指针（四）

一.字符指针变量

在指针的类型中，我们知道有一种指针类型为字符指针char*；

一般使用：

#include <stdio.h>
int main()
{
	char ch = 'w';
	char* pc = &ch;
	//*pc = 'w';
	printf("%c", *pc);
	return 0;
}

在这里，*pc打印出的结果是w。那么我们现在有了一个新的问题，如果我们将这个指针指向一个字符串会怎么样呢？我们再来实验一下！

我们发现，当我们以字符串的形式打印的时候，打印出了整个字符串。但是，我们知道，指针指向的是一个地址，那么它指向的是第一个字符的地址还是整个字符串的地址呢？通过我们对指针的计算发现，*pstr指向第一个字符，（*pstr+1）指向了第二个字符。于是我们可以得到这么一个结论：字符指针指向的是字符串首字符的地址，而不是整个字符串的地址。

下面我们来看一个题目：

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

为什么会出现这种情况呢？

先给大家补充一个知识点：在C语言中，使用操作符“==”比较两个指针时，比较的是内存地址是否相同，而不是字符串的内容是否相同。

C语言会把字符串存储到一个单独的内存区域（常量区），当几个指针指向同一个字符串的时候，他们实际会指向同一块内存，所以str3和str4相同。但是用相等的常量字符串去初始化不同的数组就会开辟出不同的内存块，每个内存块的地址不同，所以str1和str2就不同。

二.数组指针变量

1.什么是数组指针变量？

数组指针变量，也就是存放数组地址的指针变量。

现在给大家写两行代码，请大家判断一下p1和p2分别是什么。

int* p1[10];
int(*p2)[10];

先给大家介绍一下两个知识点

1.操作符的优先级：（）>[]>*

2.一个变量，去掉变量名，就是变量的类型。

根据这两个知识点，我们来观察一下这两行代码。

第一行代码中，p1要先和[10]结合，因此变量名是p1[10]，之后p1[10]再和前面的*结合，因此这是一个指针数组，其中的每个元素的类型是int*。

第二行代码中，有括号，先将p2和前面的*结合，说明p2是一个指针变量，然后去掉变量名p2，得到int（*）[10]，说明p2是一个指向数组的指针，也就是数组指针。

2.数组指针变量怎么初始化

我们刚刚已经知道了，数组指针变量是用来存放数组地址的，那么应该怎么样获得数组的地址呢？

当然可以通过取地址操作符&来获得地址啦！下面我们来写一下代码

int arr[10] = { 0 };
&arr;//取出的是整个数组的地址。

那么如果我们要存放这个数组的地址，就要存放再数组指针中。

int (*p)[10]=&arr;

这样，我们就完成了对数组指针变量初始化的工作。

三.二维数组传参的本质

有了对数组指针的理解，我们就能够去了解一下二维数组传参的本质了。

在没有学习指针之前，我们需要一个二维数组作为函数形参的时候，我们是这样写的：

#include <stdio.h>
void test(int a[3][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 ", a[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;
}

这里的实参是二维数组，形参也写成二维数组的形式，那么还有什么其他的写法么？

首先我们再次来理解一下二维数组，二维数组起始可以看作是每个元素都是一维数组的数组，这些元素在内存中连续存放。而这些元素每个元素都占一行，都是一个一维数组。那么二维数组的首元素就是第一行的一维数组。

我们再根据数组名是数组首元素的地址这个规则理解这个代码。

根据上面的例子，第一行的一维数组的类型是int[5]，所以第一行的地址的类型就是int（*）5。那也就意味着，二维数组传参本质上也是传递了地址，传递的地址是第一行这个一维数组的地址，那么形参也是可以写成指针形式的。如下：

void test(int (*p)[5], int r, int c)

四.函数指针变量

1.函数指针变量的创建

函数也是有地址的，函数名就是函数的地址，当然也可以通过*函数名的方式获得函数的地址。

那么如果我们要存储函数的地址，就肯定需要一个指针变量咯，函数指针变量的写法和数组指针变量的写法是相似的。如下：

void test()
{
	;
}
void (*p)() = test;

int Add(int x, int y)
{
	return x + y;
}
int(*pp)(int x, int y) = &Add;
int(*pp)(int,int) = &Add;//省略掉x和y也是可以的

下面我们来解析一下函数指针类型

2.函数指针变量的使用

通过函数指针来调用指针指向的函数，即通过函数指针操纵函数。

下面我们来看两段很有意思的代码

3.两段有意思的代码

在学习这两段代码之前，我们先学习一个关键字。

（1）typedef关键字

typedef是一个关键字，它能将复杂的类型重命名。

下面给大家看一下使用方法

同理，我们也可以重命名一个指针类型。

typedef int* ptr;

但是，对于数组指针和函数指针还是有稍微区别的。

我们有那么一种数组指针类型为int(*)[5]，那么对其重命名是这样写的

        int(*    )[5];//让这个类型新的名字为paff
typedef int(*paff)[5];//新的类型名在*的右边,括号的内部。

同理，函数指针也是这么写的，我们一会看代码的时候给大家实践一下。

（2）代码1

(*(void (*)())0)();

我们从内到外来拆解这行代码

首先，void（*）（）是一个函数指针，因为它写起来很繁琐，我们先将其重命名为pf

(*(void (*)())0)();
typedef void(*pf)();

那么这行代码就可以这样写

(*(void (*)())0)();
typedef void(*pf)();
(*(pf)0)();//简化后

我们还是从内而外的拆解这行代码

1  先将0强转为pf类型，即函数指针类型。

2  解引用符是将一个地址处的内容拿出来的，也就是对0地址处的函数解引用。

3  0地址处的函数为空，所以只有一个单独的()。

（3）代码2

void (*hanshu(int, void(*)(int)))(int);

首先，hanshu与()结合说明其是一个函数名，它有两个参数，一个是整型，一个是void（*）（int）。为了简化这行代码，我们先通过typedef重命名一下void（*）（int）.

typedef void（*pf ）（int）；
void (*hanshu(int, pf))(int);//一次简化后
void (*pf             )(int)//这和我们重命名的一样呀！
pf hanshu(int,pf)//二次简化后

如果你还没看出来二次简化的原理，你可以看一下下面这段代码。

void (*hanshu(int, pf))(int);
void (*               )(int);
void (*pf             )(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(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf(" 0:exit \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;
}

我们发现，每个case下面的东西都是一样的。这就造成了代码的冗余，它可以通过两种方法来简化，一种是函数指针数组，另外一种是回调函数。我们先来学习一下函数指针数组。

六.函数指针数组

顾名思义，函数指针数组就是每个元素都是一个函数指针的数组，下面我们来学习一下定义方法。

int (*par[3])(int);

首先，par先和[]结合，说明par是一个数组指针，数组的内容是什么呢？

答案是int(*)(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;
	int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; 
	//0元素方便输入
	//p先与[5]结合是个数组，每个元素是个函数指针
	do
	{
		printf(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf(" 0:exit \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;
}

下面我们再介绍一下回调函数  

回调函数就是通过函数指针来调用的函数

它是通过把一个函数（函数1）的地址作为参数传递给另外一个函数（函数2），如果我们在函数2内部使用指针来调用函数1，那么这个过程就称为回调函数。

下面我们再来实现一下这段代码。

#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;
}
void calc(int(*pf)(int, int))
//用函数指针来接收函数地址
{
	int ret = 0;
	int x, y;
	printf("输入操作数：");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("ret = %d\n", ret);
}
int main()
{
	int input = 1;
	do
	{
		printf(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf(" 0:exit \n");
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			calc(add);//传入函数的地址
			break;
		case 2:
			calc(sub);//传入函数的地址
			break;
		case 3:
			calc(mul)//传入函数的地址
				break;
		case 4:
			calc(div)//传入函数的地址
				break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}