---

正文开始。

1. 字符指针变量

我们可以通过指针来指向一个字符变量
例如：

int main()
{
	char ch = 'a';
	char* pch = &ch;
	return 0;
}

还可以这样：

int main()
{
	const char* pstr = "hello world!";
	return 0;
}

上述第三行代码，很容易让人理解为是把字符串hello world!放到了字符指针pstr里了。但其实这里本质是把字符串hello world!的首字符的地址放到了pstr里。

值得注意的是：当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。这也不难理解，某一字符串是独一无二的，没必要为同一个东西再开辟空间。

例如：

#include <stdio.h>
int main()
{
	char str1[] = "hellw world!";
	char str2[] = "hellw world!";
	const char *str3 = "hellw world!";
	const char *str4 = "hellw world!";
	
	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;
}

运行结果：

从这里就可以看出，几个指针指向同一个字符串的时候，他们会指向同一块内存；但用相同的字符串去初始化不同的数组时，就会开辟处不同的内存块。

2. 数组指针变量

2.1 什么是数组指针变量

在上一篇文章中，我们学习了指针数组，它是存放指针的数组。
类比指针数组，不难理解，数组指针变量就是指向数组的指针变量

下面我们来看两种变量：

//指针数组 - 存放指针的数组
int* p1[10];

//数组指针变量 - 指向数组的指针变量
int (*p2)[10];

理解：

• *的优先级低于[]
• int* p1[10]中p1先与[10]结合，代表数组类型，int *指明数组中元素的类型为整型指针
• int (*p2)[10]中p2先与 * 结合，代表指针类型，int [10]代表所指向对象的类型为存放了十个整型元素的数组

2.2 数组指针变量的初始化

数组指针变量是用来存放数组地址的，我们可以通过取地址操作符&来获取数组地址。

int main()
{
	int arr[10] = { 0 };
	//数组指针变量的初始化
	int (*p)[10] = &arr;
	return 0;
}

3. 二维数组传参的本质

在我们将一个二维数组传递给一个函数时，我们是这样写的：

#include <stdio.h>

void Print(int arr[2][3], 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[2][3] = {{1,2,3}, {2,3,4}};
	Print(arr,2,3);
	return 0;
}

我们再重新理解下二维数组，二维数组定义时，通常像这样int arr[2][3]，这里我们可以看作是这样的int (arr[2])[3]，即一维数组里面存放的元素是一维数组，这样就把一个二维数组拆分成了两个一维数组来看。例如第一行的一维数组的类型就是int [3]，所以第一行的地址的类型就是数组指针类型int(*)[5]。通过这一点，我们不难理解，二维数组传参本质上也是传递了参数，传递的是第一行这个一维数组的地址。

那么，我们二维数组传参，也可以写成这样：

#include <stdio.h>

void Print(int (*p)[3], 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));
			//p + i == &arr[i]
			//*(p + i) == arr[i] 相当于第i行一维数组的数组名
			//*(p + i) + j == &arr[i][j]
			//*(*(p + i) + j) == arr[i][j]
		}
		printf("\n");
	}
}
int main()
{
	int arr[2][3] = {{1,2,3}, {2,3,4}};
	Print(arr,2,3);
	return 0;
}

上述代码运行结果：

4. 函数指针变量

函数指针变量，顾名思义，它就是存放函数地址的指针变量。

在学习函数指针变量前，我们要了解到，函数名就是函数的地址。

例如：

#include <stdio.h>
//函数地址 -- &Add
//函数地址 -- Add
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	printf("&Add = %p\n", &Add);
	printf("Add  = %p\n", Add);
	return 0;
}

上述代码运行结果：

4.1 函数指针变量的创建

当我们想把函数的地址存放起来，这是就需要用到函数指针变量了，函数指针变量的写法与数组指针非常类似。例如：

#include <stdio.h>

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int (*p1)(int, int) = Add;
//或int (*p2)(int x, int y) = Add;
//Add也可写为&Add，它们都代表函数的地址

//int    (*p1)     (int, int)
// |       |       ——————————
// |       |            |
// |       |            |
// |       |       p1指向函数的参数类型和个数的声明
// |       函数指针变量名
// p1指向函数的返回类型
//
// p1的类型 -- int (*) (int x, int y)
	return 0;
}

4.2 函数指针变量的使用

我们可以通过函数指针调用指针指向的函数

#include <stdio.h>

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	//函数指针变量定义
	int (*p1)(int, int) = Add;
	//函数指针变量使用
	printf("%d\n",(*p1)(3,4));
	printf("%d\n", p1(5,1));
	return 0;
}

上述代码运行结果：

4.3 代码分析

我们来看下面两个代码

代码1：

(*(void (*)())0))();
//void (*)() -- 函数指针类型，所指向对象无形参，无返回值

//(void (*)())0 -- 将0强制转换类型为void (*)()类型，即将0地址处存放函数的地址

//*(void (*)())0) -- 解引用函数指针

//(*(void (*)())0))() -- 调用函数指针变量指向的函数

代码2：

void (*signal(int, void(*)(int)))(int);
//void(*)(int) -- 函数指针变量，指向的函数无返回值，参数类型为int

//signal(int, void(*)(int)) -- 函数名为signal的函数，第一个参数类型为int，第二个参数类型为void(*)(int)

//void (*signal(int, void(*)(int)))(int) -- 函数signal(int, void(*)(int))的声明，它的返回值类型为void (*)(int)

4.3.1 typedef 关键字

上面我们写的代码二的作用就是声明一个函数，可以看出来，这个函数声明非常的复杂，我们可以通过typedef关键字来重命名类型，简化类型。

例如：

typedef int i;
//将 int 重命名为 i

typedef unsigned int uint;
//将 unsigned int 重命名为 uint

typedef int(*parr)[5];
//将 int (*)[5] 重命名为 parr

typedef void(*pfun)(int);
//将 void(*)(int) 重命名为 pfun

若要简化代码2，我们可以这样写：

typedef void(*pfun)(int);
//将 void(*)(int) 重命名为pfun

pfun signal(int, pfun);

5. 函数指针数组

函数指针数组，就是存放函数指针变量的数组。

定义如下：

int (*parr[4])();
//  parr -- 数组名
//  [4] -- 数组元素个数
//  int (*)() -- 数组中元素的类型

6. 转移表

函数指针数组可以用来书写转移表——运用函数指针数组以数组方式去调用里面的函数，从而在某些情况下替代冗长的代码。我们通过计算器的例子来学习一下吧。

计算器的一般实现：

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

使用转移表实现计算器：

#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;
	int (*arr[5])(int, int) = {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 >= 1 && input <= 4)
		{
			printf("输入操作数：");
			scanf("%d%d", &x, &y);
			ret = *(arr[input])(x,y);//调用函数指针数组中的元素
			printf("ret=%d\n", ret);
		}
		else if(input == 0)
		{
			printf("程序退出\n");
		}
		else
		{
			printf("输入错误\n");
		}
	} while(input);
	return 0;
}

完。

---