指针进阶（二）

一维数组传参

存放数组指针的数组

传参时形参的写法

一维数组

指针数组

二级指针存放一级指针地址，数组指针存放数组地址。

#include <stdio.h>
void test(int arr[])//ok
{}
void test(int arr[10])//ok
{}
void test(int *arr)//ok
{}
void test2(int *arr2[20])//ok
{}
void test2(int **arr2)//ok
{}

int main()
{
 int arr[10] = {0};
 int *arr2[20] = {0};
 test(arr);
 test2(arr2);
}

 二维数组

二级指针只能存放一级指针的地址

数组指针是用来存放数组地址的。

void test(int arr[3][5])//ok
{}
void test(int arr[][5])//ok
{}
void test(int (*arr)[5])//ok
{}
int main()
{
 int arr[3][5] = {0};
 test(arr);
}

 数组指针与指针数组传参易混淆点

指针数组能够用二级指针来获取，因为他的类型是int *

（虽然他是数组但是传参时可以用二级指针）

数组指针只能用数组指针来获取（要注意实参是 &数组名 还是 数组名）

共同点：都可以用他们本身做为参数。

一级指针传参

 二级指针传参

void test(char** ppc)
{

}

int main()
{
	char ch = 'a';
	char* pc = &ch;
	char** ppc = &pc;
	char* arr[4];
	test(arr);
	test(&pc);
	test(ppc);
//易错点
char arr2[3][5];
test(arr2);//不能把二维数组传给二级指针
}

函数指针

函数指针变量

int (*变量)(参数类型）=函数名；

                        （指针=地址）

函数指针类型

int(*)(参数类型）

作用：

(*变量)(实参 与  函数名（实参)用法一样

(变量)(实参）=函数名(实参）

函数&Add的地址和Add地址相同

int test(char* str)
{

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

int main()
{
	int arr[10];
	int (*p)[10] = &arr;//p是一个数组指针变量
	printf("%p\n",  &Add);
	printf("%p\n", Add);
	int (* pf)(int, int) = Add;//就是函数指针变量

	int ret = (*pf)(2,3);
	//int ret = Add(2, 3);

	//int ret = pf(2, 3);

	//int (*pt)(char*) = test;//函数指针变量

}

观察以下表达式所表达的意思

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

解析：

    void (*)() 是函数指针类型
	void (*p)()

	( void (*)() ) 强制类型转换
	(类型)

	( void (*)() )0 对0进行强制类型的转换
	0x0012ff40

1. 首先是把0强制类型转换为一个函数指针类型，
这就意味着0地址处放一个返回类型是void，无参的一个函数

2. 调用0地址处的这个函数

函数声明

 int Add(int, int);

    void (* signal(int, void(*)(int)) )(int);//函数声明

	typedef void(* pf_t)(int) ;//给函数指针类型void(*)(int)重新起名叫：pf_t
	pf_t signal(int, pf_t);


	signal是一个函数的声明
	signal函数的参数，第一个是int类型的，第二个是void(*)(int)的函数指针类型
	signal函数的返回值类型也是：void(*)(int)的函数指针
	
	void(*)(int) signal(int, void(*)(int));//err

函数指针数组

存放函数指针的数组

函数指针数组

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

int main()
{
	//指针数组
	//字符指针数组
	char* arr[5];

	//整形指针数组
	int* arr2[4];

	//函数指针数组
	int (* pf[4])(int, int) = { Add, Sub, Mul, Div };

	int i = 0;
	for (i = 0; i < 4; i++)
	{
		int ret = pf[i](8, 2);
		printf("%d\n", ret);
	}

}

函数指针数组要使用时，函数要满足参数类型和返回类型都相同

int (*p[])(int,int);

【】里的数字可以省略用法上和数组一样；当去掉变量时就是变量的类型

int (*[])(int,int);

函数指针数组的用法

int (*pfArr[])(int, int) = {0, Add, Sub, Mul, Div};
函数指针【】里的数字写了也没事
要访问第几个函数时直接
pfArr[temp](x,y)
temp,x,y手动输入

比较下列两个代码

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("请输入2个操作数:>");
			scanf("%d%d", &x, &y);
			ret = Add(x, y);
			printf("ret = %d\n", ret);
			break;
		case 2:
			printf("请输入2个操作数:>");
			scanf("%d%d", &x, &y);
			ret = Sub(x, y);
			printf("ret = %d\n", ret);
			break;
		case 3:
			printf("请输入2个操作数:>");
			scanf("%d%d", &x, &y);
			ret = Mul(x, y);
			printf("ret = %d\n", ret);
			break;
		case 4:
			printf("请输入2个操作数:>");
			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);

}

---

下面这个更简洁

使用的前提 

int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	//转移表
	int (*pfArr[])(int, int) = {0, Add, Sub, Mul, Div};
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出计算器\n");
		}
		else if(input >= 1 && input<=4)
		{
			printf("请输入2个操作数:>");
			scanf("%d%d", &x, &y);	
			ret = pfArr[input](x, y);
			printf("ret = %d\n", ret);
		}
		else
		{
			printf("选择错误\n");
		}

	} while (input);
}

指向函数指针数组的指针

一个指针存放一个数组，数组中存放函数指针

这里可以用指针指数组，数组存指针，无限套

 用指针访问数组元素：*指针[ ] 或*（p+i)   

*p是首元素地址

 回调函数

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个
函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数
的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进
行响应。

 通过控制一个参数来决定传哪个函数过去，然后使用。

void calc(int (*pf)(int,int))
{
	int x = 0;
	int y = 0;
	int ret = 0;

	printf("请输入2个操作数:>");
	scanf("%d%d", &x, &y);
	ret = pf(x, y);
	printf("ret = %d\n", ret);
}

int main()
{
	int input = 0;
	do
	{
		menu();
		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;
}

<和上面使用数组的进行比较>

数组的是直接通过改变数组的元素来确定使用哪个函数；

指针是通过传过来的函数参数是哪个就用哪个。

qsort

内部实现的过程中也体现了回调函数

是一个基于快速排序算法的库函数

 

在自定义比较函数中把if中的p1和p2互换可以改变排序是升序还是降序

qsort库函数的使用

 

 

---

qsort的内部实现