C语言：深入理解指针（3）

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

1.字符指针变量

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

       字符指针变量，顾名思义就是指向字符的指针变量，所以利用指针接收字符的地址（第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）”）也是可行的。

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

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

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

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

2.数组指针变量

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

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

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

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

     对于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。

3.二维数组传参的本质

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

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

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

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

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

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

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

怎么去理解*(*(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.函数指针变量

4.1 函数指针变量

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

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

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

函数指针怎么创建？

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

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

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

形参的形参名可写可不写

4.2 函数指针变量的使用

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

4.3 函数指针变量的拓展

分析这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，常规写法是  typedef 类型 重命名  ，但是对于数组指针类型和函数指针类型稍有区别，重命名部分要写在*的后面。

5.函数指针数组

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

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

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

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

6.转移表的应用

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

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

#include 
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");
		else
			printf("输入有误\n");
		} while (input);
		return 0;
}
		

     

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

      为什么可以使用函数指针数组？因为add、sub、mul、div这四个函数的形参以及返回类型是意义的，所以他们的函数指针类型也是一致的，根据数组只能存放相同数据类型的特点，所以这几个函数可以被放在一个函数指针数组里，当放进函数指针数组时，我们就可以通过下标去访问并调用对应的函数！

    这里要注意，数组的地址是连续的，但是这个数组存放的函数地址是不连续的。