C语言--- 指针（3）

一.字符指针变量

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

一般使用：

#include<stdio.h>
int main()
{
	char ch = 'a';
	char* p = &ch;
	*p = 'b';
	printf("%c\n",ch);
	return 0;
}

其实还有一种使用方式：

#include<stdio.h>
int main()
{
	const char* pstr = "hello world";
	printf("%s",pstr);
	return 0;
}

这里是把一个字符串放到了pstr的指针变量里了吗？

其实不是，本质上是将字符串的首字符的地址放到了pstr中。

我们知道指针变量的大小其实是4/8字节，而字符串却不是，所以是不可能将字符串存放到pstr中的。
```
#include<stdio.h>
int main()
{
	 char* pstr = "hello world";
	printf("%c",*pstr);
	return 0;
}
```
在解引用后我们会发现打印的是h，也就是将字符串中首字符h的地址存放到了指针中
在我们学习指针运算时，指针+-整数，会根据指针的类型跳过不同的字节，这里其实也可以用于证明：
```
#include<stdio.h>
int main()
{
	char* pstr = "hello world";
	printf("%s",pstr+5);
	return 0;
}
```
因为pstr的类型是char*,所以＋5会跳过五个字节从而只打印了后面的world。这也证明了pstr储存的就是首字符的地址。

#include<stdio.h>
int main()
{
	char* pstr = "hello world";
	*pstr = 'abc';
	printf("%s",pstr);
	return 0;
}

虽然这个代码在编译的时候并不会报错，但是程序运行时会崩溃。为什么呢？
因为“hello world”是常量字符串，常量字符串是不能修改的。所以pstr实际的类型应该是

const char* pstr = "hellon world";
//这里的const可写可不写

虽然不可以修改但是我们可以使pstr指向另一个常量字符串，起到修改的作用。

#include<stdio.h>
int main()
{
	char* pstr = "hello world";
	pstr = "abcdef";
	printf("%s",pstr);
	return 0;
}

这里打印出来的结果是abcdef;

看一道题：

#include <stdio.h>
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");//1
	else
		printf("str1 and str2 are not same\n");//2
	if (str3 == str4)
		printf("str3 and str4 are same\n");//3
	else
		printf("str3 and str4 are not same\n");//4

	return 0;
}

这里输出结果是什么呢？

结果是2和3；

str1和str2不相同原因：这是两个不同的数组，在内存中会独立开辟空间，既然是不同的空间，那么相应的地址也就不同的，所以是不一样的。
str3和str4相同的原因：这⾥str3和str4指向的是⼀个同⼀个常量字符串。C/C++会把常量字符串存储到单独的⼀个内存区域，当⼏个指针指向同⼀个字符串的时候，他们实际会指向同⼀块内存，并不会开辟两次空间。

二.数组指针变量

指针数组是一种数组，数组中存放的是指针（地址）。

那么数组指针到底是数组？还是指针呢？

答案肯定是一种指针变量。

我们熟悉的指针变量：

整形指针变量：int* pint;存放的是整形变量的地址，能够指向整形数据的指针。
浮点数指针变量：float* pf;存放的是浮点型变量的地址，能够指向浮点数据的指针。

那么数组指针变量：存放的是数组的地址，能够指向数组的指针变量。

思考一下：p1和p2到底是什么？？？

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

p1毫无疑问是一个数组，*的优先级小于[ ]，所以p1先与[10]结合，所以它先是一个数组，数组元素的类型是int*,所以它是一个指针数组。

那么p2就是数组指针了，因为（）的优先级很高，可以用于更改其他操作符的优先级，所以p2先和*结合，代表它是一个指针，指针所指向的是一个大小为10的整形数组。

数组指针如何初始化呢？

数组指针变量是⽤来存放数组地址的，得到数组的地址就需要用到&数组名。

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

&arr和p的类型是一模一样的。

int (*p)[10] = &arr; 
//int指的是p所指向的数组的元素的类型。
//*指p是一个指针变量。
//[10]指的是p所指向的数组的大小。

三.二维数组传参的本质

观察下面这个代码：

#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] 。那就意味着⼆维数组传参本质上也是传递了地址，传递的是第一⾏这个⼀维数组的地址，那么形参也是可以写成指针形式的。

所以test函数就可以这样写。

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

我们可以发现参数不仅改了，printf函数中的参数也有所变化。

*(*(p + i) + j)；
p是第一行的地址，p+i就可以得到第二行或者第三行的地址。
再解引用就是一维数组首元素的地址，加j就可以得到不同位置元素的地址，
再解引用就可以得到该元素。

总结：⼆维数组传参，形参的部分可以写成数组，也可以写成数组指针的形式。

四.函数指针变量

（1）函数指针变量的创建。

通过前面的学习，我们类比可得知，函数指针变量存放的就是函数的地址，也就是指向一个函数。

函数是否有地址呢？

我们可以运行一下这个代码。

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

输出结果：

Add和&Add结果是一样的，也就是说函数名就是函数的地址，当然我们也可以&函数名来获取函数的地址。

那么我们应该如何书写这个指针变量呢？

int (*pf)(int,int) = &Add;
int (*pf)(int x,int y) = Add;//;x和y可写可不写

如何理解这个呢？其实和数组指针是类似的

int (*pf3) (int x, int y)
|      |    ------------
|      |          |
|      |      pf3指向函数的参数类型和个数的交代
|      函数指针变量名
pf3指向函数的返回类型
int (*) (int x, int y) //pf3函数指针变量的类型

#include <stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int(*pf3)(int, int) = Add;

	printf("%d\n", (*pf3)(2, 3));//输出结果5
	printf("%d\n", pf3(3, 5));//输出结果8
	return 0;
}

观察两个有趣的代码：

代码1：

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

代码2：

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

代码1理解：　

(void (*)( )) ，是一个返回值为void，参数为空的函数指针原型。
(void (*)( ))0，把0强制类型转换为一个返回值为void，参数为空的函数指针，指针指向的地址为0.
*(void (*)( ))0，前面加上*表示整个是一个返回值为void的函数的名字
(*(void (*)( ))0)( )，这当然就是一个函数了。

代码2理解：

void(*)(int)就是一个函数指针，这个函数的返回值为void,参数只有一个int.
signal是这个函数名，它的参数就是int和void(*)(int).
返回值也是一个函数指针void(*)(int),只不过signal作为函数名写在了*后面。

（2）typedef关键字

typedef关键字使用类型重命名的，可以简化复杂的类型。

比如unsigned int 你觉得写起来不方便就可以这样写。

typedef unsigned int u_int;
int main()
{
	u_int a = 10;
}

这里就将unsigned int 重命名为了u_int;

指针也可以重命名。

typedef int* ptr_t;

但是对于函数指针和数组指针有一点不一样。

typedef int(*parr_t)[5]; //新的类型名必须写在*的后面
typedef void(*pfun_t)(int);

代码简化就可以这样写：

typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);

五.函数指针数组

什么是函数指针数组呢？

首先，函数指针数组肯定是一个数组，存放的是函数的地址。

那么函数指针的数组如何定义呢？

int (*parr1[3])();
int *parr2[3]();
int (*)() parr3[3];

答案是第一个。

parr1首先和[ ]结合，证明它是一个数组，然后是类型为int (*)()的函数指针。虽然第三个也是这样的，但是parr3[3]的位置不对，应该放在*后面。

六.转移表

函数指针数组的⽤途：转移表。

利用函数指针数组实现计算器基本用法。

#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 }; //转移表 函数指针数组
	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;
}