深入理解指针（四）

目录

1. 回调函数是什么?

​2. qsort使用举例

2.1冒泡排序

2.2使用qsort函数排序整型数据

​2.3 使用qsort排序结构数据(名字)

2.4 使用qsort排序结构数据(年龄)

3. qsort函数的模拟实现

---

1. 回调函数是什么?

回调函数就是⼀个通过函数指针调⽤的函数。

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

上述图片中的代码是之前计算器的代码,这种代码比较冗余,我们可以把重复的代码写成一个函数。

#include <stdio.h>
 
void menu()
{
	printf("**************************\n");
	printf("*****  1.Add  2.Sub  *****\n");
	printf("*****  3.Mul  4.Div  *****\n");
	printf("*****  0.Exit        *****\n");
	printf("**************************\n");
}
 
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 Calc(int(*pf)(int, int))
{
	int x = 0;
	int y = 0;
	int index = 0;
	printf("请输入两个操作数:>");
	scanf("%d %d", &x, &y);
	index = pf(x, y);
	printf("%d\n", index);
}
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;
}

输出结果:

2. qsort使用举例

qsort是C语言中的一个库函数,这个函数是用来对任意数据进行排序。

2.1冒泡排序

我们之前学习过一种排序,叫冒泡排序,冒泡排序的思想就是两两比较。

#include <stdio.h>
void bubble_sort(int* arr, int sz)
{
	for (int i = 0; i < sz - 1; i++)
	{
		for (int j = 0; j < sz - i - 1; j++)
		{
			if (*(arr + j) > *(arr + j + 1))
			{
				int tem = *(arr + j);
				*(arr + j) = *(arr + j + 1);
				*(arr + j + 1) = tem;
			}
		}
	}
}
void print_arr(int* arr, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", *(arr + i));
	}
}
int main()
{
	int arr[] = { 2,6,3,4,1,9,10,8,7,5 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	print_arr(arr, sz);
	return 0;
}

这种代码的功能比较单一,只能排序整型,如果想要排序浮点类型的数据或者其它类型的数据,函数的参数就比如重新设计了,而qsort函数能排序任何类型的数据。

2.2使用qsort函数排序整型数据

qsort:

qsort - C++ Reference

void qsort (void* base, size_t num, size_t size,int (*compar)(const void*,const void*));

 所以qsort的第四个参数就是一个函数,让我们传一个比较大小的函数进去即可,比如我现在想要比较结构体的数据,那么我就需要往进传一个两个结构体成员比较大小的函数,这样qsort就能实现想要排序什么数据就可以排序什么数据。

排序整型的代码:

#include <stdio.h>
#include <stdlib.h>
/*
p1指向的元素大于p2指向的元素就返回大于0的数字
p1指向的元素小于p2指向的元素就返回小于0的数字
p1指向的元素等于p2指向的元素就返回0
*/
//排序整型数据就得提供两个整型的比较函数
int cpm_int(const void*p1, const void*p2)
{
	//void*的指针不能解引用,必须强转,比较整型那就强转为int*
	return *(int*)p1 - *(int*)p2;
}
 
int main()
{
	int arr[10] = { 10,9,8,7,6,5,4,3,2,1 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cpm_int);
	for (int i = 0; i < 10; i++)
		printf("%d ", *(arr + i));
	return 0;
}

输出结果:

2.3 使用qsort排序结构数据(名字)

使用qsort排序结构体之前,先看一个操作符,->操作符。

#include <stdio.h>
struct Stu
{
	char name[20];
	int age;
	float light;
};
/*
结构体成员访问操作符
  .  结构体变量.成员名
  -> 结构体指针->成员名
*/
int main()
{
	struct Stu s = { "lixiangsi",20,170.0f };
 
	//得到结构体的变量名就用.操作符找结构体的每个成员
	printf("%s %d %f\n", s.name, s.age, s.light);
 
	//那如果现在得到的是结构体的地址呢?
	struct Stu* ps = &s; //struct Stu*是结构体指针类型
 
	//当得到结构体地址的时候,解引用再用.操作符找结构体每个成员
	printf("%s %d %f\n",(*ps).name, (*ps).age,(*ps).light);
 
	//->操作符的使用方法 得到结构体的地址也可以使用->操作符找到结构体的每个成员 
	printf("%s %d %f\n",ps->name,ps->age,ps->light);
	
	return 0;
}

输出结果:

排序结构体数据代码:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Stu
{
	char name[20];
	int age;
	float light;
};
int cmp_name(const void*p1, const void*p2)
{
	return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
	//strcmp这个函数中p1大于p2返回1,p1小于p2返回-1,p1等于p2返回0
	//刚好是我们需要的返回值,所以将strcmp的结果直接返回就行
}
 
int main()
{
	struct Stu s[] = { {"zhangsan",20,181.3f},{"lisi",18,175.5f},
		{"wangwu",25,178.8f} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_name);
	for (int i = 0; i < sz; i++)
		printf("%s %d %f\n", s[i].name, s[i].age, s[i].light);
	return 0;
}

代码运行结果:

 从运行结果可以看出按名字排序,lisi最小,wangwu次之,zhangsan最大,因为lisi的首字母l的ASCILL码值最小,w次之,z最大。

关于字符串怎么比较大小的方式可参考文章字符函数和字符串函数:字符函数和字符串函数-CSDN博客文章浏览阅读577次，点赞27次，收藏13次。在编程的过程中，我们经常要处理字符，为了⽅便操作字符，C语⾔标准库中提供了 ⼀系列操作字符的库函数。https://blog.csdn.net/m0_74271757/article/details/139031604?spm=1001.2014.3001.5501

参考文章中的6. strcmp 的使用和模拟实现章节

2.4 使用qsort排序结构数据(年龄)

#include <stdio.h>
#include <stdlib.h>
struct Stu
{
	char name[20];
	int age;
	float light;
};
int cmp_age(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
 
int main()
{
	struct Stu s[] = { {"zhangsan",20,181.3f},{"lisi",18,175.5f},
		{"wangwu",25,178.8f} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_age);
	for (int i = 0; i < sz; i++)
		printf("%s %d %f\n", s[i].name, s[i].age, s[i].light);
	return 0;
}

输出结果:

我们可以看到qsort函数默认排的是升序,那怎么降序呢?

我们只需要将我们的比较大小的函数返回值颠倒一下就可以,比如说第一个数比第二个数大,本来返回大于0的时候,我们返回小于0的数字,第一个数比第二个数小,本来返回小于0的数字,我们返回大于0的数字即可。

升序前面的大于后面的返回大于0的数字,就交换,现在降序的话前面的大于后面的就不需要交换,所以我们返回小于0的数字,相反,升序的话 前面小于后面的就不交换,但是降序的话前面小于后面的就需要交换,就返回大于0的数字。

3. qsort函数的模拟实现

我们可以将我们的冒泡排序函数bubble_sort函数改造成通用的算法,可以排序任意类型。

模仿qsort函数,只不过qsort底层用的是快速排序算法,而我们用冒泡排序算法实现。

函数参数以及返回值的设计:

 函数体的设计:

交换元素的代码设计:

my_qsort排序整型代码:

#include <stdio.h>
int cmp(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}
 
void swap(char* buf1, char* buf2,int size)
{
	for (int i = 0; i < size; i++)
	{
		char tem = *((char*)buf1 + i);
		*((char*)buf1 + i) = *((char*)buf2 + i);
		*((char*)buf2 + i) = tem;
	}
}
 
void my_qsort(void* base, size_t num, size_t size, int (*compar)(const void*, const void*))
{
	for (int i = 0; i < num - 1; i++)
	{
		for (int j = 0; j < num - i - 1; j++)
		{
			if (compar((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[10] = { 8,2,6,4,3,7,9,1,5,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	my_qsort(arr, sz, sizeof(arr[0]), cmp);
	for (int i = 0; i < sz; i++)
		printf("%d ", *(arr + i));
	return 0;
}

输出结果:

my_qsort函数排序结构体代码:

#include <stdio.h>
struct Stu
{
	char name[20];
	int age;
	float light;
};
int cmp_age(const void* p1, const void* p2)
{
	return ((struct Stu*)p2)->age - ((struct Stu*)p1)->age;
}
 
void swap(char* buf1, char* buf2,int size)
{
	for (int i = 0; i < size; i++)
	{
		char tem = *((char*)buf1 + i);
		*((char*)buf1 + i) = *((char*)buf2 + i);
		*((char*)buf2 + i) = tem;
	}
}
 
void my_qsort(void* base, size_t num, size_t size, int (*compar)(const void*, const void*))
{
	for (int i = 0; i < num - 1; i++)
	{
		for (int j = 0; j < num - i - 1; j++)
		{
			if (compar((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}
 
int main()
{
	struct Stu s[] = { {"zhangsan",20,167.0f},{"lisi",22,175.5f},{"wangwu",25,180.0f} };
	int sz = sizeof(s) / sizeof(s[0]);
	my_qsort(s, sz, sizeof(s[0]), cmp_age);
	for (int i = 0; i < sz; i++)
		printf("%s %d %f\n", s[i].name,s[i].age,s[i].light);
	return 0;
}

输出结果:

泛型编程里面大多数都是void*的指针。

qsort就是典型的用了回调函数的场景。