11.C语言函数指针、函数指针数组及回调函数

 

通过指针（上）和指针（中）的学习，了解了指针的含义、用法以及相关复杂声明。

本章将继续对指针进行学习，主要学习函数指针、函数指针数组以及回调函数的使用等内容，更加灵活地使用指针。

目录

1.函数指针

2.函数指针数组

3.回调函数

---

 

1.函数指针

指向一个函数的指针被称为函数指针。

在了解函数指针前，我们再重新认识一下函数。

请看下面代码：

#include<stdio.h>

void text1()
{
	printf("hello\n");
}

int main()
{
	printf("%p\n", text1);
	printf("%p\n", &text1);
	return 0;
}

显而易见，两次打印的结果是相同的，00491276就是函数text1的地址，当我们平时调用text的时候，计算机会找到text中存储的地址，从而找到函数，实现函数的调用。接下来介绍如何存储函数的地址。请看下面的几个例子：

例1：

void text1()
{
	printf("hello\n");
}
void (*pf1)() = text1;

其对应关系如下图所示：

• void与函数text1的返回类型对应。
• void (*pf1)()中，*与pf1结合，*pf1表示为一个指针，其中pf1是我们自己定义的指针名，因为*的优先级比较低，为了避免pf1与后面的括号结合，需要给*pf1先加上括号。
• text1无需输入参数，最右侧括号里为空。

例2：

int text2(int x, int y)
{
	return x + y;
}
int (*pf2)(int, int) = text2;

有了上面的例子，再看这个例子就更加好理解了。

• 函数的返回值为int，所以函数指针的类型也为int。
• *pf2表示是一个指针。
• 函数text2的两个参数为int，故函数指针的两个参数也为int类型。

有了函数指针存放函数的地址，那么如何用函数指针调用函数呢？依照上文的text1和text2函数，下面演示用函数指针调用函数。

(*pf1)();//*可以省略
pf1();

int a=(*pf2)(3, 5);
int b=pf2(3, 5);

看起来函数指针调用函数与直接调用函数没有差别，反而函数指针还需要提前声明，那么为什么还要用函数指针呢？

事实上，在大多数情况下，函数指针会作为参数传给另外一个函数，这种不直接调用函数，而是另一个函数通过函数指针调用这个函数的过程称为“回调函数”，回调函数会在后文给予详细例子进行解释。

2.函数指针数组

数组是存放一类相同数据类型的存储空间，函数指针数组是存储一类函数指针的数组。

我们依然通过例子来介绍函数指针数组的声明：

例1：

我们现在有三个void类型的函数text1、text2和text3。

void text1()
{
	printf("hello\n");
}
void text2()
{
	printf("hello world\n");
}
void text3()
{
	printf("hello world!\n");
}

通过刚刚所学的函数指针，我们按照其函数类型创建一个函数指针数组来存放函数指针。

void(*arr[])()=[text1,text2,text3];

其中，arr[]的结合更优先，表示arr是一个数组，数组中存放的元素类型为：void(*)()是函数指针类型；通过调用数组的下标元素，来间接对函数进行调用。

上述的例子有些抽象，很多读者肯定有这样的疑问：既然直接调用函数与间接调用函数都可以实现同样的目的，反而后者还稍显更加复杂，那么回调函数的优势在哪里呢？接下来我们通过实现一个计算器的例子，来解释回调函数的优势。

#include<stdio.h>
typedef int Data;
Data add(Data x, Data y)
{
	return x + y;
}
Data sub(Data x, Data y)
{
	return x - y;
}
Data mul(Data x, Data y)
{
	return x * y;
}
Data div(Data x, Data y)
{
	return x / y;
}

void menu()
{
	printf("***********************\n");
	printf("***** 1.add  2.sub ****\n");
	printf("***** 3.mul  4.div ****\n");
	printf("***** 0.exit       ****\n");
}
int main()
{
	int input = 1;
	Data x, y;
	Data(*cal[])(Data x, Data y) = { 0, add, sub, mul, div };
	while (input)
	{
		menu();
		printf("请选择\n");
		scanf("%d", &input);
		if (input >= 1 && input <= 4)
		{
			printf("请输入x y:>");
			scanf("%d%d", &x, &y);
			Data ret = (*cal[input])(x, y);
			printf("ret=%d\n", ret);
		}
		else if(input!=0)
		{
			printf("输入有误，请重新输入\n");
		}
	}
	return 0;
}

其中，typedef int Data是为了以后方便更改函数的返回类型；我们设置了加、减、乘、除四个函数，在主函数中对其进行调用。

因为有了函数指针数组的存在，避免了长篇幅的使用switch语句进行选择。而且函数指针数组易于后续的管理与改进，插入函数或者删除函数只需要在数组内进行即可。

 

3.回调函数

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

在正式进行回调函数的演示之前，先了解一个qsort函数：
qosrt函数需要包含头文件<stdlib.h>，基本格式为：

void qsort (void* base, size_t num, size_t size, int (*compar)(const void*,const void*));

base为排序的对象，num为排序的个数，size为单个排序类型的大小，最后需要给qsort传入一个排序原则的函数，其返回值需要是个整数，根据返回值>0，<0，=0的情况进行排序。

需要注意的是，qsort适合所有类型的排序，所以传入给qsort的函数，其接收参数的形式必须是void*类型的。

#include<stdio.h>
#include<stdlib.h>

int int_cmp(const void* p1, const void* p2)
{
	return *((int*)p1) - (*(int*)p2);
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1 };
	int i = 0;
	qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	putchar('\n');
	return 0;
}

上面是qsort函数的简单应用，先定义了一个函数int_cmp，其意义为：如果前一个数比后一个数大，则大的数在后面。

值得注意的是，在整个过程中，我们并没有给int_cmp函数传入参数，而是把其传给qsort函数，由qosrt对其进行调用，这种方式就称为：回调函数。

 

仿照qsort排序的思路，对传统的冒泡排序进行改进。

其定义与qsort保持一致：

void bsort(void* base, size_t num, size_t size, int(*compar)(const void*, coonst void*));

首先，先设计compar函数：

int compar(const void* p1, const void* p2)
{
	return *((int*)p1) - *((int*)p2);
}

然后，设计交换函数change，由于传入的参数是void*类型，并且要保证改进后的冒泡排序适用所有类型的数据，在交换数字时，选择最小的类型——字节，并将参数类型的大小传给change，进行for循环交换。

void change(void* e1, void* e2, size_t size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *((char*)e1 + i);
		*((char*)e1 + i) = *((char*)e2 + i);
		*((char*)e2 + i) = tmp;
	}
}

最后，原有的冒泡排序的循环结构不变，其判定与交换的部分替换成上述两个函数。

void bsort(void* base, size_t num, size_t size, int(*pf)(void*, void*))
{
	int i = 0;
	int j = 0;
	for (i = 0; i < num - 1; i++)
	{
		for (j = 0; j < num - 1 - i; j++)
		{
			if (compar((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				change((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

将写入的代码代入主函数中进行测试即可。

int main()
{
	int arr[10] = { 7,8,1,2,6,5,5,4,2,1 };
	int i = 0;
	bsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), compar);
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

看到这里，相信各位读者对回调函数的用法有了一定清晰的认识，特别是在大型项目中，函数指针、函数指针数组、回调函数，这些用法是非常实用的，提高代码的可读性时，也对代码进行了相应的简化。