【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");
	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 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 重命名为uint
 
typedef int* ptr_t;//整形指针
//int*重命名为ptr_t
 
typedef int(*parr_t)[5];//数组指针
//int(*5)重命名为parr_t
 
typedef void(*pfun_t)(int);//函数指针
//void(*)(int)重名名为pfun_t
 
 
void (*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");
		else
			printf("输入有误\n");
		} while (input);
		return 0;
}

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