🥰欢迎关注 轻松拿捏C语言系列，来和 小哇 一起进步！✊

🌈感谢大家的阅读、点赞、收藏和关注💕

---

目录👑

 一、指针与内存🪐

二、指针变量 、取地址操作符&和解引用操作符* 🌏

三、指针变量类型的意义🌔

1.指针变量类型不同决定了在解引用的时候能访问的字节数不同💛

2.指针变量类型决定了指针向前或向后的步长🧡

3.void*指针🩵

四、const修饰指针☀️

五、指针运算🌈

1、指针加减运算🌸

2、指针相减🌺

3、指针关系运算🌷

六、野指针🏵️

        1.指针变量没有初始化

        2.指针越界访问

         3.指针指向的空间被释放掉了

七、传值调用与传址调用🌻

八、一维数组与指针🌼

1.数组名的理解

2.用指针访问数组

3.一维数组传参本质

九、指针数组🌙

1.定义 

2.用指针数组模拟二维数组 

十、字符指针变量 💙

十一、数组指针变量💜

1.定义

2.数组指针变量的初始化：

3、二维数组传参的本质： 

十二、函数指针变量💗

1.定义

2.使用

3.两段代码

十三、函数指针数组💖

 1.定义

2.区分两个数组，两个指针变量 

3.函数指针数组用途——转移表

---

 

 一、指针与内存

        有一栋楼，里有200个房间，假如我们要去某个房间找某个人，然后他说他在C304，我们就能通过门牌号C304快速找到他所在房间。

        在计算机中内存划分为一个个内存单元，每个内存单元也有编号，每个内存单元占1字节的空间大小，1字节又等于8个比特位

       这相当于，内存就是一栋楼，每个内存单元就是一个房间，内存单元编号就是房间门牌号，房间里有8个床位。

        内存单元编号==地址==指针

二、指针变量 、取地址操作符&和解引用操作符* 

         int a = 10;

        这里创建了一个整型变量a，占四个字节，所以就会向内存申请四个字节大小的连续空间，每个字节的内存单元都有编号。

        通过取地址符& 我们可以得到a所占四个字节中 地址最小的内存单元 的地址，该地址就是变量a的地址

        因为这四个字节的空间连续，我们得到了这一个地址，就能挨着访问另外的地址

        拿到地址有什么用？

        我们可以将地址存储在一个变量中，用来存储地址的这个变量就叫做指针变量

       int a = 10;

       int* b = &a;

这里b就是一个指针变量，它的类型是int*类型。int*中*说明b是指针变量，int说明b指向的对象是整型（即b中存储的这个地址对应的变量a是整型）

        通过解引用操作符*,我们可以改变指针变量指向的内容

           int a = 10;

           int* b = &a;

           *b = 5；这样a中的值就从10变成了5。b中存放的是a的地址，*b就是找到b中存放的地址对应的空间，所以其实*b就是a了，*b=5就是把a变成了5。

        通过解引用操作符没有直接修改变量a，而是通过地址来间接修改

另外指针变量的大小与它的类型没有关系，在32位平台下（32个比特位），指针变量大小是4个字节；在64位平台下指针变量是8个字节。

总结一下关于指针p的三个值：

​​int a = 1;

int* p = &a;

①p        p中放着一个地址，这里是a的地址

②*p        p指向的对象，这里为a

③&p        表示变量p的地址 

        二级指针：存放一级指针变量地址的变量

int a = 10;

int* p =&a;

int** m = &p;

 

对*m = p，**m = *p = a。

三、指针变量类型的意义

1.指针变量类型不同决定了在解引用的时候能访问的字节数不同

例如，char*类型的指针解引用时只能访问一个字节，而int*类型的指针解引用能访问四个字节

int n = 0x11223344;

int *pi = &n;

*pi = 0;这里将变量n的四个字节空间的内容都改成0

int n = 0x11223344;

char *pc = (char *)&n;

*pc = 0;这里只将变量n四个字节中第一个字节的内容改为0

2.指针变量类型决定了指针向前或向后的步长

char* 类型的指针变量+1跳过1个字节， int* 类型的指针变量+1跳过了4个字节。这就是指针变量的类型差异带来的变化。

指针+1，其实跳过1个指针指向的元素。指针可以+1，那也可 以-1。

3.void*指针

void*是一种特殊的指针类型，也叫泛型指针（或无具体类型的指针）

优点：可以接收任何类型的指针

缺点：不能进行 指针+-整数的运算，不能进行 解引用操作

四、const修饰指针

        const修饰变量时，变量不能被修改

#include <stdio.h>int main(){ int m = 0; m = 20;//m是可以修改的 const int n = 0; n = 20;//n是不能被修改的 return 0;}

但是这里我们可以不直接修改变量n，可以通过它的地址来间接修改

但我们给n加上const的目的就是为了使它不能被修改，所以我们应该让p拿到n的地址后也不能间接修改n

我们可以在*p前面加上const      const int *p = &n;   或者  int const *p   这样就不能通过指针变量p来间接修改n的值了

const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。 但是指针变量本身的内容可变（就是他存储的地址可以改变）。

 const如果放在*的右边，修饰的是指针变量本身，保证了指针变量的内容不能修改（它存储的地址不能改变），但是指针指向的内容，可以通过指针改变。

五、指针运算

1、指针加减运算

        数组在内存中连续存放，找到第一个元素地址就能顺藤摸瓜找到所有元素

#include <stdio.h>int main(){ int arr[10] = {1,2,3,4,5,6,7,8,9,10}; int *p = &arr[0]; int i = 0; int sz = sizeof(arr)/sizeof(arr[0]); for(i=0; i<sz; i++) { printf("%d ", *(p+i));// p+i 这⾥就是指针+整数 } return 0;}

2、指针相减

前提：两个指针指向同一块空间

指针 - 指针的绝对值是指针间的元素个数

#include <stdio.h>int my_strlen(char *s)//s为字符串常量abc中a的地址{ char *p = s; while(*p != '\0' ) p++;当p指向\0，不再++ return p-s;指向\0的地址p减指向a的地址s，所以p-s为3}int main(){ printf("%d\n", my_strlen("abc"));//打印3 return 0;}

3、指针关系运算

地址大小比较

#include <stdio.h>int main(){ int arr[10] = {1,2,3,4,5,6,7,8,9,10}; int *p = &arr[0]; int sz = sizeof(arr)/sizeof(arr[0]); while(p<arr+sz) //指针的⼤⼩⽐较 { printf("%d ", *p); p++; } return 0;}

六、野指针

指针指向的位置是未知的、不正确的、随机的，那么这个指针就是野指针。

        野指针成因：

        1.指针变量没有初始化

int *p;//局部变量指针未初始化，默认为随机值

*p = 20;

        规避方法，将指针初始化

        当不知道指针变量该指向哪里时，可以给指针赋值NULL. NULL 是C语⾔中定义的⼀个标识符常量，值是0，0也是地址，这个地址是无法使用的，读写该地址会报错。 

        2.指针越界访问

#include <stdio.h>int main(){ int arr[10] = {0}; int *p = &arr[0]; int i = 0; for(i=0; i<=11; i++) { //当指针指向的范围超出数组arr的范围时，p就是野指针 *(p++) = i; } return 0;}

         3.指针指向的空间被释放掉了

#include <stdio.h>int* test(){ int n = 100;//局部变量n return &n;//该函数结束后，创建的变量n会被销毁}int main(){ int*p = test(); printf("%d\n", *p); return 0;}

七、传值调用与传址调用

        通过一个题来感受一下什么是传值调用，什么是传址调用

写一个函数，交换整型变量的值

#include <stdio.h>void Swap(int x, int y){ int tmp = x; x = y; y = tmp;}int main(){ int a = 0; int b = 0; scanf("%d %d", &a, &b); printf("交换前：a=%d b=%d\n", a, b); Swap(a, b); printf("交换后：a=%d b=%d\n", a, b); return 0;}

但是我们却发现a和b的值却没有交换

调试看一下：

通过调试我们发现，虽然a确实把值传给了x，b把值传给了y，但是a的地址和x的地址不是同一个地址，b的地址和y的地址也不是同一个地址。

这是因为变量x和y是在Swap函数内部创建的，变量x和变量y是两个独立的空间，因此x和y交换值对变量a和b是没有影响的。

像这样把变量的值传给函数，这就是传值调用。

把实际参数传递给形式参数时，形参会单独创建一个空间来接收实参，因此形参的改变对实参没有影响。

所以我们可以将a和b的地址传过去，通过地址将a和b的值交换。 

#include <stdio.h>void Swap(int* x, int* y){ int tmp = *x; *x = *y; *y = tmp;}int main(){ int a = 0; int b = 0; scanf("%d %d", &a, &b); printf("交换前：a=%d b=%d\n", a, b); Swap(&a, &b); printf("交换后：a=%d b=%d\n", a, b); return 0;}

 交换成功。

像这样把变量的地址传递给函数，这就是传址调用。

所以在函数中需要改变主调函数中变量的值，我们可以采用传址调用；如果仅需要在函数内利用变量的值来计算，就采用传值调用。

八、一维数组与指针

1.数组名的理解

数组名是数组首元素的地址

#include <stdio.h>int main(){ int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; printf("&arr[0] = %p\n", &arr[0]); printf("arr = %p\n", arr); return 0;}

 数组名和数组首元素打出的地址一样。

但是有两个例外：

       1、 sizeof(数组名)，sizeof中单独放数组名，这的数组名表示整个数组，计算的是整个数组的大小， 单位是字节

       2、 &数组名，这的数组名表示整个数组，取出的是整个数组的地址

这里讲一下&arr和arr的区别：

可以看出它们三个打印出的一模一样，没区别呀？

这时就发现，&arr[0]和arr加1，它们地址都只加了 4，而&arr加1后，它的地址加了40。

这时因为&arr[0]和arr都是首元素的地址，它们加1，就是跳过一个元素

而&arr是整个数组的地址，它加1就是跳过整个数组

2.用指针访问数组

#include <stdio.h>int main(){ int arr[10] = {0}; //输⼊ int i = 0; int sz = sizeof(arr)/sizeof(arr[0]); //输⼊ int* p = arr; for(i=0; i<sz; i++) { scanf("%d", p+i); //scanf("%d", arr+i);//也可以这样写 } //输出 for(i=0; i<sz; i++) { printf("%d ", *(p+i)); } return 0;}

将*(p+i)换成p[i]也是能够正常打印的，所以本质上p[i] 是等价于 *(p+i)。

同理arr[i] 应该等价于 *(arr+i) 。

3.一维数组传参本质

之前我们都是在主函数里计算数组元素的个数，那能在函数里计算吗？

#include <stdio.h>void test(int arr[]){ int sz2 = sizeof(arr)/sizeof(arr[0]); printf("sz2 = %d\n", sz2);}int main(){ int arr[10] = {1,2,3,4,5,6,7,8,9,10}; int sz1 = sizeof(arr)/sizeof(arr[0]); printf("sz1 = %d\n", sz1); test(arr); return 0;}

这个代码看上去感觉sz1和sz2算出来是一样的，但并不是这样。 

上面讲过，arr表示数组首元素的地址，因此在形参中我们应该用一个int* 类型的指针变量来接受实参，所以形参中int arr[]只是写成了数组的形式，本质上还是一个指针变量。

所以在函数内部sizeof（arr）计算的是数组首元素的地址的大小，并不是整个数组的大小

（这里提一个点，在32位的环境下 指针变量占4字节，64位环境下 指针变量占8字节，所以不同环境下sz2可能算出来一个是1，一个是2）。

九、指针数组

1.定义 

        指针数组是一个存放指针的数组，是数组。

        类比，整型数组是存放整型的，字符数组是存放字符的数组。

所以指针数组的每个元素存储的都是地址，类型都为指针类型，每个元素又能通过指针指向一块空间。

一个指针数组arr，长度为5，元素类型为int*类型 即元素都是 整型指针变量 的地址。

int* arr[5] = {&a1,&a2,&a3,&a4,&a5};

那么这个数组arr的类型 为 int* [5]

2.用指针数组模拟二维数组 

#include <stdio.h>int main(){ int arr1[] = {1,2,3,4,5}; int arr2[] = {2,3,4,5,6}; int arr3[] = {3,4,5,6,7}; //数组名是数组⾸元素的地址，类型是int*的，就可以存放在parr数组中 int* parr[3] = {arr1, arr2, arr3}; int i = 0; int j = 0; for(i=0; i<3; i++) { for(j=0; j<5; j++) { printf("%d ", parr[i][j]); } printf("\n"); }

parr[i]是访问parr数组的元素，parr[i]找到的数组元素指向了整型⼀维数组，parr[i][j]就是整型⼀维数组中的元素。 

但这并非是二维数组，二维数组是连续的一块空间，但指针数组模拟的并不是连续的。

十、字符指针变量 

有一种指针类型是 char* 类型

        它是把一个字符的地址放进指针变量中

#include<stdio.h>{ char a = 'w'; char* p = &a; printf("%c\n",*P); return 0;}

请问下面这个代码是把⼀个字符串放到pstr指针变量里了吗

int main(){ const char* pstr = "hello Bao Gengxiaowa."; printf("%s\n", pstr); return 0;}

并不是！

 它是将字符串hello Bao Gengxiaowa.的首元素地址即h的地址放进指针变量中。

用%s打印字符串，只需要传首元素的地址。

 

现在来看一段代码：

#include <stdio.h>int main(){ char str1[] = "hello Bao Gengxiaowa."; char str2[] = "hello Bao Gengxiaowa."; const char *str3 = "hello Bao Gengxiaowa."; const char *str4 = "hello Bao Gengxiaowa."; if(str1 ==str2) printf("str1 and str2 are same\n"); else printf("str1 and str2 are not same\n"); if(str3 ==str4) printf("str3 and str4 are same\n"); else printf("str3 and str4 are not same\n"); return 0;}

❓ 你觉得程序允许后屏幕会打印哪些语句？

你对了吗😃

这是因为str1和str2是两个数组首元素的地址，是两个不同的地址。

        所以str1、str2 not same

而str3、str4都是字符指针变量，都存放的是字符串 hello Bao Gengxiaowa.的首元素h的地址。

        所以str3、str4 same

十一、数组指针变量

1.定义

        数组指针变量是一个指向数组的指针，存储的是数组的地址，它不是数组

类比一下：

        整型指针变量 int* p;存储的是一个int型变量的地址，指针类型是 int*。

        字符指针变量 char* p；存储的是一个char类型变量的地址，指针类型是 char*。

看看这两个分别是什么：

int *p1[10];

int (*p2)[10];

        第一个是 一个数组长度为10，数组元素类型为 int* 的 指针数组，存储的是指针（地址）。

        第二个是 一个指向的 数组长度为10 数组元素类型为 int 的 数组指针，这个数组指针变量中存储的是数组的地址。 这个指针变量的类型为 int （*）[10]

注意：[]的优先级要高于*号的，所以在数组指针变量中，必须加上（）来保证p先和*结合，否则p和[]先结合，那就是一个指针数组了。

2.数组指针变量的初始化：

int arr[10] = {0};

int (*p)[10] = &arr;//数组的地址 

p和&arr的类型一致，都是int （*）[10]类型。

p是这个数组指针变量的变量名，10表示p指向的数组元素个数，int为数组元素的类型。

3、二维数组传参的本质： 

#include <stdio.h>void test(int a[3][5], int r, int c){ ………}int main(){ int arr[3][5] = { {1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7}}; test(arr, 3, 5); return 0;}

这里实参是二维数组，形参也是二维数组的形式 ，知道了数组指针后 参数还能有别的写法吗？

二维数组可以看成是一个 一维数组 的数组，每一行就是一个一维数组，那么二维数组首元素的地址就是第一行的地址

第一行数组元素类型为 int [5]，所以第一行元素的地址的类型为 int (*)[5]

所以二维数组传参的本质是 传递了地址，传递的是第一行这个一维数组的地址。

所以形参也可以写成指针形式：

#include <stdio.h>void test(int (*p)[5], int r, int c){ int i = 0; int j = 0; for(i=0; i<r; i++) { for(j=0; j<c; j++) { printf("%d ", *(*(p+i)+j)); } printf("\n"); }}int main(){ int arr[3][5] = { {1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7}}; test(arr, 3, 5); return 0;}

十二、函数指针变量

1.定义

        函数指针变量是存放函数地址的变量，能通过这个变量或地址来调用函数

        函数名 就是函数的地址，也可以在函数名的前面加上&来获取地址（加不加&都一样）

  写法：

void test(){ printf("hehe\n");}void (*pf1)() = &test;void (*pf2)()= test;int Add(int x, int y){ return x+y;}int(*pf3)(int, int) = Add;int(*pf3)(int x, int y) = &Add;//x和y写上或者省略都是可以的

那int(*pf3)(int, int)举例，pf3是函数指针变量的变量名，

函数指针变量pf3的类型（就是函数地址的类型）是int(*)(int,int)

它指向的函数的参数有两个，类型都为int，函数的返回值类型为int。

2.使用

#include <stdio.h>int Add(int x, int y){ return x+y;} int main(){ int(*pf3)(int, int) = Add; printf("%d\n", (*pf3)(2, 3)); printf("%d\n", pf3(3, 5)); return 0;}

这里printf中的*pf3和pf3都是函数Add地址，所以(*pf3)(2,3)和pf3(3,5)都是在调用函数Add。 

3.两段代码

来看两段代码

(*(void (*)())0)();

 这个代码中，void (*)()是一个函数指针类型，它指向的函数没有形参，返回值类型为void。

void (*)()放在整数0的前面表示强制类型转换，将整型的数字0转换成void (*)()类型的 地址0。

所以这是一次函数调用，调用0地址处放的那个函数，0地址处放的函数没有参数，返回值也是void

void (*signal(int , void(*)(int)))(int); 

这整个代码表示的是一个 函数的声明。

函数名字是signal，函数参数有两个，一个是int类型，一个是 void(*)(int)函数指针类型。

函数的返回值类型也是 void(*)(int)函数指针类型，也就是说函数signal的返回值是一个函数的地址。

但是 我们并没有写成 void(*)(int) signal(int , void(*)(int))，而是把函数名和参数放进返回值类型里面，所以就是void (*signal(int , void(*)(int)))(int); 

十三、函数指针数组

 1.定义

是一个用来存放函数指针的数组

定义：int (*p[3])();

p先和[3]结合表示数组，数组中存放的是int (*)()类型的函数地址。

我们可以这样使用

int func1() { return 1; } int func2() { return 2; } int func3() { return 3; } int (*p[3])() = {func1, func2, func3};

2.区分两个数组，两个指针变量 

我们来区分一下这几个是什么：

1、int (*p[3])();  //函数指针数组

2、int*(p[3]);      //指针数组

3、int (*p)();      //函数指针变量

4、int (*p)[3];    //数组指针变量

 第1个中p是一个数组，它包含 3 个元素，每个元素都是int (*)()类型

第2个中，p是一个数组，有3个元素，每个元素都是int*类型

第3个中，p是一个指针变量，它存储的是一个函数的地址，这个函数返回值为int型，没有形参

第4个中，p也是一个指针变量，存储的是一个数组的地址，数组有3个int型的元素。

3.函数指针数组用途——转移表

使用转移表比使用switch语句更加灵活，因为你可以动态地改变转移表的内容，而不需要修改调用转移表的代码。

举例：分别用switch和转移表来实现一个计算器功能

用switch：

#include<stdio.h>void menu(){printf("====================================\n");printf("********* 1.add 2.sub **********\n");printf("********* 3.mul 4.div **********\n");printf("********* 0.exit 退出 **********\n");printf("====================================\n");}int add(int x, int y){return x + y;}int sub(int x, int y){return x - y;}int mul(int x, int y){return x * y;}int div(int x, int y){return x / y;}int main(){int input = 0;int x = 0;int y = 0;int ret = 0;do{menu();printf("请选择："); scanf("%d", &input); switch (input) { case 1: printf("输⼊操作数："); scanf("%d %d", &x, &y); ret = add(x, y); printf("ret = %d\n", ret); break; case 2: printf("输⼊操作数："); scanf("%d %d", &x, &y); ret = sub(x, y); printf("ret = %d\n", ret); break; case 3: printf("输⼊操作数："); scanf("%d %d", &x, &y); ret = mul(x, y); printf("ret = %d\n", ret); break; case 4: printf("输⼊操作数："); scanf("%d %d", &x, &y); ret = div(x, y); printf("ret = %d\n", ret); break; case 0: printf("退出程序\n"); break; default: printf("选择错误\n"); break;} while (input);return 0;}

用函数指针数组（转移表）：

#include<stdio.h>void menu(){printf("====================================\n");printf("********* 1.add 2.sub **********\n");printf("********* 3.mul 4.div **********\n");printf("********* 0.exit 退出 **********\n");printf("====================================\n");}int add(int x, int y){return x + y;}int sub(int x, int y){return x - y;}int mul(int x, int y){return x * y;}int div(int x, int y){return x / y;}int main(){int input = 0;int x = 0;int y = 0;int ret = 0; //函数指针数组int (*arr[5])(int, int) = {0,add,sub,mul,div };do{menu();printf("请选择：");scanf("%d", &input);if (input >= 1 && input <= 4){printf("请输入两个操作数");scanf("%d %d", &x, &y);ret = arr[input](x, y);printf("%d\n", ret);}else if (input == 0)printf("退出计算器\n");elseprintf("输出错误，请选择0-4\n");} while (input);return 0;}

 用转移表代码量大大减少，能提高程序效率。

---

 🎉🎉🎉本文内容结束啦，希望各位大佬多多指教！

🌹🌹感谢大家三连支持

💕敬请期待下篇文章吧~