C语言进阶 -- 回调函数以及qsort函数的使用

柔光的暖阳◎ 2023-10-08 17:09 20阅读 0赞

## 一、回调函数 ##

### 1.1、什么是回调函数？？？ ###

> 回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。  
> 上面的说法有点复杂，我们看一段代码理解上面的意思：  
> ![在这里插入图片描述][ed2aee4e1fad4bec95416cb171f8f515.png]

## 二、qsort函数的介绍 ##

[qsort函数][qsort]

### 2.1、qsort函数的使用 ###

> qsort函数就是对数组进行排序，进行升序，不管是什么类型的数组都可以进行排序，int，char，float，结构体类型，这些都是可以的。

**例如：对整型数组进行排序**

int compar(const void* a, const void* b)
    {
        
    	return (*(int*)a - *(int*)b);
    }
    
    int main()
    {
        
    	int arr[10] = {
         10,5,8,9,4,6,7,2,11,98 };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	qsort(arr, sz, sizeof(arr[0]), compar);
    	int i = 0;
    	for (i = 0; i < sz; i++)
    	{
        
    		printf("%d ",arr[i]);
    	}
    	return 0;
    }

![在这里插入图片描述][ec3e018e99ba497698f48bb64631f78d.png]

**例如：对字符数组进行排序**

int compar(const void* a, const void* b)
    {
        
    	return (*(char*)a - *(char*)b);
    }
    
    int main()
    {
        
    	int arr[] = {
         'w','d','g','h','p'};
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	qsort(arr, sz, sizeof(arr[0]), compar);
    	int i = 0;
    	for (i = 0; i < sz; i++)
    	{
        
    		printf("%c ", arr[i]);
    	}
    	return 0;
    }

![在这里插入图片描述][a79486ed56cd4cfbab18a0b5096c42fd.png]  
**例如：对结构体数组进行排序**

struct Stu 
    {
        
    	char name[20];
    	int age;
    };
    int compar(const void* a, const void* b)
    {
        
    	return strcmp(((struct Stu*)a)->name, ((struct Stu*)b)->name);
    }
    
    int main()
    {
        
    	struct Stu arr[] = {
         {
        "zhangsan", 20},{
        "lisi", 18}};
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	qsort(arr, sz, sizeof(arr[0]), compar);
    	int i = 0;
    	for(i = 0; i < sz; i++)
    	{
        
    		printf("%s  %d\n", arr[i].name, arr[i].age);
    	}
    	return 0;
    }

![在这里插入图片描述][a2526ddd7e1645cd9cb250889b2fd69a.png]  
**所以只要我们将sqort中比较的函数实现成我们想要的样子，那样就可是比较任何数据类型了**

### 2.2、实现sqort函数（冒泡排序实现） ###

我们知道排序的算法有很多：冒泡排序，选择排序，插入排序，快速排序…  
而C语言库函数中的sqort函数是由快速排序实现的，那我们就用冒泡排序实现。  
首先：看一个整型的冒泡排序

void sort(int arr[], int sz)
    {
        
    	int i = 0;
    	//sz -- 表示数组有多少个元素，sz-1就是要拍序多少趟
    	for (i = 0; i < sz - 1; i++)
    	{
        
    		int j = 0;
    		//sz - 1 - i 表示这一趟要比较多少对
    		for (j = 0; j < sz - 1 - i; j++)
    		{
        
    			if (arr[j] > arr[j + 1])
    			{
        
    				int tmp = arr[j];
    				arr[j] = arr[j + 1];
    				arr[j + 1] = tmp;
    			}
    		}
    	}
    }
    int main()
    {
        
    	int arr[] = {
         9,8,7,6,5,4,3,2,1,0 };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	sort(arr,sz);
    
    	int i = 0;
    	for (i = 0; i < sz; i++)
    	{
        
    		printf("%d ",arr[i]);
    	}
    	return 0;
    }

![在这里插入图片描述][bb69cf7d6bca48779d8433c5d9db3afd.png]

#### 2.2.1、参考库函数里面的qsort函数来实现函数参数 ####

![在这里插入图片描述][5084fbbefc434d62987514771fc6f066.png]  
*注意：void 这是什么意思？？*\*  
void\* 就是无类型指针，任何指针类型都可以通过void*来存放  
但是void* 不能运算，不能进行±运算，也不能进行解引用操作  
![在这里插入图片描述][aef310d9b3e1484bbf1dda915ea965f8.png]

![在这里插入图片描述][0993b80e253147e99f62098d43ff2c64.png]

实现qsort：

int compare(const void* elem1, const void* elem2)
    {
        
    	return (int*)elem1 - (int*)elem2;
    }
    
    void Swpa(const void* s1, const void* s2, int width)
    {
        
    	int i = 0;
    	for (i = 0; i < width; i++)
    	{
        
    		char* tmp = (char*)s1;
    		(char*)s1 = (char*)s2;
    		(char*)s2 = tmp;
    	}
    }
    void my_qsort(void* base, size_t sz, size_t width,
    	          int(__cdecl* compare)(const void* elem1, const void* elem2))
    {
        
    	size_t i = 0;
    	//sz -- 表示数组有多少个元素，sz-1就是要拍序多少趟
    	for (i = 0; i < sz - 1; i++)
    	{
        
    		size_t j = 0;
    		//sz - 1 - i 表示这一趟要比较多少对
    		for (j = 0; j < sz - 1 - i; j++)
    		{
        
    			if (compare((char*) base+j*width, (char*)base + (j + 1) * width) > 0)
    			{
        
    				Swpa( (char*)base + j * width, (char*)base + (j + 1) * width , width);
    			}
    		}
    	}
    }
    
    int main()
    {
        
    	int arr[] = {
         9,8,7,6,5,4,3,2,1,0 };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	my_qsort(arr,sz,sizeof(arr[0]),compare);
    
    	int i = 0;
    	for (i = 0; i < sz; i++)
    	{
        
    		printf("%d ",arr[i]);
    	}
    	return 0;
    }

![在这里插入图片描述][c6ca127d6bd54e79885cfcbf228e04dd.png]

1、使用自己实现的qsort对结构体进行排序

struct Stu
    {
        
    	char name[20];
    	int age;
    };
    //比较整型
    int cmp_int(const void* e1, const void*e2)
    {
        
    	return *(int*)e1 - *(int*)e2;
    }
    //通过姓名来比较
    int cmp_by_name(const void*e1, const void*e2)
    {
        
    	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
    }
    
    //通过年龄来比较
    int cmp_by_age(const void* e1, const void* e2)
    {
        
    	return ((struct Stu*)e1)->age -((struct Stu*)e2)->age;
    }
    
    void Swap(char* buf1, char* buf2, int width)
    {
        
    	int i = 0;
    	for (i = 0; i < width; i++)
    	{
        
    		char tmp = *buf1;
    		*buf1 = *buf2;
    		*buf2 = tmp;
    		buf1++;
    		buf2++;
    	}
    }
    
    void my_qsort(void* base, size_t sz, size_t width,
    	int(__cdecl* compare)(const void* elem1, const void* elem2))
    {
        
    	size_t i = 0;
    	//sz -- 表示数组有多少个元素，sz-1就是要拍序多少趟
    	for (i = 0; i < sz - 1; i++)
    	{
        
    		size_t j = 0;
    		//sz - 1 - i 表示这一趟要比较多少对
    		for (j = 0; j < sz - 1 - i; j++)
    		{
        
    			if (compare((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
    			{
        
    				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
    			}
    		}
    	}
    }
    
    
    int main()
    {
        
    	struct Stu arr[] = {
         {
        "zhangsan", 20},{
        "lisi", 18} };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	my_qsort(arr, sz, sizeof(arr[0]), cmp_by_name);
    	int i = 0;
    	for (i = 0; i < sz; i++)
    	{
        
    		printf("%s  %d\n", arr[i].name, arr[i].age);
    	}
    	return 0;
    }

[ed2aee4e1fad4bec95416cb171f8f515.png]: https://img-blog.csdnimg.cn/ed2aee4e1fad4bec95416cb171f8f515.png
[qsort]: https://www.runoob.com/cprogramming/c-function-qsort.html
[ec3e018e99ba497698f48bb64631f78d.png]: https://img-blog.csdnimg.cn/ec3e018e99ba497698f48bb64631f78d.png
[a79486ed56cd4cfbab18a0b5096c42fd.png]: https://img-blog.csdnimg.cn/a79486ed56cd4cfbab18a0b5096c42fd.png
[a2526ddd7e1645cd9cb250889b2fd69a.png]: https://img-blog.csdnimg.cn/a2526ddd7e1645cd9cb250889b2fd69a.png
[bb69cf7d6bca48779d8433c5d9db3afd.png]: https://img-blog.csdnimg.cn/bb69cf7d6bca48779d8433c5d9db3afd.png
[5084fbbefc434d62987514771fc6f066.png]: https://img-blog.csdnimg.cn/5084fbbefc434d62987514771fc6f066.png
[aef310d9b3e1484bbf1dda915ea965f8.png]: https://img-blog.csdnimg.cn/aef310d9b3e1484bbf1dda915ea965f8.png
[0993b80e253147e99f62098d43ff2c64.png]: https://img-blog.csdnimg.cn/0993b80e253147e99f62098d43ff2c64.png
[c6ca127d6bd54e79885cfcbf228e04dd.png]: https://img-blog.csdnimg.cn/c6ca127d6bd54e79885cfcbf228e04dd.png