C语言：指针的详细讲解3_qsort默认升序-CSDN博客

本文链接：https://blog.csdn.net/weixin_55547460/article/details/123469026

本文详细介绍了回调函数的概念，强调其灵活性和在代码优化中的作用。通过示例展示了如何使用回调函数减少重复代码，并讨论了qsort快速排序函数及其自定义排序功能。此外，还讲解了如何实现自定义排序类型的冒泡排序，重点在于参数为void*类型的通用性处理。

摘要由CSDN通过智能技术生成

1.回调函数

1.1回调函数是什么

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

在这里插入图片描述
你会发现经过设计的print_hehe函数中，形参是一个函数指针，你就可以根据这个函数指针，自由的去设计一个新的函数，等再次调用print_hehe函数后，将自己写好的函数传过去，就可以实现一个回调函数的利用，这样灵活性更高，其他冗余和复杂的事情，可以更快的在函数中处理，你只需要把会变化的关键点写成函数传过去就可以了

1.2怎样使用回调函数能凸显出回调函数的优点

我们再去看这个代码

#include <stdio.h>
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 main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	do
	{
		printf( "*************************\n" );
		printf( " 1:add 2:sub \n" );
		printf( " 3:mul 4:div \n" );
		printf( "*************************\n" );
		printf( "请选择：" );
		scanf( "%d", &input);
		switch (input)
		{
		case 1:
				printf( "输入操作数：" );
				scanf( "%d %d", &x, &y);
				ret = add(x, y);
				printf( "ret = %d\n", ret);
				break;
		case 2:
				printf( "输入操作数：" );
				scanf( "%d %d", &x, &y);
				ret = sub(x, y);
				printf( "ret = %d\n", ret);
				break;
		case 3:
				printf( "输入操作数：" );
				scanf( "%d %d", &x, &y);
				ret = mul(x, y);
				printf( "ret = %d\n", ret);
				break;
		case 4:
				printf( "输入操作数：" );
				scanf( "%d %d", &x, &y);
				ret = div(x, y);
				printf( "ret = %d\n", ret);
				break;
		case 0:
				printf("退出程序\n");
				break;
		default:
				printf( "选择错误\n" );
				break;
		}
	} while (input);
	return 0;
}

你会发现在break的地方代码十分的重复和冗余
在这里插入图片描述
这种情况下我们就可以利用回调函数去优化代码

int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}


void menu()
{
	printf("**************************\n");
	printf("****  1.add   2.sub   ****\n");
	printf("****  3.mul   4.div   ****\n");
	printf("****  0.exit          ****\n");
	printf("**************************\n");
}

void calc(int (*pf)(int,int))
{
	int x = 0;
	int y = 0;
	int ret = 0;

	printf("请输入2个操作数:>");
	scanf("%d%d", &x, &y);
	ret = pf(x, y);
	printf("ret = %d\n", ret);
}

int main()
{
	int input = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			calc(Add);
			break;
		case 2:
			calc(Sub);
			break;
		case 3:
			calc(Mul);
			break;
		case 4:
			calc(Div);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);

	return 0;
}

我们设计了一个calc计算函数去处理那些冗余重复的代码，只需要将想用的函数传到calc函数，calc可以把输入参数和打印等重复的工作做完，让代码简洁方便，但缺点就是，你的大部分函数的函数指针类型必须一样才可以，否则函数指针类型不对应，传入的函数也不能去实现计算

1.3回调函数的使用和qsort快速排序

下面是一个很普通的冒泡排序函数

void bubble_sort(int arr[], int sz)
{
	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])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

但这个冒泡排序函数有个缺陷，也就是只能排序int型的内容，如果我想排序字符串类型，结构体应该怎么去做呢

我们下面可以用到include<stdlib.h>头文件中的qsort函数，也就是快速排序函数
qsort函数有4个参数，其中最特殊的就是后面的cmp函数指针

在这里插入图片描述

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

int s[10000], n, i;

int cmp(const void *a, const void *b)
{
     return (*(int *)a - *(int *)b);
}

int main()
{
     scanf("%d", &n);
     for(i = 0; i < n; i++) 
         scanf("%d", &s[i]);

     qsort(s, n, sizeof(s[0]), cmp);

     for(i = 0; i < n; i++) 
         printf("%d ", s[i]);

     return 0;
}

qsort函数默认是升序的，假如我们想降序，就可以修改cmp函数元素的位置，实现返回值的颠倒，从而实现降序，也就是说原本第一个元素大于第二个元素，我们修改第一个元素和第二个元素的位置后，返回值就会变化

int cmp(const void *a, const void *b)
{
     return (*(int *)a - (*(int *)b;
}

这样就可以实现降序

类似的我们还可以根据结构体中的字符串去排列

struct stu
{
	int a;
	char s[20];
	double d;
};

int cmp_char(const void* e1, const void* e2)
{
	return strcmp(((struct stu*)e1)->s, ((struct stu*)e2)->s);
}

int main()
{

	struct stu arr_stu[3] = { {10,"hahahaha",30.0},{20,"duwdjdjd",50.0},{80,"sdhdhdh",27.5} };
	qsort(arr, sz_int, sizeof(arr[0]), cmp_int);
	for (int i = 0; i < sz_int; i++)
	{
		printf("%d ",arr[i]);
	}
	qsort(arr_stu, sizeof(arr_stu) / sizeof(arr_stu[0]), sizeof(arr_stu[0]), cmp_char);

}

上面利用了strcmp函数去比较字符串，返回的值刚好符合cmp所返回的值

1.4根据sqort函数去实现可以自定义排序类型的冒泡排序

int cmp_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}

void Swap(void*p1,void*p2,int sz)
{
	for (int i = 0; i < sz; i++)
	{
		char tmp = *((char*)p1 + i);
		*((char*)p1 + i) = *((char*)p2 + i);
		*((char*)p2 + i) = tmp;
	}
}
void my_bubble(void* arr, int num, int sz, int(*cmp)(const void*, const void*))
{
	int i = 0;
	int j = 0;
	for (i = 0; i < num; i++)
	{
		for (j = 0; j < num - 1 - i; j++)
		{
			if (cmp(((char*)arr+sz*j),((char*)arr+sz*(j+1))) > 0)
			{
				Swap(((char*)arr + sz * j), ((char*)arr + sz * (j + 1)),sz);
			}
		}
	}
}

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

int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	my_bubble(arr, sz, sizeof(arr[0]), cmp_int);
	my_printf(arr, sz);
}

首先我们要注意的是参数类型都是void* 的，为的就是更好得去使用，因为作者是不知道我们要使用时是用什么类型,而void*能存放各种类型的地址
写的Swap函数需要一个字节一个字节去交换要交换的内容，只需要传递出要交换的两个元素地址和一个元素多少个字节，在内部转换成char* 类型，然后一个字节一个字节交换，就可以实现各种类型的元素，各种不同字节元素的交换
比较的时也是同理，去根据穿传递过来的元素类型去知晓要比的内容字节是多少