前言?
谈到指针，想必大家都不陌生。它不仅是C语言的重难点，还是不少C初学者的噩梦。本期我们将深度探讨一些较为复杂的指针以及指针的妙用，带领大家感受指针的魅力?。
首先，我们先来复习复习指针的概念：
1. 指针就是地址，而 指针变量是个变量，用来存放地址（指针），地址标识着一块唯一的内存空间。例如有一张纸，上面写着湖滨东路12号，那湖滨东路12号是什么呢？它就是一个地址，一个指针；而这个地址的载体纸便是指针变量，修改纸上的内容就相当于修改了指针变量存放的内容，即修改了指针。2. 指针的大小是固定的 4/8个字节（32位平台/64位平台）。
3. 指针是有类型，指针的 类型决定了指针的+-整数的步长和指针解引用操作的时候的权限。
4.指针和指针不能进行加法运算，这是没有意义的；但可以进行 减法运算，运算的结果表示 间隔的元素个数。
下面，让我们怀着激动的心情，正式进入进入今天的主题✨
字符指针?
我们知道，指针有一种类型叫字符指针，我们一般有以下方法使用它：
//指向一个字符变量int main(){ char ch = 'c'; char* pch = &ch; *pch = 'w'; return 0;}//指向一个字符串int main(){ const char* str= "abcdef"; printf("%s\n", str); return 0;}对于第一种，毫无疑问，pch存放的是字符变量ch的地址。但是对于第二种，我们是将整个字符串放到str里面吗？实则不然，我们是将"abcdef"的首元素地址存放到str中。如下：
上述代码实际上是将"abcdef"中'a'的地址放到指针变量str中。有了这层理解，我们来看看下面一道面试题：
int main(){ char str1[] = "hello bit."; char str2[] = "hello bit."; const char* str3 = "hello bit."; const char* str4 = "hello bit."; 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想必大家没有问题，这两个数组都用"abcdef"来进行初始化，它们的 存放的内容一样。但是毕竟是两个不同的数组，它们 在内存中的地址是不同的，因此它们首元素的地址也是不同的，并且 数组名代表首元素地址，因此str1不等于str2。就好比定义变量a=10，变量b=10，虽然a == b，但是&a != &b。
而有疑问的可能是 str3和str4，这里需要注意的是，它们存放的都是字符串"abcdef"首元素的地址，而在C/C++中，一个常量字符串通常会单独存放在地址空间中的字符常量区，因此str3和str4指向的其实是同一块内存空间。如下：
指针数组与数组指针✈
3.1 引入
这两兄弟长得很像，很容易让初学者记混。我们需要记住指针数组是一个数组，它的每一个元素是指针；而数组指针是一个指针，它指向一个数组。
个人认为：无论名称多么复杂，后缀一般就是其类型。试问下面几条语句表达什么：
int* arr[10];int (*arr)[10];int (*arr[10])[10];对于第一条，arr毋庸置疑是变量名。首先arr会先和[]结合，因此arr是一个数组，一个每个元素是整形指针的指针数组。
对于第二条，arr与*号结合，因此arr是一个指针，指向一个整形数组，arr是一个数组指针。
对于第三条，同样由于[]的优先级比*号高，因此arr先与[]结合，arr是一个数组，每个元素的类型是int （*）[10]，即是一个整形数组指针。综上，arr是一个存放整形数组指针的数组。
如果你想，你甚至可以无限套娃下去，这里就留给读者自己尝试啦 ?3.2 使用方法
对于数组指针，既然它是指向数组的，那数组指针中存放的应该是数组的地址，我们来看如下代码：
int main(){ int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; int(*p1)[10] = &arr;//正确？错误？ int(*p2)[10] = arr; //正确？错误？ return 0;}我们知道数组名arr代表首元素地址，但也有两个例外，分别是&数组名和sizeof(数组名)，这两种情况下arr代表的就不是首元素地址了，而是整个数组。因此，p1才是正确的使用方法。
我们可以通过数组指针将一个数组的地址保存起来，不过我们很少这样写代码，数组指针一般用在数组传参上，如下：
void print_arr1(int arr[3][5], int row, int col) //形参用数组的形式接收{ for (int i = 0 ; i < row; i++) { for (int j = 0; j < col; j++) { printf("%d ", arr[i][j]); } printf("\n"); }}void print_arr2(int(*arr)[5], int row, int col) //形参用指针的方式接收{ for (int i = 0; i < row; i++) { for (int j = 0; j < col; j++) { printf("%d ", arr[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} }; print_arr1(arr,3,5); print_arr2(arr, 3, 5); return 0;}事实上， 数组传参是会发生降维的，降维成 指向其内部元素类型的指针。 如果不降维，就要发生数组拷贝，数组空间过大，函数调用效率降低，因此需要降维。如二维数组传参，就会降维成指向一维数组的指针。
而我们可以 把二维数组看作一个一维数组，数组中的每一个元素都为一个 一维整形数组。那么二维数组arr传参，发生降维后传的就是首个整形数组的地址，因此可以 用一维整形数组指针来接收。
而对于指针数组，其存放的就为一个个指针变量，如下：
int main(){ char* s1 = "hello"; char* s2 = "world"; char* arr[2] = { s1,s2 }; for (int i = 0; i < 2; i++) { printf("%s ", arr[i]); } return 0;}4. 数组/指针传参?
我们在写代码的时候难免要将数组或者指针作为参数传递给函数，下面我们就来介绍以下如何正确地设计函数参数。4.1一维数组传参
void test01(int arr[10]) {}; //1 ok?void test01(int arr[]) {}; //2 ok?void test01(int* arr) {}; //3 ok?void test02(int* arr[10]) {}; //1 ok?void test02(int** arr) {}; //2 ok?int main(){ int arr1[10] = {0}; int* arr2[10] = { 0 }; tesst01(arr1); test02(arr2); return 0;}对于 tesst02()，arr2为整形指针数组，每一个元素是整形指针，传入的即为指向整形指针的指针，即 二级指针，因此 两种写法均正确。
4.2二维数组传参
void test(int arr[3][5]) {}; //1 ok？void test(int arr[][]) {}; //2 ok？void test(int arr[][5]) {}; //3 ok？void test(int* arr) {}; //4 ok？void test(int* arr[5]) {}; //5 ok？void test(int(*arr)[5]) {}; //6 ok？void test(int** arr) {}; //7 ok？int main(){ int arr[3][5] = { 0 }; test(arr);}其次我们来看以指针的形式接收，二维数组传参降维为指向一维数组的指针，所以我们也需用 一维整形数组指针来接收。而4是整形指针，5是指针数组，7是二级指针， 因此只有6是正确的写法。
4.3一级指针传参
当实参是一级指针时，很简单，不要想的太复杂，函数形参就使用 一级指针接收。并没有用一维数组接收的做法。如下：#include <stdio.h>void print(int* p, int sz) //用整形指针接收{ int i = 0; for (i = 0; i < sz; i++) { printf("%d\n", *(p + i)); }}int main(){ int arr[10] = { 1,2,3,4,5,6,7,8,9 }; int* p = arr; //arr：首元素地址，整形指针接收 int sz = sizeof(arr) / sizeof(arr[0]); //一级指针p，传给函数 print(p, sz); return 0;}下面我们可以思考以下，当函数形参是一级指针时，函数可以接收什么参数呢？
Sush as：
void test01(int* p); //test01()能接收什么参数void test02(char* p); //test02()能接收什么参数对于test01()，形参是整形指针，因此毋庸置疑可以 接收一个整形指针；并且由于一维整形数组传参时传入的也是整形指针，因此也可以 接收一维整形数组：
void test(int* p) {};int main(){ int n = 10; int* pn = &n; int arr[10] = { 10 }; //传入一级整形指针 test(&n); test(pn); //传入整形数组 test(arr); return 0;}void test(char* p) {};int main(){ char c = 'b'; char* pc = &c; char arr[10] = { 'b'}; //传入一级字符指针 test(&c); test(pc); //传入字符数组 test(arr); return 0;}4.4二级指针传参
同理，二级指针传参，函数形参用二级指针接收：void print(int** p) //形参用二级指针{ printf("num = %d\n", **p);}int main(){ int n = 10; int* p = &n; int** pp = &p; //二级指针 print(pp); //二级指针传参 return 0;}那么，当函数形参是二级指针，函数又可以接收什么参数呢？
void test01(int** p) //test01()接收什么参数void test02(char** p) //test02()接收什么参数void test(int** p) {};int main(){ int n = 10; int* pn = &n; int** ppn = &pn; int* arr[10] = { pn }; //传入二级整形指针 test(&pn); test(ppn); //传入一级整形指针数组 test(arr); return 0;}void test(char** p) {};int main(){ char c = 'b'; char* pc = &c; char** ppc = &pc; char* arr[10] = {pc}; char* arr1[10] = { "hello","world" }; //传入二级字符指针 test(&pc); test(ppc); //传入一级字符指针数组 test(arr); //传入字符串数组 test(arr1); return 0;}5. 函数指针⛄
5.1 引入
在C语言中，函数也是有地址的，函数是代码的一部分，程序在运行时，要先将代码加载到内存中以便后续访问，而代码就保存在C程序地址空间中的代码区中。我们来看以下代码：
int main(){ printf("%p\n", main); printf("%p\n", &main); return 0;}
输出的地址即为main函数在代码区的地址。既然是地址，我们能不能将它保存起来呢？这就要谈谈我们的主角了： 函数指针（Function pointer） 5.2 函数指针的使用
int test(int x){ return x + 10;}int main(){ int (*p1)(int x) = test; int (*p2)(int x) = &test; return 0;}上述p1和p2其实都是指向test函数的指针，这是因为与数组不同的是， 函数名和&函数名等价，都为函数的地址。因此，我们可以用以下两种方法调用函数：
int test(int x){ return x + 10;}int main(){ int (*p1)(int x) = test; printf("p1: %d\n", (*p1)(10)); //1 printf("p1: %d\n", p1(10)); //2 return 0;}5.3两个有趣的代码
我们来分析一下下面两条语句：
//代码1(*(void (*)())0)();//代码2void (*signal(int , void(*)(int)))(int);而对于 代码2： 主体就为signal，signal先于括号结合，因此为一个函数，有两个参数，一个为整形，另一个为函数指针。然后剩下的就为signal的返回值，为函数指针。因此代码2就是 声明一个signal函数 ，函数有两个参数：整形和函数指针，返回值为函数指针。
6. 函数指针数组?
6.1引入
我们之前学过了指针数组，其存放的每个元素类型是指针。那当我们把函数的地址保存到数组中，这个数组就叫函数指针数组。写法如下：
int(*pa[10])()6.2 应用-转移表
假设我们需要实现一个整数计算器，具有加减乘除的功能，我们可能会这样写代码：
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;}void menu(){ printf("*************************\n"); printf(" 1:add 2:sub \n"); printf(" 3:mul 4:div \n"); printf(" 0:exit \n"); printf("*************************\n");}int main(){ int x, y; int input = 0; int ret = 0; do { menu(); printf("请选择:> "); scanf("%d", &input); switch (input) { case 0: break; 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; default: printf("输入错误，请重新输入\n"); break; } } while(input); return 0;}当我们计算器的选项越来越多，switch-case语句也会越来越长，并且我们发现switch-case语句中每个分支我们做的操作都非常相似，显得代码十分冗长。那我们要如何优化这个代码呢？嘿嘿，这就要问问神奇的函数指针数组了：
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;}void menu(){ printf("*************************\n"); printf(" 1:add 2:sub \n"); printf(" 3:mul 4:div \n"); printf(" 0:exit \n"); printf("*************************\n");}int main(){ int x, y; int input = 0; int ret = 0; int (*pa[5])(int, int) = { NULL,add,sub,mul,div }; //转移表 int sz = sizeof(pa) / sizeof(pa[0]); do { menu(); printf("请选择:> "); scanf("%d", &input); if (input > 0 && input < sz) { printf("请输入两个操作数:> "); scanf("%d %d", &x, &y); ret = pa[input](x, y); printf("%d\n", ret); } else if(input!=0) { printf("输入有误，请重新输入\n"); } } while (input); return 0;}其次，当input为函数指针数组pa的有效下标时，就通过对应下标的函数指针调用函数，这种通过下标来实现跳转到相应函数的函数指针数组我们就称作 转移表。简单来说， 转移表就是一个函数指针数组，数组的内容是自定义函数，我们通过数组下标访问自定义函数。
最后，当我们后续需要添加函数时，我们只需要在转移表(函数指针数组)中添加对应函数即可，十分方便 。
注意❗
由于数组每个元素类型相同，因此转移表中函数指针的类型必须严格一致，即指向的自定义函数参数列表和返回值都要一样，否则转移表就不适用了。例如：上面将计算器的除法函数返回值改为double，我们就不能单纯的使用一个转移表来编写代码了。
7. 指向函数指针数组的指针?
指向函数指针数组的指针是一个指针，指针指向一个数组，数组的每一个元素都是指针，那我们应该如何定义它呢？来看以下代码：
void test(const char* str){ printf("%s", str);}int main(){ //定义一个函数指针 void(*pf)(const char*) = test; //定义一个函数指针数组 void(*arr[5])(const char*); //给函数指针数组第一个元素赋值 arr[0] = test; //定义一个指向函数指针数组的指针，并将其指向函数指针数组 void(*(*parr)[5])(const char*) = &arr; return 0;}我们来看这条语句，首先parr先于*号结合，说明它是一个指针；然后与[]结合，说明它指向了一个数组。然后剩余的部分就是数组的元素类型，是一个函数指针。综上， parr是一个指向函数指针数组的指针变量，存放着arr这个函数指针数组的地址。
?以上，就是本期的全部内容啦
?像指针这种高档食材，我们当然要细细品味,剩下的部分我们就留到下期不见不散啦^-^
制作不易，能否点个赞再走呢?