【C语言】指针（3）：探索-不同类型指针变量

一、字符指针变量

二、数组指针变量

三、二维数组传参的本质

四、函数指针变量

4.1 函数指针变量

4.2 函数指针变量的使用

4.3 函数指针变量的拓展

五、函数指针数组

六、转移表的应用

通过深入理解指针（1）和深入理解指针（2），我们对指针有了一个初步的了解，学会了一级指针、二级指针、指针数组……而深入理解指针（3），主要是为了学习不同数据类型的指针变量。

一、字符指针变量

字符串指针变量的指针类型为char*，下面我们通过这段代码来解析字符指针变量。

int main()
{printf("指针接收字符\n");char ch = 'w';char* pc = &ch;printf("\t*pc=%c\n", *pc);printf("----------------\n");printf("指针接收字符串\n");const char* pstr = "abcdef";//const 加了一层保护，使其变成常量字符串，被修改编译器会报错printf("\t*pstr=%c\n", *pstr);//其实是把字符串的首字符地址放到pstr,字符串出现在表达式中时，他的值就是第一个字符的地址printf("\tpstr=%s\n", pstr); //%s占位符的特点就是只要告诉他字符串的首地址, 就可以读取整个字符串printf("\tpstr[3]=%c\n", pstr[3]);//[]是特殊的解引用操作符，等价于*（pstr+3），相当于得到第1个元素偏移3得到第四个元素printf("\tabcdef[3] = % c\n", "abcdef"[3]);//可以把字符串想象成一个字符数组，可以通过下标去访问他return 0;
}

指针接收字符
*pc=w
----------------
指针接收字符串
*pstr=a
pstr=abcdef
pstr[3]=d
abcdef[3] = d

字符指针变量，顾名思义就是指向字符的指针变量，所以利用指针接收字符的地址（第31行代码），最后解引用该指针变量得到的是对应的字符，非常容易理解。但字符指针变量还有一种方式，就是接收字符串的地址。

通过第35行代码，我们用字符指针变量pstr接收了字符串“abcdef”，那这是把整个字符串放到pstr指针变量里面了吗？

其实并不是的，我们通过第36行代码的运行结果，发现将指针变量pstr解引用后得到的是‘a’，这说明字符指针变量pstr接收字符串的本质是将字符串的首字符地址存放到pstr中，所以如果字符串出现在表达式中，他的值就是第一个字符的地址。

既然pstr存放的是字符串首字符的地址，那么我们打印出来的是一个地址，但我们在看向第37行代码，当我们用%s的占位符时，却可以直接将整个字符串打印出来，这说明了%s占位符的特点就是只要告诉他字符串首字符的地址，他就可以直接读取整个字符串。

那为什么，我们知道了字符串的首元素地址，就可以通过%s打印出字符串全体呢？这是因为其实我们可以把字符串理解成一个字符数组，他具有数组的特点，可以通过首元素地址找到后面的全部元素，并且也可以像数组一样通过下标去访问每个元素，比如我们想访问字符串下标为3的元素（d），那么通过第39行代码我们可以发现“abcdef”[3]是可行的，

既然可以通过下标去访问字符串，那么既然pstr是接收字符串的指针变量，那么我们同样可以通过首元素地址的指针偏移来找到下标为3的元素，第38行代码中的pstr[3]（等价“*（pstr+3）”）也是可行的。

下面是一道和字符串相关的面试题。

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");elseprintf("str1 and str2 are not same\n");if (str3 == str4)printf("str3 and str4 are same\n");elseprintf("str3 and str4 are not same\n");return 0;
}

str1 and str2 are not same
str3 and str4 are same

为什么str1和str2的地址不同，而str3和str4的地址相同呢？？

将常量字符串赋值给数组（str1和str2），本质上是将这个常量字符串复制一份到数组中，这两个数组其实并不在一个空间，所以str1=str2，并且复制出来的常量字符串是可以修改的。

而如果通过字符指针变量指向常量字符串（str3和str4），对于常量字符串来说，是只能读不能改的，从内存利用率来说，内容相同的字符串只会保存一份，所以str3=str4.

二、数组指针变量

我们学过指针数组，它是一个存放指针的数组。

那什么是数组指针变量呢？我们通过已经学过的指针变量来类比一下。

所以数组指针变量是一个存放的是数组的地址，并且能够指向数组的指针变量。

int* p1[10];
int(*p2)[10];

以上哪个是数组指针变量呢？

对于int*p1[10]来说，首先p1会先和[ ]结合，然后int和*结合，所以p1有10个元素，并且每个元素是int*类型，所以p1是一个存放指针的数组，p1是指针数组。（[ ]的优先级高于*）

对于int（*p2）[10]来说，p2先和*结合了，所以*p2是一个指针，int和[10]代表p2指向的是一个数组，并且有10个元素，并且每个元素的类型是int，所以p2是数组指针。(因为[ ]的优先级高于*，所以必须加上（）来保证p和*先结合)

那数组指针如何初始化呢？既然指针变量是用来存放数组地址的，而&arr是取整个数组的地址，所以写法就是int（*p2）[10]=&arr。

三、二维数组传参的本质

数组指针有什么用呢?其实数组指针有自己的应用场景，在此之前要先了解二维数组传参的本质

以往我们对有一个二维数组需要传递给函数时，我们是这样写的

void test(int a[][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 2 3 4 5
2 3 4 5 6
3 4 5 6 7

形参和实参都是二维数组的形式，但其实还有其他写法。

对于二维数组来说，可以看做是每个元素是一维数组的数组，也就是二维数组的每个元素是一个一维数组。那么二维数组的首元素就是第一行，是个一维数组。

根据一维数组的数组名名就是首元素地址、一维数组传参本质是传递首元素地址这个规则，我们可以推出二维数组的数组名就是就是第一行（一维数组）的地址，二维数组传参本质是传递第一行这个一维数组的地址。

根据上面的代码，我们知道该二维数组第一行的一维数组的数据类型是int[5]，所以第一行的地址类型就是数组指针类型int(*)[5],所以我们可以将形参类型写成指针形式。

接下来对上面的代码进行改写，将形参写成数组指针类型。

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 2 3 4 5
2 3 4 5 6
3 4 5 6 7

怎么去理解*(*(p+i)+j))呢？我们要进行拆解！（假设访问二维数组中的一个元素）

首先是p+i，二维数组的首元素地址是第一行的一维数组，所以p存放的是第一行的地址，所以+i会跳过i行，i=0时，此时跳过0行，拿到的是第一行的地址，i=1时，跳过1行，拿到的是第二行的地址，i=2时，跳过2行，拿到的是第三行的地址。

然后是*（p+i），假设i已经确定，此时就是通过解引用拿到了一行的数据。

然后是*（p+i）+j，此时*（p+i）已经拿到一行的数据了，通过j来访问这一行的其他元素地址，当j=0时，就是首元素地址，j=1时，就跳过一个元素，拿到第二个元素的地址，以此类推，找到了该行所有元素的地址。

然后是*(*(p+i)+j))，假设j已经确定，此时*（p+i）+j就是一个元素的地址，再对他进行解引用，找到该元素。

底层逻辑还是通过指针的偏移量去访问每个元素。所以p[i][j]的写法也是可行的。

所以根据二维数组传参的本质-----传递首行这个一维数组的地址，我们找到了数组指针变量的应用场景。

四、函数指针变量

4.1 函数指针变量

通过类比，函数指针就是指向函数的指针，那么函数指针变量就是用来存放函数的地址。

对应数组arr来说，arr是数组首元素地址，而&arr代表是整个数组的地址，而对于函数来说，函数名是函数的地址，&函数名也是函数的地址。

既然函数指针变量是用来存放函数的地址的，所以未来也可以通过函数的地址去调用函数。

函数指针怎么创建？

int(*p)(int, int) = Add;
int(*p)(int x, int y) = &Add;

（）将*和p结合起来，说明这是一个指针，（int，int）说明这个指针指向一个函数，并且形参类型是int和int，开头的int说明该函数的返回类型是int。

add和&add是一样的，因为对于函数来说，函数名是地址，&函数名也是地址

同理*p和p也是一样的，函数指针变量是可以不需要解引用。

形参的形参名可写可不写

int       （*pf3）   （int x,  int y）|            |      ————————————————|            |              ||            |     pf3指向函数的参数类型和个数交代|       函数指针变量名
pf3指向函数的返回类型int （*）（int x， int y）//pf3函数指针变量的类型

4.2 函数指针变量的使用

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;
}

5

8

注意：因为Add和&Add都是函数的地址，所以对于pf3来说，即使不解引用也是可以调用函数的，但如果解引用了，一定要记得用括号（）将*和pf3放在一起！！

4.3 函数指针变量的拓展

fun1(char* p, int (*)(char*));(*(void (*)())0)();void (*signal(int, void(*)(int)))(int);

分析这3个代码

1.fun1的的第1个形参的类型是字符指针，第2个形参int（*）（char*），（*）代表这个形参是个指针，int和（char*）表名这是一个函数指针，形参类型为字符指针，返回值为整型。函数指针作为其他函数的形参时，其自身的函数名和形参名可以省略，仅保留数据类型即可。

2.多个括号要逐步拆解，void（*）（）说明这是一个void类型的函数指针，没有形参，类型放在（）,就是强制类型转换，所以（void（*）（）0）的意思时将0这个整数值强制转换成一个void（*）（）类型的函数指针，再进行解引用，得到的是函数指针的地址，结尾的（）就是调用0地址处的函数。所以上述代码实际上是一个函数调用，将0转化成一个void（*）（）类型的函数地址，再去调用0地址处的函数。

3.首先，*没有和signal在一起，signal（int，void（*）（int））说明signal是一个函数名，该函数的形参有两个类型，一个是int，一个是void（*）（int）类型的函数指针，剩下的部分就是该函数的返回类型，所以signal的返回类型是void（*）（int）类型的函数指针。上述代码其实是一个函数声明。

通过上述的扩展，我们复习到了

1.认识函数指针类型

2.强制类型转换

3.通过函数指针调用函数的方式

4.函数的定义、声明、调用

4.4 typedef关键字

typedef是用来类型重命名的，可以将复杂的类型简单化

typedef unsigned int uint;
//将unsigned int 重命名为uinttypedef int* ptr_t;//整形指针
//int*重命名为ptr_ttypedef int(*parr_t)[5];//数组指针
//int(*5)重命名为parr_ttypedef void(*pfun_t)(int);//函数指针
//void(*)(int)重名名为pfun_tvoid (*signal(int, void(*)(int)))(int);//进行改写
pfun_t signal(int, pfun_t);

关于typedef，常规写法是 typedef 类型重命名，但是对于数组指针类型和函数指针类型稍有区别，重命名部分要写在*的后面。

五、函数指针数组

数组是一个存放相同类型数据的存储空间，所以函数指针数组存放的是具有相同返回类型和形参的函数指针。

函数指针数组怎么创建呢？

int (*parr1[3])();
int* parr2[3]();

如上图代码，其实是parr1，首先parr1先和[ ]结合，说明parr1是个数组，且有3个元素，存放的是int（*）（）类型的函数指针。

函数指针数组的应用场景，我们可以通过转移表来理解。

六、转移表的应用

函数指针数组，用数组取每个元素的方式去调用函数，就叫转移表。

当我们想要对两个数进行加减乘除运算操作时，以下是计算机的一般实现。

#include <stdio.h>
int add(int a, int b)
{return a + b;
}
int sub(int a, int b)
{return a - b;
}
int mul(int a, int b)
{return a * b;
}
int div(int a, int b)
{return a / b;
}
int main()
{int x, y;int input = 1;int ret = 0;do{printf("*************************\n");printf(" 1:add 2:sub \n");printf(" 3:mul 4:div \n");printf(" 0:exit \n");printf("*************************\n");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;
}

假设我们想要对这两个数进行更多的运算，那么由于增加了更多的选择，switch语句的相关代码会变得非常冗长，且重复性很高，所以此时用函数指针数组，可以很好地解决这个问题。下面我们通过函数指针数组来实现。

int add(int a, int b)
{return a + b;
}
int sub(int a, int b)
{return a - b;
}
int mul(int a, int b)
{return a * b;
}
int div(int a, int b)
{return a / b;
}
int main()
{int x, y;int input = 1;int ret = 0;int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表do{printf("*************************\n");printf(" 1:add 2:sub \n");printf(" 3:mul 4:div \n");printf(" 0:exit \n");printf("*************************\n");printf("请选择：");scanf("%d", &input);if ((input <= 4 && input >= 1)){printf("输入操作数：");scanf("%d %d", &x, &y);ret = (*p[input])(x, y);printf("ret = %d\n", ret);}else if (input == 0)printf("退出计算器\n");elseprintf("输入有误\n");} while (input);return 0;
}

我们发现原本通过switch语句的选择代码，直接变成了函数指针数组的下标访问，代码简洁清晰。