指针进阶二——函数指针、函数指针数组、回调函数

函数指针

函数指针的定义
顾名思义，是指向函数的指针，存放的是函数的地址。
接下来我们创建一个Add函数，然后通过%p打印出函数的地址。

int Add(int x, int y) {
	return x + y;
}
int main() {
	printf("%p\n", Add);
	printf("%p\n", &Add);
	return 0;
}

运行结果如图所示：

可知&Add与Add都能拿到函数的地址。与数组不同，对于函数而言，两者具有相同意义。
那如何创建一个函数指针存放函数的地址呢？与数组指针类似，使用()让*与变量相结合；因其指向函数，变量后加上()，并填上参数类型；变量前加上函数的返回类型。
存放上文Add函数的函数指针如下：

    int (*pf)(int, int) = Add;

将 pf 从中取出得到 int (*)(int, int) ，得到的便是函数指针的类型。正如前文数组指针 int (*p)[5] ，取出 p 后，留下的便是数组指针类型 int (*)[5] ，也就是说指针 p 指向的数组类型是 int (*)[5] ，同理 pf 指向的函数类型是 int (*)(int, int)。

函数指针的使用

int main(){
    int (*pf)(int, int) = Add;
    int ret1 = Add(2, 3);
    int ret2 = (*pf)(2, 3);
    int ret3 = pf(2, 3);		
    printf("%d\n", ret1);
    printf("%d\n", ret2);
    printf("%d\n", ret3);
    return 0;
}

运行结果如下：

上述代码说明无论是 (*pf)(2, 3) 还是 **pf(2, 3)**都能正确调用函数，因此，函数指针是否解引用不影响使用。上文便是函数指针使用的基本用法。
另外 ，函数指针的使用，有时会降低代码的可读性，观察以下两个代码：

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

首先对代码进行拆分，分为

    void (*)(int)   signal(int, void(*)(int));
    // signal 是一个函数声明
    // signal 两个参数，分别是int和void(*)(int)
    // signal 返回类型是void (* )(int) 

使用 typedef 可进行如下变化

    typedef void(*pf_t)(int);	
    //将void (* )(int) 命名为 pf_t
    //上述代码可改为
    pf_t signal(int, pf_t);

因此，signal函数是一个参数为 int 和 函数指针的一个函数，返回值为 函数指针

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

将改代码逐个拆分

    void (*)()          // 函数指针类型
    (void (*)())        // 强制类型转换 
    (void (*)())0       // 对0进行强制类型转换 
    (*(void (*)())0)()  // 对0进行解引用

因此，该代码首先把0强转为函数指针类型，意味着0地址处放在一个返回类型是void的无参函数；接着解引用0处地址，调用这个函数。

---

函数指针数组

函数指针数组是对指针数组和函数指针的一种重要应用。
那么函数指针数组该如何定义呢？
观察如下代码：

    int (*p1[10])();
    int* parr2[10]();
    int (*)() parr3[10];

首先p1才是规范的函数指针数组的写法。
p1 先和 [] 结合，说明 p1是数组，数组的元素是 int (*)() 类型的函数指针。
函数指针数组的应用——转移表
首先定义加减乘除四则运算的函数

int add(int a, int b){
    return a + b;
}
int sub(int a, int b){
    return a - b;
}
int mul(int a, int b){
    return a * b;
}
int div(int a, int b){
    return a / b;
}

创建函数指针数组存放函数地址

    int(*p[])(int, int) = { 0, Add, Sub, Mul, Div };

对函数指针数组进行调用可实现计算器

int main()
{
    int x, y;
    int input = 1;
    int ret = 0;
    int(*p[])(int, int) = { 0, Add, Sub, Mul, Div }; //转移表
    while (input)
    {
        printf("*************************\n");
        printf(" 1:add           2:sub \n");
        printf(" 3:mul           4:div \n");
        printf("*************************\n");
        printf("请选择：");
        scanf("%d", &input);
        if ((input <= 4 && input >= 1))
        {
            printf("输入操作数：");
            scanf("%d %d", &x, &y);
            // 调用
            ret = (*p[input])(x, y);
        }
        else {
            printf("输入有误\n");
            break;
        }
        printf("ret = %d\n", ret);
    }
    return 0;
}

重点语句 ret = (*p[input])(x, y) ，其中变量 input 决定函数指针数组的下标，进而通过地址调用相应函数。

---

回调函数

回调函数就是一个通过函数指针调用的函数。
如果把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。
回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应
接下来我们在使用和模拟库函数qsort的过程中感受回调函数 (下文中的比较函数) 的使用。

• 首先，使用库函数qsort需要手动实现比较函数，这里只实现比较int和char类型的比较函数。

int cmp_int(const void* e1, const void* e2) {
    // void* 能转变为任意 类型
    return (*(int*)e1 - *(int*)e2);
}
int cmp_char(const void* e1, const void* e2) {
    return strcmp(*(char**)e1 , *(char**)e2);
}

cmp_int 中将 e1和e2强制类型转换为 int* 类型，再解引用进行比较。
cmp_char 中将 e1和e2 强制类型转换为 char** 类型，再解引用进行比较。因为我们向 qsort 传入 arr 之后，qsort 将 arr 理解为指向数组中第一个元素的指针，然而在形参表中，e1 和 e2 其实是指向 “指向常量字符串的指针”的指针 ，是 char**。(因为数组名本身算一层指针，而里面的内容又是一层指针，数组存放的是指向字符串的地址)(即arr->e1->字符串)
而我们需要传给strcmp这个字符串比较函数的参数，是 “指向字符串的指针”，是 char*，所以我们将 void* 转换为 char**，然后解引用，得到 char*，接下来使用 strcmp 进行比较。

• 接着创建数组使用库函数进行排序。

int main() {
    int arr1[] = { 1,5,2,3,6,4,7,8,9 };
    char* arr2[] = { "aaaa","dddd","cccc","bbbb" };
    int sz1 = sizeof(arr1) / sizeof(arr1[0]);
    int sz2 = sizeof(arr2) / sizeof(arr2[0]);
    qsort(arr1, sz1, sizeof(arr1[0]), cmp_int);
    qsort(arr2, sz2, sizeof(arr2[0]), cmp_char);
    return 0;
}

运行结果如下所示：
排序前：

排序后：

通过冒泡排序模拟实现库函数qsort

• 首先创建整型比较函数和交换函数

int int_cmp(const void* p1, const void* p2)
{
   return (*(int*)p1 - *(int*)p2);
}
void _swap(void* p1, void* p2, int size)
{
   int i = 0;
   for (i = 0; i < size; i++)
   {
       char tmp = *((char*)p1 + i);
       *((char*)p1 + i) = *((char*)p2 + i);
       *((char*)p2 + i) = tmp;
   }
}

• 然后通过冒泡排序思想进行排序

void bubble(void* base, int count, int size, int(*cmp)(void*, void*))
{
   int i = 0;
   int j = 0;
   for (i = 0; i < count - 1; i++)
   {
       for (j = 0; j < count - i - 1; j++)
       {
           // 比较
           if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
           {
               // 交换
               _swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
           }
       }
   }
}
int main()
{
   int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
   int i = 0;
   bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
   return 0;
}

运行结果如下：

---

总结

• 函数指针是指向函数的指针，使用时是否解引用意义相同。
• 函数指针数组是函数指针的重要应用，例如转移表。
• 回调函数是一个通过函数指针调用的函数。当某个函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。
• 使用库函数qsort时，需要手动实现比较函数，比较函数的参数需要强制转换，注意类型的匹配！(比如char类型的匹配问题)