C语言：函数指针及定义方式、函数指针作函数参数、回调函数

1 函数指针

函数指针：函数名本身即函数指针，指向函数的入口地址。
函数指针的定义：返回值类型 (*函数指针名)(形参列表类型) = 函数名;
函数指针的调用：函数指针名(实参列表); 等价于函数名(实参列表);

示例：

void func(int param1, double param2, char param3){...}
//定义函数指针
//返回值类型 (*函数指针名)(形参列表) = 函数名;
void (*pFunc)(int, double, char) = func;

2 函数指针、指针函数、函数指针数组

• 函数指针：属于指针，表示指向函数的入口地址。

• 指针函数：属于函数，返回值类型是指针类型的函数。

• 函数指针数组：属于数组， 数组的每个元素均为函数指针，但函数指针的类型需相同。

函数指针数组的定义：返回值类型 (* 函数指针数组名[数组元素个数])(形参列表类型);。

示例：

int func1(int a){
	return a + 1;
}
int func2(int b){
	return b - 2;
}
int func3(int c){
	return c * 3;
}

//定义函数指针数组
int (*func_arr[3])(int);
func_arr[0] = func1;
func_arr[1] = func2;
func_arr[2] = func3;

3 函数指针的定义方式

void func(int a, char b){...}

3.1 typedef定义函数类型

先定义函数类型，再通过函数类型定义函数指针变量。

定义：
typedef void(FUNC_TYPE)(int, char);
FUNC_TYPE *pFunc = func;
调用：
pFunc(1 , 'a');

注：FUNC_TYPE返回值类型void，形参列表类型为(int, char)。

3.2 typedef定义函数指针类型

先定义函数指针的类型，再通过函数指针类型定义函数指针变量。

定义：
typedef void(*FUNC_POINTER_TYPE)(int, char);
FUNC_POINTER_TYPE pFunc = func;
调用：
pFunc(2 , 'b');

3.3 直接定义函数指针变量

返回值类型 (*函数指针名)(形参列表类型) = 函数名;
定义：
void (*pFunc)(int, char) = func;
调用：
pFunc(3 , 'c');

4 函数指针作函数参数-回调函数

应用：
向用户提供通用的函数接口，使用函数指针作为函数形参（接收用户自定义的回调函数），并使用万能指针类型参数void *接收任意数据类型的地址。在通用的函数接口内部，将数据传递给用户自定义的回调函数进行处理。
当用户调用该通用的函数接口时，具体指定传递的数据和回调函数（名）。

示例：实现任意数据类型元素的打印

#include <stdio.h>

/* 对外提供通用的函数接口 */
//参数void* info：接收任意数据类型的地址
//参数void (* doPrint)(void *)：函数指针，接收回调函数（名）
void printInfo(void* info, void (* doPrint)(void *)) {
	doPrint(info);
}

//回调函数1-打印字符串
void printString(void* info) {
	char* str = (char*)info;
	printf("%s\n", str);
}

struct Object {
	int field;
	char attr[64];
};

//回调函数2-打印结构体
void printStruct(void* info) {
	struct Object* obj = (struct Object*)(info);
	printf("%d--%s\n", obj->field, obj->attr);
}

int main(){
	//创建字符串变量
	char str[64] = "HelloWorld";
	//调用通用接口打印信息，进一步调用回调函数1：printString
	//由用户传递指定的指针类型数据和函数指针（回调函数）
	printInfo(str, printString);	//HelloWorld

	struct Object obj = { 10, "New" };
	//调用通用接口打印信息，进一步调用回调函数2：printStruct
	//由用户传递指定的指针类型数据和函数指针（回调函数）
	printInfo(&obj, printStruct);	//10--New

	return 0;
}

5 回调函数案例

5.1 打印任意数据类型的数组

#include <stdio.h>
/* 提供对外的通用接口，打印任意类型的数组 */
/*
	arr：数组指针
	elemSize：数组元素的大小
	arrLength：数组长度
	void (*doPrint)(void*)：用户自定义的回调函数，打印指定类型的数组元素
*/
void printInfo(void* arr, int elemSize, int arrLength, void (*doPrint)(void*)) {
	//强转为char*类型，将指针的步长置为1	
	char* p = (char *)arr;

	//printf()函数的format表达式需指定类型，无法打印任意数据类型
	//for (int i = 0; i < arrLength; i++) {
	//	printf("%d\n", *((int*)(p + elemSize * i)));
	//}

	//将printf()函数在回调函数中调用，由用户指定具体类型
	for (int i = 0; i < arrLength; i++) {
		char* elemAddr = p + elemSize * i;
		doPrint(elemAddr);
	}
}

//回调函数1-打印整型数据
void printIntArr(void* info) {
	int* p = (int*)info;
	printf("%d\n", *p);
}

struct Object {
	int field;
	char attr[64];
};

//回调函数2-打印结构体数据
void printStruct(void* info) {
	struct Object* obj = (struct Object*)(info);
	printf("%d--%s\n", obj->field, obj->attr);
}

int main() {
	int arr[] = { 1, 2 ,3 ,4 ,5 };
	printInfo(arr, sizeof(int), sizeof(arr)/sizeof(int), printIntArr);

	struct Object objs[] = { {1, "Tom"}, {2, "Jerry"}, {3, "Lucy"}, {4, "Lily"} };
	printInfo(objs, sizeof(struct Object), sizeof(objs) / sizeof(struct Object), printStruct);

	return 0;
}

5.2 任意数据类型数组中查找指定元素

#include <stdio.h>
#include <stdbool.h>
#include <string.h>

/* 提供对外的通用接口，在任意类型的数组中查找指定元素 */
/*
	arr：数组指针
	elemSize：数组元素的大小
	arrLength：数组长度
	target：指向指定元素的指针
	void (*doCompare)(void*, void*)：用户自定义的回调函数，比较两元素是否相同
*/
bool findElement(void* arr, int elemSize, int arrLength, void* target ,bool (*doCompare)(void*, void*)) {
	//强转为char*类型，将指针的步长置为1	
	char* p = (char*)arr;

	for (int i = 0; i < arrLength; i++) {
		char* elemAddr = p + elemSize * i;			//当前数组元素的地址
		//if ((*(int*)elemAddr == *(int*)target)	//数组元素类型固定
		/* 将元素比较的操作放在回调函数中，由用户指定具体类型 */
		if (doCompare(elemAddr, target)) {
			return true;
		}
	}
	return false;
}

//回调函数1-比较整型数据
bool compareInt(void* data1, void* data2){
	return *(int*)data1 == *(int*)data2;
}

struct Object {
	int field;
	char attr[64];
};

//回调函数2-比较结构体数据
bool compareStruct(void* data1, void* data2) {
	struct Object* obj1 = (struct Object*)(data1);
	struct Object* obj2 = (struct Object*)(data2);
	return (strcmp(obj1->attr, obj2->attr) == 0) && (obj1->field == obj2->field);
}

int main() {
	int arr[] = { 1, 2 ,3 ,4 ,5 };
	int target = 6;
	bool flag1 = findElement(arr, sizeof(int), sizeof(arr) / sizeof(int), &target, compareInt);
	if (flag1) {
		printf("元素%d存在\n", target);
	}
	else {
		printf("元素%d不存在\n", target);
	}

	struct Object objs[] = { {1, "Tom"}, {2, "Jerry"}, {3, "Lucy"}, {4, "Lily"} };
	struct Object obj = { 3, "Newsom" };
	bool flag2 = findElement(objs, sizeof(struct Object), sizeof(objs) / sizeof(struct Object), &obj, compareStruct);
	if (flag2) {
		printf("元素%s--%d存在\n", obj.attr, obj.field);
	}
	else {
		printf("元素%s--%d不存在\n", obj.attr, obj.field);
	}
	return 0;
}

5.3 任意数据类型数组的排序

需求：使用冒泡排序算法，实现对任意数据类型数组元素的降序排序。

#include <stdio.h>
#include <stdbool.h>
#include <string.h>

/* 提供对外的通用接口，实现对任意数据类型数组元素的降序排序 */
/*
	arr：数组指针
	elemSize：数组元素的大小
	arrLength：数组长度
	target：指向指定元素的指针
	void (*doCompare)(void*, void*)：用户自定义的回调函数，比较两元素的大小（降序）
*/
void sortArray(void* arr, int elemSize, int arrLength, bool (*doCompare)(void*, void*)) {
	//申请elemSize大小的堆区空间，用于memcpy交换元素
	//强转为char*类型，将指针的步长置为1	
	char* temp = (char *)malloc(elemSize);

	for (int i = 0; i < arrLength - 1; i++) {
		for (int j = 0; j < arrLength - i - 1; j++) {
			char* cur = (char*)arr + elemSize * j;			//当前元素
			char* next = (char*)arr + elemSize * (j + 1);	//下一个元素

			//此写法：数组元素类型固定，无法扩展
			//if (*(int *)cur < *(int *)next) {}
			/* 将元素比较的操作放在回调函数中，由用户指定具体类型 */
			if (doCompare(cur, next)) {
				//通过内存拷贝函数memcpy，实现元素交换
				memcpy(temp, cur, elemSize);
				memcpy(cur, next, elemSize);
				memcpy(next, temp, elemSize);
			}
		}
	}
}

//回调函数1-比较整型数据（降序）
bool compareInt(void* data1, void* data2) {
	return *(int*)data1 < *(int*)data2;
}

struct Object {
	int field;
	char attr[64];
};

//回调函数2-比较结构体数据
bool compareStruct(void* data1, void* data2) {
	struct Object* obj1 = (struct Object*)(data1);
	struct Object* obj2 = (struct Object*)(data2);
	return obj1->field < obj2->field;
}

int main() {
	int arr[] = { 1, 2 ,3 ,4 ,5 };
	sortArray(arr, sizeof(int), sizeof(arr) / sizeof(int), compareInt);
	
	for (int i = 0; i < sizeof(arr) / sizeof(int); i++) {
		printf("%d\n", arr[i]);
	}
	//5 4 3 2 1

	struct Object objs[] = { {1, "Tom"}, {2, "Jerry"}, {3, "Lucy"}, {4, "Lily"} };
	sortArray(objs, sizeof(struct Object), sizeof(objs) / sizeof(struct Object), compareStruct);
	
	for (int i = 0; i < sizeof(objs) / sizeof(struct Object); i++) {
		printf("%s--%d\n", objs[i].attr, objs[i].field);
	}
	//Lily--4    Lucy--3    Jerry--2    Tom--1

	return 0;
}