深入理解指针（2）

对数组名的理解

我们来观察一下以下代码

&arr[0]表示拿到了数组第一个元素的地址 ，arr表示数组名，所以我们可以得出结论：

                                                    数组名等于数组首元素的地址

但是有两个例外：

1.sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩,单位是字节

2.   & 数组名，这⾥的数组名表⽰整个数组，取出的是整个数组的地址（整个数组的地址和数组⾸元素的地址是有区别的）

下面我们来用代码验证

我们发现&arr[0]和&arr[0]+1相差4个字节，arr和arr+1 相差4个字节，是因为&arr[0] 和 arr 都是

⾸元素的地址，+1就是跳过⼀个元素

但是&arr 和 &arr+1相差40个字节，这就是因为&arr是数组的地址，+1 操作是跳过整个数组

使用指针访问数组

数组名arr和指针变量p是等价的

基于以上知识，当我们用指针访问数组时候如果创建指针变量 p 则p[i]=arr[i]=*(arr+i)=*(p+i）

int main()
{
	int arr[10] = { 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = arr;
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		scanf("%d", p + i);
	}
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}//也可以*(arr+i)======arr[i]========p[i]

	return 0;
}

一维数组传参的本质

一维数组传参本质上传的是首元素的地址 形参部分可以写成数组形式，也可以写成指针形式

冒泡排序

//冒泡排序
void bubble_sort(int arr[], int sz)
{
	//趟数
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		//一趟排序的过程
		int flag = 1;
		int j = 0;
		for (j = 0; j <sz-1-i ; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
				flag = 0;
			}
		}
		if (flag == 1)
		{
			break;
			//这一趟有序结束这趟的排序
		}
	}
}
int main()
{
	int arr[] = {9,8,7,6,5,4,3,2,1,0};
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	int i = 0;
	for (i = 0; i < sz; i++)
	{ 
		printf("%d ", arr[i]);
	}
	return 0;
}

二级指针

指针变量也是变量，既然是变量那就有地址，这个时候指针变量的地址就需要一个二级指针变量来接收

指针数组 

顾名思义 指针数组 为存放指针的数组

//指针数组-存放指针的数组
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };

	int* arr[] = { arr1,arr2,arr3 };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);
		}               //*(*(arr+i)+j)
		printf("\n");
	}
	return 0;
}

int* arr[5] 指针数组的每个元素都是用来存放地址（指针）的

字符指针变量

字符数组 数组内容可变 但是常量字符串的内容不可被修改

我们来看一道经典例题

这里的str3和str4是同一个常量字符串，C/C++会把常量字符串存储到单独的一块内存区域，他们实际会指向同一块内存。但是⽤相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同

数组指针变量

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int(*p)[10] = &arr;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", (*p)[i]);
	}
	return 0;
}

这里的int(*p)[10]就是数组指针变量--------本质是一个指向数组的指针

p先和*结合，说明p是一个指针变量，然后指向的是一个大小为10个整型的数组，所以p是一个指针，指向一个数组，叫做数组指针

如果要存放整个数组的地址，就得存放在数组指针变量中 如 int（*p）[10]=&arr;

二维数组传参的本质

//二维数组传参的本质
void Print(int arr[3][5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}


void Print(int(*arr)[5], int r, int c)
{
	int i= 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		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} };
	print(arr, 3, 5);
	//二维数组的数组名也是首元素的地址
	//首元素的地址就是第一行的地址 类型--数组指针类型

	return 0;
}

函数指针变量

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

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

函数指针变量的使用

这些形式都可以调用函数

下面来分析两段代码

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

void（*）（）；函数指针类型

（void（*）（））0 把0（原本类型为int）强制转化为函数指针类型  这就意味着0地址处放着一个无参 返回类型为void的函数

然后对函数解引用去调用这个函数   最终是调用0地址处放的函数

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

signal 表示函数名 第一个参数为int类型，第二个参数为void(*)(int)函数指针类型 ，函数的返回类型也为void(*)(int)函数指针类型

其表达的意思就是 void(*)(int) signal (int ,void(*)(int)) ；进行函数的声明 但是我们不能这么写

typedef关键字

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

例如：typedef unsigned int u_int；

上面第二段代码就可以改写为 typedef void (*pf_t)(int);  //pf_t 就是void(*)(int)

                                                   pf_t signal (int, pf_t)

typedef与#define的区别：

typedef int* ptr_t;
#define PTR_T int *;

编译器解读为：
ptr_t p1, p2;  //p1 p2 都是指针变量
PTR_T p3, p4; //p3是指针变量,p4是整型变量   在预处理阶段替换后为int* p3, p4;则p4

为整型变量

函数指针数组
把函数的地址存到一个数组中，那这个数组就叫做函数指针数组

如  ：int(*p[5])(int ,int) 

借助于函数指针数组，我们就可以模拟实现计算器，看如下代码：

//转移表
//优化
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 meau()
{
	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 z = 0;
	int (*pfArr[5])(int, int) = { 0,Add,Sub, Mul,Div };

	do
	{
		meau();
		printf("请选择:>");
		scanf("%d", &input);

		if (input >= 1 && input <= 4)
		{
			printf("请输入两个操作数:");
			scanf("%d %d", &x, &y);
			z = pfArr[input](x, y);
			printf("%d\n", z);
		}
		else if (input == 0)
		{
			printf("退出计算器\n");
		}
		else
		{
			printf("输入错误，请重新选择\n");
		}


	} 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 meau()
{
	printf("***************************************\n");
	printf("******** 1.add ****** 2.sub************\n");
	printf("*********3.mul********4.div***********\n");
	printf("***********0.exit*********************\n");
	printf("**************************************\n");
}
void calc(int (*pf)(int, int))
{
	int x = 0;
	int y = 0;
	int z = 0;
	printf("请输入两个操作数:");
	scanf("%d %d", &x, &y);
	z = pf(x, y);
	printf("%d\n", z);
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int z = 0;
	do
	{
		meau();
		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;
}