深入理解指针：【探索指针的高级概念和应用二】

一，数组参数、指针参数

1.一维数组传参

2.二维数组传参

3.一级指针传参

4.二级指针传参

二，函数指针

三，函数指针数组

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

四，指向函数指针数组的指针

一，数组参数、指针参数

我们在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？下面我们就一起来探究一下。

1.一维数组传参

#include <stdio.h>
//数组传参，形参是可以写成数组形式的，因为这儿传参的本质是数组首元素的地址，所以大小可以不写
void test(int arr[])
{}

//这儿不会去创建一个新的数组，这个大小是无意义的，所以数组里边的大小也可以省略
void test(int arr[10])
{}

//数组传参的本质是传递数组首元素的地址；数组传参，形参也可以是指针
void test(int* arr)
{}

//数组传参，形参用数组形式，数组的大小也可以省略
void test2(int* arr2[20])
{}

//arr2的每个元素类型都是int*，这儿传过来的是首元素地址，即第一个元素的地址（int*的地址），
//所以就是将一级指针的地址取出来放在二级指针里边去
void test2(int** arr2)
{}

int main()
{
	int arr[10] = { 0 };//定义了一个一维数组，数组里边有10个元素，每个元素是int类型
	int* arr2[20] = { 0 };//数组里边有20个元素，每个元素是int*类型
	test(arr);
	test2(arr2);
}

2.二维数组传参

//数组传参，形参的部分写成数组
void test(int arr[3][5])
{}

//错误写法
//数组传参的时候，行可以省略，但是列绝对不能省略
void test(int arr[][])
{}

//正确写法
void test(int arr[][5])
{}

//错误写法
//数组名表示首元素的地址，即第一行的地址；而这是一个整型指针，
//整型指针是用来接受整型变量的地址的，所以这种写法是错误的
void test(int* arr)
{}

//错误写法
//二维数组传过来拿指针数组接收了，应该用数组指针接收
void test(int* arr[5])
{}

//正确写法
//这是一个数组指针，指向5个元素，每个元素是int类型，它可以指向数组中的第一、二、三行
void test(int(*arr)[5])
{}

//错误写法
//二级指针是用来接收一级指针的地址的
void test(int** arr)
{}

int main()
{
	int arr[3][5] = { 0 };//定义了一个三行五列的二维数组
	test(arr);//对数组进行传参
}

🍂总结：

二维数组传参，函数形参的设计只能省略第一个[ ]的数字。因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素，这样才方便运算。

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;//将数组的数组名赋给了p，本质是将数组首元素的地址赋给了p
	int sz = sizeof(arr) / sizeof(arr[0]);
	
	print(p, sz);//一级指针p，传给函数
	return 0;
}

🌴我们可以思考一下当一个函数的参数部分为一级指针的时候，函数能接收什么参数？

void test(int* p)
{

}

int a = 10;

test(&a);//传整型变量的地址

int* ptr = &a;
test(ptr);//传整型指针

int arr[5];
test(arr);//传整型一维数组的数组名

4.二级指针传参

#include <stdio.h>
void test(int** ptr)//二级指针传过来拿二级指针接收
{
	printf("num = %d\n", **ptr);
}
int main()
{
	int n = 10;
	int* p = &n;
	int** pp = &p;
	test(pp);//把pp这个二级指针传给test函数
	test(&p);//p是一级指针变量，&p也是二级指针
	return 0;
}

🌴我们再思考一下当一个函数的参数部分为二级指针的时候，函数能接收什么参数？

void test(int** p)
{

}

int main()
{
	int n = 10;
	int* p = &n;
	int** pp = &p;
	int* arr[6];

	test(&p);
	test(pp);
	test(arr);//数组名表示首元素的地址，就是int*的地址，传参后要用二级指针来接收
	return 0;
}

二，函数指针

我们知道数组指针是指向数组的指针，存放的是数组的地址，&数组名就是数组的地址；

那函数指针就是指向函数的指针，存放的是函数的地址，那怎么才能得到函数的地址呢？是不是&函数名呢？接下来我们通过一段代码来探究一下函数指针的神秘面纱：

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	//&函数名就是函数的地址
	//函数名也是函数的地址
	printf("%p\n", &Add);
	printf("%p\n", Add);

	return 0;
}

🎈输出结果：

我们可以看到输出的是两个相同的地址，而这两个地址都是Add函数的地址，所以&函数名和函数名都能得到函数的地址。那我们的函数想要保存起来，该怎么做呢？看代码：

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int (*pf1)(int, int) = &Add;//pf1就是函数指针变量

	int ret = (*pf1)(3, 5);//通过函数指针变量找到函数地址并且调用它
    printf("%d\n", ret);

	return 0;
}

上面代码中的pf1是函数指针变量，它可以将我们的函数保存起来，pf1先和*结合，说明pf1是指针，指针指向的是一个函数，指向的函数有两个int类型的参数，返回值类型为int类型。

🍂 接下来我们再阅读两段有趣的代码（出自：《C陷阱和缺陷》）：

🍃代码一：

int main()
{
	( *(void (*)())0 )();

	return 0;
}

在上面这段代码中我们从最熟悉的0开始下手，0是个数字；0前面的void (*)()这部分是指针指向了一个函数，函数没有参数，返回类型是void，所以这部分是一个函数指针类型；将类型放在括号里边就是要强制类型转换，转换完后前面加个*，就是要解引用，去调用这个函数，调用的这个函数也没有参数；

总结起来就是上面这段代码是在调用0地址处的函数，这个函数没有参数，返回类型是void。

🍃代码二：

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

	return 0;
}

上面这段代码比较复杂，我们可以将它简化为以下两部分
void (*  )(int);

signal(int, void(*)(int));
现在我们再来看这段代码就比较好分析了，首先它是一次函数声明，声明的是signal函数，signal 函数的参数有两个，第一个是int 类型，第二个是函数指针类型，该类型是void (*)(int)，该函数指针指向的函数，参数是int，返回类型是void；signal函数的返回类型也是函数指针类型，该类型是void (*)(int)，该函数指针指向的函数，参数是int，返回类型是void。

三，函数指针数组

通过前面的学习我们知道数组是一个存放相同类型数据的存储空间，例如指针数组：

int* arr[10];
这是一个整型指针数组，存放的是整型指针，数组的每个元素是int*。

由上边的例子我们就可以知道函数指针数组也是一个数组，它存放的是函数指针（即函数的地址）：

int (*parr1[10])();
//parr1 先和 [] 结合，说明 parr1是数组，
//数组的内容是int (*)() 类型的函数指针

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

🌴例子（计算器）：

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

上面这段代码现在只具有加减乘除的功能，但是如果我想让它实现 a&&b、a||b、a&b、a|b、a>>b、a<<b等功能时，我们的运算会越来越多，菜单里边的功能相应的也会越来越多，同时类似加减乘除的函数也会越来越多，而且switch语句会越来越长，代码会冗余。
那有没有什么办法让函数变得简洁呢，其实是有的。通过观察，会发现这些函数除了函数名和里边的计算不一样外，函数的参数都是两个int，返回类型都是int，所以我们可以通过函数指针数组来改写它。

🌴使用函数指针数组的实现：

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);
		//函数指针数组 - 转移表
		int (*pfarr[5])(int, int) = { NULL,Add,Sub,Mul,Div };//放个NULL的原因是将这些操作函数的下标往右挤一位
	    if (0 == input)
		{
			printf("退出计算器\n");
		}
		else if (input >= 1 && input <= 4)
		{
			printf("请输入操作数:>");
			scanf("%d%d", &x, &y);
			ret = (pfarr[input])(x, y);
			printf("ret= %d\n", ret);
		}
		else
		{
			printf("选择错误，请重新选择！\n");
		}
	} while (input);

	return 0;
}

四，指向函数指针数组的指针

🎈我们先来看一下整型指针数组：

int a = 10;
int b = 20;
int c = 30;

//整型指针数组，数组的每个元素是int*类型
int* arr[] = { &a, &b, &c };

//p是指针，是指向整型指针数组的指针
int* (*p)[3] = &arr;

有了上面的例子我们再来看指向函数指针数组的指针：

指向函数指针数组的指针是一个指针
指针指向一个数组，数组的元素都是 函数指针

void test(const char* str)
{
	printf("%s\n", str);
}
int main()
{
	//函数指针pfun
	void (*pfun)(const char*) = test;

	//函数指针的数组pfunArr
	void (*pfunArr[5])(const char* str);

	pfunArr[0] = test;
	//指向函数指针数组pfunArr的指针ppfunArr
	void (*(*ppfunArr)[5])(const char*) = &pfunArr;

	return 0;
}