1.回调函数

回调函数就是一个通过函数指针调用的函数。

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

Calc（Add）——>void Calc（int（*p）（int，int））——>pf——>int Add（int x，int y）——

                                                                                                                                                    |

                                                                                                          ret <—— return x+y <——

2.qsort 使用举例

头文件：<stdlib.h>

qsort函数原型：

void qsort（void* base，size_t num，size_t size，int （*cmp）（const void*，const void*））

其中：

void* base：指向待排序数组的第一个元素的指针。

size_t num：base指向数组中的元素个数。

size_t size：base指向的数组中一个元素的大小，单位是字节。

int （*cmp）（const void*，const void*）：函数指针——传递函数的地址。

举例1：排序整型数据

#include <stdio.h>

void print_arr(int arr[], int sz)
{
    for (int i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
}

int cmp_int(const void* p1, const void* p2)
{
    if (*(int*)p1 > *(int*)p2)
    {
        return 1;
    }
    else if (*(int*)p1 < *(int*)p2)
    {
        return -1;
    }
    else
    {
        return 0;
    }
}

//测试qsort，来排序整型数据。
void test1()
{
    int arr[] = { 3,1,7,9,4,2,6,5,8,0 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    qsort(arr, sz, sizeof(arr[0]), cmp_int);
    print_arr(arr, sz);
}

int main()
{
    test1();

    return 0;
}

举例2：排序结构体

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

void print_arr(int arr[], int sz)
{
    for (int i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
}

struct Stu
{
    char name[20];
    int age;
};

//测试qsort，排序结构体数据
//比较两个结构体数据

int cmp_stu_by_name(const void* p1, const void* p2)
{
    return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}

int cmp_stu_by_age(const void* p1, const void* p2)
{
    return (((struct Stu*)p1)->age - ((struct Stu*)p2)->age);
}
//按照名字排序
void test2()
{
    struct Stu arr[] = { {"zhangsan",20},{"lisi",35},{"wangwu",18}};
    int sz = sizeof(arr) / sizeof(arr[0]);
    qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}

//按照年龄排序
void test3()
{
    struct Stu arr[] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
    int sz = sizeof(arr) / sizeof(arr[0]);
    qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
}

int main()
{
    //test2();
    test3();

    return 0;
}

伪代码：将qsort函数改编为通用类型排序函数

Swap( char* buf1 , char* buf2 , size_t width )
{
    int i = 0;
    char temp = 0;
    for (i = 0; i < width; i++)
    {
        temp = *buf1;
        *buf1 = *buf2;
        *buf2 = temp;
    }
}

void bubble_sort(void* base,size_t sz,size_t width,int (*cmp)(const void* p1,const void* p2))
{
    //躺数
    int i = 0;
    for (i = 0; i < sz - 1; i++)
    {
        int j = 0;
        for (j = 0; j < sz - 1 - i; j++)
        {
            //if (arr[j]>arr[j+1])
            //比较两个元素
            if(cmp( (char*)base+j*width,(char*)base+(j+1)*width )>0)
            {
                //交换两个函数
                Swap( (char*)base + j * width, (char*)base + (j + 1) * width ,width );
            }
        }
    }
}

里面涉及到“回调函数”的应用，同时使用了函数指针来进行传递。特别说明一下，其中的（char*）目的是为了将base强制转换为1字节这样在加常量时，便于指针指向的后移。

注：读者可以进行思考，如果有什么实在不理解的，欢迎评论区留言。