C语言深入理解指针3

1.字符指针变量

在指针类型中char*是字符指针

int main()
{
	char ch = 'w';
	char* pc = &ch;//pc是字符指针变量
	//字符指针变量是用来存放地址的
	const char* p = "abcsefghi";
	// 不是将abcdefghi\0存放到p中
	// 而是将首字符a的地址存放在p中
	// "abcsefghi"是常量字符串，是不能被修改的
	//abcdefghi\0的值属性是字符a的地址，首字符地址
	//b=2+3
	//表达式都有两个属性：值属性，类型属性
	//2+3=5值是5
	//2+3的类型属性是int
	printf("%c\n", *p);
	//*p = 'q';//程序崩掉
	printf("%s\n", p);
	return 0;
}

const char* p = "abcsefghi"本质是将字符串的首字符地址存放在p中
那根据上面的结论，下面代码的结果应该是什么？

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

解释:这里的str1和str2是两个数组，只不过初始化的常量字符相同，但本质上还是两块不同的内存空间。str3和str4是字符指针，指向同一个常量字符串，在内存中两个相同的常量字符串只会保存一份，所以str3和str4指向的对象相同

2.数组指针变量

2.1数组指针变量

指针数组是存放地址的数组
整型指针变量存放的是整型变量的地址，指向整型数据
浮点型指针变量存放的是浮点型变量的地址，指向的是浮点型数据
由此可知，数组指针变量存放的是数组的地址，指向数组

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

解释:p1是数组名，数组里面是int*的数据，是一个存放地址的数组，p2先和*结合，*p2是一个指针变量，指向有10个int型的数组，数组指针存放的是数组的地址

2.2数组指针变量初始化

int arr[10] = {0};
&arr;//得到的就是数组的地址

如果要存放数组的地址，就得存放在数组指针变量中

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

数组指针类型解析：

int (*p) [10] = &arr;
 |    |    |
 |    |    |
 |    |    p指向数组的元素个数
 |    p是数组指针变量名
 p指向的数组的元素类型

3.二维数组传参的本质

void test(int arr[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 ", arr[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]
结论:二维数组传参本质上也是传递了地址，传递的是一维数组的地址

void test(int (*arr)[5], int r, int c)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < r; i++)
	{
		for (j = 0; j < c; j++)
		{
			//*(arr+i)==arr[i]
			printf("%d ", arr[i][j]);
			//printf("%d ",*(*(arr+i)+j));
			//printf("%d ",(*(arr+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;
}

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

4.函数指针变量

4.1函数指针变量的创建

函数指针变量用来存放函数的地址，通过地址可以调用函数

int Add(int x,int y)
{
	return x + y;
}

int main()
{
	//对于函数来说，&函数名和函数名都是函数的地址
	printf("%p\n", &Add);
	printf("%p\n", Add);
	int* p1 = &Add;
	int* p2 = Add;
	return 0;
}

可以看出函数是有地址的，函数名就是函数的地址，也可以用&函数名获得函数地址

解释

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

4.2函数指针变量的使用

通过函数指针调⽤指针指向的函数。

#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));
 printf("%d\n", pf3(3, 5));
 return 0;
}

拓展

//代码1
 (*(void (*)())0)();

解释:首先void()()是一个函数指针，返回类型是void没有参数，(void()())0将0强制转成函数指针类型，即为一个指向0地址的函数指针，(void()())0)对该函数指针解引用得到0地址处的函数，((void()())0)()进行调用函数，该函数没有参数返回void

//代码2
 void (*signal(int , void(*)(int)))(int);
//简化
typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);

解释:void()(int)是一个函数指针，返回void类型，有一个int参数，signal(int, void()(int))是一个函数声明，参数是int类型和函数指针类型，void(signal(int, void()(int)))(int)是一个函数声明返回函数指针类型，参数是一个int类型

4.3.typedef关键字

typedef是用来类型重命名的，可以将复杂的类型简单化

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

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

5.函数指针数组

数组是一个存放相同类型数据的存储空间

nt *arr[10];
//数组的每个元素是int*

把函数的地址存放在一个数组，该数组叫函数指针数组

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

解释:parr1才是正确的写法，parr1和[]先结合，parr1是数组名，数组内容是int(*)()类型的函数指针

6.转移表

函数指针数组的用途:转移表
举例:计算器的一般实现

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;
}
void menu()
{
	printf("****************************\n");
	printf("*****   1.add  2.sub  ******\n");
	printf("*****   3.mul  4.div  ******\n");
	printf("*****   0.exit        ******\n");
	printf("****************************\n");

}

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("%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;
}

函数指针数组实现

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;
}
void menu()
{
	printf("****************************\n");
	printf("*****   1.add  2.sub  ******\n");
	printf("*****   3.mul  4.div  ******\n");
	printf("*****   0.exit        ******\n");
	printf("****************************\n");

}

int main()
{
	//函数指针数组
	//转移表
	int(*pfArr[])(int, int) = {0,Add,Sub,Mul,Div };

	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		if (input >= 1 && input <= 4)
		{
			printf("请输入两个操作数:>");
			scanf("%d %d", &x, &y);
			int ret=pfArr[input](x, y);
			printf("%d\n", ret);

		}
		else if (input == 0)
		{
			printf("退出计算器\n");
			break;
		}
		else
		{
			printf("选择错误，请重新选择\n");
		}
			
	} while (input);
	return 0;
}

通过将运算函数的地址存放到p函数指针数组，根据输入的input定位函数地址，调用函数进行计算，比起一般实现，省去了大量代码