C进阶：指针的进阶（4）

た入场券 2023-10-13 19:18 36阅读 0赞

![1db8ab180ffa4829be6af2d502d88340.png][]

## 回调函数 ##

> **回调函数就是一个通过函数指针调用的函数。**（函数指针的一个非常重要的作用就是实现回调函数）。**如果你把这个函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。****回调函数不是由该函数的实现方直接调用，而是在特定的事件或者条件发生时由另一方实现调用的，用于对该事件或条件进行响应。**
> 
> **举例：**比如B函数中有一个参数是A函数的地址，在使用B函数时调用了A函数，我们就说A函数是回调函数。

下面我们通过qsort这一重要的快速排序函数来了解一下回调函数。

//头文件：#include <stdlib.h>
    
    void qsort(void* base,//指向了被排序的第一个函数
    	size_t sum,//排序的元素个数，size_t指无符号整数
    	size_t size,//一个元素大小，单位是字节
    	//函数指针类型——这个函数指针指向一个函数，能够比较base指向的两个函数
        //这个回调函数返回小于零的数表明p1<p2
        //返回大于零的数表明p1>p2
        //返回等于零的数表明p1=p2
    	int (*cmp)(const void* p1, const void* p2)
    );
    
    //void*指针是无类型指针，可以接受任意类型的地址（这也是qsort函数的一个重要的特点）
    //（因为这个函数不知道你要排序什么类型的指针，所以用void*）
    //1.不能进行解引用操作，2.不能直接进行指针运算

下面来看一下qsort函数的使用（这里使用整型和结构体排序为例）

**整型类型排序**

#include <stdio.h>
    #include <stdlib.h>
    
    //注意：这个函数需要自己书写（注意升降序）
    int int_cmp(const void* p1, const void* p2)
    {
        //由于p1,p2都是void*类型的，不能直接进行解引用操作，
        //因此将它们转换为int*再解引用获得它们的值
    //这个是升序，若想改为降序，只需要将p1,p2的位置互换即可
    	return (*(int*)p1 - *(int*)p2);
    }
    
    print(int sz, int arr[])
    {
    	int i = 0;
    	for (i = 0; i < sz; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    }
    
    void test()
    {
    	int arr[] = { 3,1,4,5,8,6,7,9,0,2 };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	qsort(arr, sz, sizeof(int), int_cmp);
    	print(sz, arr);
    }
    
    int main()
    {
    	test();
    	return 0;
    }

**结构体类型排序(按照整型成员)**

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    struct Peo {
    	char name[20];
    	int age;
    };
    
    int cmp_byage(const void* p1, const void* p2)
    {
    	return (((struct Peo*)p1)->age - ((struct Peo*)p2) -> age);
    }
    
    test1()
    {
    	struct Peo p[] = {
       {"zhangsan",20},{"lisi",50},{"wangwu",15}};
    	int sz = sizeof(p) / sizeof(p[0]);
    	qsort(p, sz, sizeof(struct Peo), cmp_byage);
    }
    
    int cmp_byname(const void* p1, const void* p2)
    {
    	return strcmp(((struct Peo*)p1)->name, ((struct Peo*)p2)->name);
    }
    
    int main()
    {
    	test1();
    	return 0;
    }

按照整型成员升序排序结果

![906e7abf355e4fa6b3b35f6ebfe37d1c.png][]

**结构体类型排序（按照字符串成员）**

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    struct Peo {
    	char name[20];
    	int age;
    };
    
    int cmp_byname(const void* p1, const void* p2)
    {
    	return strcmp(((struct Peo*)p1)->name, ((struct Peo*)p2)->name);
    }
    
    void test2()
    {
    	struct Peo p[]= { {"zhangsan",20},{"lisi",50},{"wangwu",15} };
    	int sz = sizeof(p) / sizeof(p[0]);
    	qsort(p, sz, sizeof(struct Peo), cmp_byname);
    }
    
    int main()
    {
    	test2();
    	return 0;
    }

按照字符串类型成员升序排序结果

![247dc5798c2644478200d466cd996805.png][]

**模拟实现**

> 为了帮助我们更好地理解qsort 函数的原理，下面我会带大家来模拟实现一下这个函数。
> 
> > 我们给它起名起名曰：bubble\_sort( )
> > 
> > **1.使用的这个函数的思想是冒泡排序的思想。**
> > 
> > **2.它可以适用于各种类型的排序。**

> 要搞清这个函数的具体实现方法，我们首先要思考下面几个问题：
> 
> **1.对于不同类型的数据，我们万万不能使用简单的数学比较符号来比较。**
> 
> **解决：我们可以将2个元素的比较方法，以函数参数的形式传递，不同类型传不同比较方法。**
> 
> **2.不同数据类型，交换略有差异。**
> 
> **解决：在bubble\_sort()函数内部嵌套使用一个swap函数，将比较的两个元素传递过去，由于不知道元素的类型，所以我们以char\*的形式传递（因为走过char\*的步长最小，我们可以根据元素大小size一个一个字节进行交换）。**

**下面我们来看一下具体代码（以整型数组的升序排序为例）**

#include <stdio.h>
    #include <string.h>
    
    //非字符串类型的比较方法
    int int_cmp(const void* p1, const void* p2)
    {
    	return (*(int*)p1 - *(int*)p2);
    }
    
    //字符串类型的比较方法
    //int char_cmp(const void* p1, const void* p2)
    //{
    //	return strcmp(根据两个字符串相关类型传入有关参数);
    //}
    
    //交换函数swap的实现
    void swap(char* buf1, char* buf2, int size)
    {
    	int i = 0;
    	char tmp = 0;
    	for (i = 0; i < size; i++)
    	{
    		//由于不知道交换数据的具体单位，所以我么逐字节进行数据交换
    		tmp = *buf1;
    		*buf1 = *buf2;
    		*buf2 = tmp;
    		buf1++;
    		buf2++;
    	}
    }
    
    void bubble_sort(void* base, int count, int size, int(*cmp)(void*, void*))
    {
    	//确定交换的趟数
    	int i = 0;
    	for (i = 0; i < count - 1; i++)
    	{
    		//确定一趟交换类型的次数
    		int j = 0;
    		for (j = 0; j < count - 1 - i; j++)
    		{
    			//这里假设是升序交换（即>0）
    			//跟据交换参数的类型不同，将位置定位到第j个和第j+1个元素的位置上
    			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
    			{
    				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
    			}
    		}
    	}
    }
    
    //打印
    void print(int arr[], int sz)
    {
    	int i = 0;
    	for (i = 0; i < sz; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    }
    
    void test()
    {
    	int arr[] = { 3,1,6,4,7,8,2,5,9,0 };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	bubble_sort(arr, sz, sizeof(arr[0]), int_cmp);
    	print(arr, sz);
    }
    
    int main()
    {
    	test();
    	return 0;
    }

好了，这就是回调函数及qsort函数的所有内容，感谢各位未来的大厂员工支持！！！

[1db8ab180ffa4829be6af2d502d88340.png]: https://img-blog.csdnimg.cn/1db8ab180ffa4829be6af2d502d88340.png
[906e7abf355e4fa6b3b35f6ebfe37d1c.png]: https://img-blog.csdnimg.cn/906e7abf355e4fa6b3b35f6ebfe37d1c.png
[247dc5798c2644478200d466cd996805.png]: https://img-blog.csdnimg.cn/247dc5798c2644478200d466cd996805.png