C语言指针：指针数组、数组指针、函数指针及函数指针数组

一、指针数组

1.指针数组的概念

指针数组解释过来就是：存放指针的数组。
指针数组是一个数组，数组里面的每一个元素都是同类型的指针(地址)。我们可以类比记忆：整型数组是存放整型的数组，字符数组是存放字符的数组，那指针数组就是存放指针的数组。
如上图，就是一个指针数组，这个数组中存放的是int*类型的元素。也就是每个元素是一个指针(地址)。

2.指针数组模拟二维数组

#include<stdio.h>
int main()
{
	int arr1[] = { 1,2,3 };
	int arr2[] = { 4,5,6 };
	int arr3[] = { 7,8,9 };
	int* parr[] = { arr1,arr2,arr3 };
	int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 3; j++)
		{
			printf("%d ", parr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

运行结果：

上图解释了上述代码：指针数组parr中存放了三个整型数组的首元素地址，每个元素都是int*类型的，因为数组名表示数组首元素的地址(指针)。那么parr数组中的元素，就分别指向了对应的一维数组的首元素。parr[i] 访问的就是parr数组中的元素，parr[i] 找到的数组元素指向了整型一维数组，则 parr[i][j] 就是整型一维数组中的元素。(注意数组元素下标从0开始)
上述的代码模拟出二维数组的效果，实际上并非完全是二维数组，因为每一行并非是连续的。

二、数组指针变量

1.什么是数组指针变量

我们还是通过类比记忆：
整形指针变量: 比如int* pi；存放的是整形变量的地址，能够指向整形数据的指针。
浮点型指针变量: 比如float* pf；存放浮点型变量的地址，能够指向浮点型数据的指针。
那么数组指针变量：存放的应该是数组的地址，能够指向数组的指针变量。

那要怎么表示数组指针变量呢？

int* p1[5]; //指针数组
int (*p2)[5]; 

上面的代码中，p1是一个指针数组，数组中有5个元素，每个元素是int*类型的。p2就是一个数组指针变量，那要怎么记忆理解呢？
解释: 首先p2先和*结合，说明p2是一个指针变量变量，然后指向的是一个元素个数为5，元素类型为整型的数组。所以p2是一个指针，指向一个数组，所以叫数组指针。(因为[ ]的优先级要高于*号，所以必须加上()来保证p2先和*结合，这样才能说明p2是一个数组指针变量。)

2.数组指针变量的初始化

数组指针变量是用来存放数组地址的，之前我们学习了数组的地址，就是在数组名前加上取地址操作符(&)就得到了数组的地址，&数组名：就表示数组的地址。所以数组的地址就要通过数组指针变量来存放。

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
&arr; //表示的是数组的地址
int(*p)[10] = &arr;

由上面的代码，从监视里也能看出p和&arr的类型是一样的。理解记忆：

3.二维数组传参

二维数组传参的本质是什么？看下面一段代码：

#include<stdio.h>
void test(int arr[3][5], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { {1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15} };
	test(arr, 3, 5);
	return 0;
}

运行结果：
首先理解一下二维数组，二维数组其实可以看做是每个元素是一维数组的数组，也就是二维数组的每个元素是一个一维数组。那么二维数组的首元素就是第一行，是一个一维数组。
上面代码中，函数test中形参写成了二维数组的形式，那有其他的写法吗？根据数组名是数组首元素的地址，则二维数组的数组名就是第一行的地址，也就是一维数组的地址，那第一行一维数组的类型就是int [5]，所以第一行的地址的类型就是数组指针类型int (*)[5]，意味着二维数组传参本质上也是传递了地址，传递的是第一行这个一维数组的地址，那么形参也是可以写成指针的形式：

#include<stdio.h>
void test(int (*p)[5], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			printf("%d ", *(*(p+i)+j));
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { {1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15} };
	test(arr, 3, 5);
	return 0;
}

三、函数指针变量

1.函数指针变量的概念

通过理解上面的数组指针变量，可以知道数组指针变量是用来存放数组地址的。那函数指针变量就是用来存放函数地址的。在未来能通过函数的地址来调用函数。
函数也是有地址的：

#include<stdio.h>
void test()
{
	printf("mifan\n");
}
int main()
{
	printf("test: %p\n", test);
	printf("&test:%p\n", &test);
	return 0;
}

运行结果：
通过上述运行结果可知，函数名就是函数的地址，当然也可以通过 &函数名 的方式获得函数的地址。

如果我们要将函数的地址存放起来，就需要存放在函数指针变量中，函数指针变量的写法其实和数组指针变量非常类似。如下:

#include<stdio.h>
void test()
{
	printf("mifan\n");
}
int add(int x, int y)
{
	return x + y;
}
int main()
{
	void (*pf1)() = test;
	void (*pf2)() = &test;
	int (*pf3)(int, int) = add;
	int (*pf4)(int x, int y) = &add; //x和y写上或省略都可以
	return 0;
}

理解记忆图：

2.函数指针变量的使用

通过函数指针调用指针指向的函数：

#include<stdio.h>
int add(int x, int y)
{
	return x + y;
}
int main()
{
	int (*pf)(int x, int y) = add;
	printf("%d\n", (*pf)(2, 3));
	printf("%d\n", pf(1, 5));
	return 0;
}

运行结果：
由上面的代码，通过对函数指针解引用找到指针指向的函数或者是直接使用函数指针也是一样的效果。

四、函数指针数组

1.函数指针数组的概念

数组是一个存放相同类型数据的存储空间，刚才我们学习了函数指针。那么函数指针数组就是存储函数地址的数组，数组里面存放的都是相同类型的函数指针。那函数指针数组怎么定义呢? 如下：

#include<stdio.h>
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 (*parr[4])(int x, int y) = { add,sub,mul,div };
	return 0;
}

上面的代码中parr就是一个函数指针数组，parr首先和 [ ] 结合说明parr是数组，数组当中每个元素是 int （*)(int x，int y) 类型的函数指针。

2.转移表

实现一个一般的计算器：平常我们会想到代码就是：

#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("%d\n", ret);
			break;
		case 2:
			printf("请输入两个整数：");
			scanf("%d%d", &x, &y);
			ret = sub(x, y);
			printf("%d\n", ret);
			break;
		case 3:
			printf("请输入两个整数：");
			scanf("%d%d", &x, &y);
			ret = mul(x, y);
			printf("%d\n", ret);
			break;
		case 4:
			printf("请输入两个整数：");
			scanf("%d%d", &x, &y);
			ret = div(x, y);
			printf("%d\n", ret);
			break;
		case 0:
			printf("退出程序！\n");
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}
	} while (input);
	return 0;
}

运行结果：
虽然上面的代码实现了一个计算器的功能，但是代码太冗余，有重复使用的代码：
现在我们通过函数指针数组来改进上面的代码：

#include<stdio.h>
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 x, y;
	int input = 1;
	int (*parr[5])(int x, int y) = { 0,add,sub,mul,div };//转移表
	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);
		if (input >= 1 && input <= 4)
		{
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = (*parr[input])(x, y);
			printf("%d\n", ret);
		}
		else if (input == 0)
			printf("退出计算器\n");
		else
			printf("输入有误，请重新输入\n");
	} while (input);
	return 0;
}

运行结果：
什么是转移表？[参考]
转移表所指的就是运用函数指针数组以数组的方式去调用里面的函数。

函数指针数组的作用就是转移表，在写代码时，可能会遇到使用switch语句的情况，当我们使用switch语句来编写代码时，可能会出现代码冗余，也就是会出现代码重复的情况，经过转移表的使用，就会使代码的篇幅大大减少，提高敲代码的效率。