目录
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:
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就是典型的用了回调函数的场景。