【C语音】详解指针进阶和注意点(2)

前言:本节紧挨《详解指针的初阶和进阶以及注意点（1）》，
     在最后初识了一下函数指针，接下来将围绕函数指针继续开始。

一、再谈函数指针

在前面我们知道如果想得到函数的地址，有两种方式，一种是直接用函数名(如test)，一种是用取地址符号(如&test)。
那么如何用指针存储地址？
接下来看看代码

int test(const char* str)
{
	printf("test()\n");
	return 0;
}

int main()
{
	printf("%p\n", test);
	printf("%p\n", &test);

	//用指针pf存放test地址
	int (*pf)(const char*) = test;
	//或者
	int (*pf)(const char*) = &test;
	//或者
	int pf(const char*) = &test;
	//或者
	int (*****pf)(const char*) = &test;
	
	//可以通过以下方式进行调用。
	(*pf)("abc");
	test("abc");
	pf("abc");

	return 0;
}

我们发现：

1. 指针存放函数地址，函数地址有两种表示方法，指针可以不用加* 或者加多个*（加*需要用括号括起来）。
2. 像int (* )(const char *)这个，我们称作为函数指针类型。
3. 由于指针和函数名可以表示函数地址，在调用时，可以直接通过如pf(“abc”)，test(“abc”)直接调用。

那么函数指针有什么用呢？
下面看一段代码

void menu()
{
	printf("*****************************\n");
	printf("*****	1.add	2.sub	*****\n");
	printf("*****	3.mul	2.div	*****\n");
	printf("*****	0.exit		    *****\n");
	printf("*****************************\n");
}

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 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("%d\n", ret);

}

int main()
{
	int input = 0;

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

		switch (input)
		{
		case 1:
			calc(Add);
			//如果没有通过函数指针建立calc函数，那么代码将如下写变得非常冗余。
			//int x = 0;
			//int y = 0;
			//int ret = 0;

			//printf("请输入2个操作数:>");
			//scanf("%d %d", &x, &y);
			//ret = Add(x, y);
			//printf("%d\n", ret);
			break;
		case 2:
			calc(Sub);
			//int x = 0;
			//int y = 0;
			//int ret = 0;

			//printf("请输入2个操作数:>");
			//scanf("%d %d", &x, &y);
			//ret = Sub(x, y);
			//printf("%d\n", ret);
			break;
		case 3:
			calc(Mul);
			//..
			break;
		case 4:
			calc(Div);
			//..
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);

	return 0;
}

利用函数指针，能在一些特殊情况下，简化代码。

 

在理解函数指针后，我们来看两段有趣的代码，看看这两段代码分别有什么用。

//代码1
(*(void (*)())0)();
//代码2
void (*signal(int , void(*)(int)))(int);

1. 在第一段代码中，首先是( void (*)() )，（类型）类型在括号里意思就是强转换，将0强转为函数指针，*解引用地址，所以本质就是个函数调用，调用地址为0处的函数。
2. 从外边看，void (* )(int)是一个函数指针类型，内部signal(int, void()(int))，函数signal，参数是(int, void()(int))，类型是void(* )(int)，有返回类型，有参数类型，就是个函数声明。

 
 

二、函数指针数组

顾名思义，就是一个数组里存了函数指针。
那么如何表示呢?
函数指针是这样的

int (*pf)();

前面学习指针数组，知道是这样表示的

int* arr[];

那么合起来，函数指针数组就这样表示，pf先和[]结合说明是一个数组，类型就是int (*)()函数指针。

int (*pf[])();

 
那么函数指针数组有什么用呢？
看看这个代码

void menu()
{
	printf("*****************************\n");
	printf("*****	1.add	2.sub	*****\n");
	printf("*****	3.mul	2.div	*****\n");
	printf("*****	0.exit          *****\n");
	printf("*****************************\n");
}

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()
{
	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("%d\n", ret);
		}
		else
		{
			printf("选择错误\n");
		}
	} while (input);

	return 0;
}

通过访问数组下标的方式访问函数，更加美化，方便我们代码的设计。

 
函数指针数组的指针
当然函数指针数组也能通过数组的地址放入指针中，这里只是认识一下，也可以无线套娃下去，不过到此为止了。
如何表示？

//函数指针数组
int (*pfun[5])();

//函数指针数组指针
//(*ppfun)先说明ppfun是一个指针，之后与[]结合说明指向一个有5个元素的数组，
//数组里元素类型是int (*)()
int (*(*ppfun)[5]))()  

 

三、回调函数

什么是回调函数?

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

假设有函数F1调用了函数F2的时候，函数F1通过参数给F2传递了另一个函数F3的指针，在函数F2执行的过程中，函数F2调用了函数F3，这个动作就叫做回调，而先被当做指针传入、后面又被回调的函数F3就是回调函数。

理解如下：
F3地址作为参数传递给了F2，储存F3地址的指针又用来调用原来的F3函数，就说F3是回调函数。
但值得注意的是，并不是通过F3函数直接调用（不是实现方直接调用），而是通过一个存放了F3函数指针进行调用。

int F3()
{
	return 0;
}

//F2调用了函数F3
int F2(int (*F3)())
{
	F3();//又通过F3的地址访问了F3函数
	return 0;
}

int F1()
{
	//函数F1调用F2传递了F3指针
	F2(F3)
	return 0;
}

 
 
接下来让我们看看回调函数qsort的实现。
通过MSDN，我们看到了一些qsort的信息，qsort是通过参考快排实现的，这里我们不讨论它怎么实现，我们学会怎么用它。
下面看函数声明。

通过简化函数声明得到：

void qsort(void* base, //需要排序数据的起始位置
	size_t num, //待排序的数据元素的个数
	size_t width, //待排序的数据元素的大小(单位是字节)
	int (*cmp)(const void* e1, const void* e2) //函数指针-比较函数
);

因为我们不知道需要排序的数据类型是什么，所以在定义起始位置的时候，选择了void*类型，怎么理解它？
看代码

int main()
{
	int a = 10;
	//char* pa = &a;//int*
	void* pv = &a;//void*是无具体类型的指针，可以接受任意类型的地址
	//void*是无具体类型的指针，所以不能解引用操作，也不能+-整数
	//
	return 0;
}

现在我们来试试实现排序
看代码

//整型排序
//回调函数
int cmp_int(const void* e1, const void* e2)
{
	//排什么类型的数据，先强转一下
	return (*(int*)e1 - *(int*)e2);
}

void test1()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };

	int sz = sizeof(arr) / sizeof(arr[0]);

	qsort(arr, sz, sizeof(arr[0]), cmp_int);

	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);//结果{0，1，2，3，4，5，6，7，8，9}
	}
}


//结构体排序
int cmp_stu_name(const void* e1, const void* e2)
{
	return strcmp(((struct stu*)e2)->name, ((struct stu*)e1)->name);
}

int cmp_stu_age(const void* e1, const void* e2)
{
	return (((struct stu*)e1)->age -((struct stu*)e2)->age);
}

void test2()
{
	struct stu s[] = { {"ade",20 }, {"qwe", 30}, {"wer", 25} };
	int sz2 = sizeof(s) / sizeof(s[0]);
	qsort(s, sz2, sizeof(s[0]), cmp_stu_name);
	printf("\n");
	for (i = 0; i < sz; i++)
	{
		printf("%d ", (s + i)->name);
	}
}

void test3()
{
	struct stu s[] = { {"ade",20 }, {"qwe", 30}, {"wer", 25} };
	int sz2 = sizeof(s) / sizeof(s[0]);
	qsort(s, sz2, sizeof(s[0]), cmp_stu_age);
	printf("\n");
	for (i = 0; i < sz; i++)
	{
		printf("%d ", (s + i)->age);
	}
}

int main()
{
	test1();
	test2()
	test3()
	return 0;
}

---