路由硬盘做网站空间不搜索引擎营销的主要模式
目录
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就是典型的用了回调函数的场景。