一、回调函数
1.1回调函数是什么
回调函数就是一个通过函数指针调用的函数，那么这个函数就是回调函数。
如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数
时，被调用的函数就是回调函数。
#include<stdio.h>
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;
}
calc(int(*pf)(int,int))//通过函数指针来调用所指向的函数，则那个函数为回调函数
{
int x, y = 0;
int ret = 0;
printf("请输入二个操作数：");
scanf("%d %d", &x, &y);
ret = pf(x, y);//也可以写成ret = (*pf)(x,y)
printf("结果是：%d\n", ret);
}
int main()
{
int input = 0;
do
{
printf("**********************\n");
printf("***1.add 2.sub***\n");
printf("***3.mul 4.div***\n");
printf("*** 0.exit ***\n");
printf("**********************\n");
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");
default:
printf("请重新输入!\n");
break;
}
} while (input);
return 0;
}
回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。就是说函数并不是通过它的函数名取调用的，而是通过函数指针等间接调用函数。
二、qsort使用举例
qsort函数是C语言中的一个库函数，这个函数是用来对数据进行排序的，对任意类型的数据都能排序。qsort函数默认是排成升序，但是可以改变。
此时想一想，我们前面学习过冒泡排序法，下面给出部分代码：
bubble_arr(int p[], int sz)
{
int i = 0;
int flag = 1;//假定已满足排序
for (i = 0; i < sz - 1; i++)//每一趟
{
int j = 0;
for (j = 0; j < sz - 1 - i; j++)//每一趟完成一个数字的排序
{
count++;
if (p[j] > p[j+1])//升序排序
{
int flag = 0;//说明没有排序好
int temp = p[j];//交换
p[j] = p[j + 1];
p[j + 1] = temp;
}
}
if (flag == 1)
{
break;
}
}
}
可以看到在bubble_arr()函数的形参部分是接收的是int arr[10]中首元素的地址，该首元素的数据类型是int整型,说明了我们写的bubble_arr()函数只能排序int整型的数据。所以不能排序字符数组，字符串，浮点数，结构体。那么这个时候就可以使用qsort库函数来进行！
就比如：在冒泡排序中，对于排序字符串，在比较二个元素和交换二个元素的操作是与操作int整型不一样的，因为两个字符串比较大小不能使用 >,>=,<=,==,!=，而是应该用strcmp()函数来比较字符串的大小
qsort库函数的底层原理是：使用了快速排序的算法。
我们可以上网搜一下qsort库函数的参数：
void qsort(void * base, //base是指向待排序数组的第一个元素的指针
size_t num , //num是base指向的数组中的元素个数
size_t size , //size是base指向的数组中一个元素的大小，单位是字节
int(*cmp)(const void*, const void*) //函数指针 --- 传递函数的地址
//把你需要比较具体数据类型的函数提供给qsort就可以了
//qsort会根据你写的函数来排序大小
)
多说无益，我们使用qsort函数排序多个类型的数据直观感受，直接上代码，进行测试！
在代码一中，我们想要排序整型数据。
//代码一
#include<stdio.h>
//对函数的返回值有要求
//p1>p2,返回大于0的数
//p1=p2,返回等于0的数
//p1<p2,返回小于0的数
int cmp_int(const void* p1, const void* p2)
{
if (*(int*)p1 > *(int*)p2)//因为我们自己知道我们要排序的数据类型是什么
//那么我们就将无类型（void）指针强制转换为我们想要的指针类型
//比如我们想要排序整型的数据，那么就将指针强制转换为(int *)
//这样就可以通过解引用操作来找到数据
{
return 1;
}
else if (*(int*)p1 < *(int*)p2)
{
return -1;
}
else
return 0;
}
//打印排序后的数据
printf_arr(int arr[],size_t sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
//测试qsort，排序整型数据
test1()
{
int arr[] = { 3,1,7,9,4,2,6,5,8,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_int);
printf_arr(arr, sz);//结果为0 1 2 3 4 5 6 7 8 9
}
int main()
{
test1();
return 0;
}
在排序结构体类型之前我们要总结一下如何访问结构体成员
#include<stdio.h>
struct Stu
{
char name[20];//成员
int age;//成员
};
int main()
{
struct Stu s = {"zhangsan",20};
printf("%s %d",s.name,s.age);//结果为zhangsan 20
struct Stu* ps = &s;//ps是指向s结构体变量的结构体指针，类型为struct Stu*
printf("%s %d",(*ps).name,(*ps).age);//结果为zhangsan 20
printf("%s %d",ps->name,ps->age);//结果为zhangsan 20
return 0;
}
结构体成员访问操作符：
（1）. 结构体变量.成员名
（2）-> 结构体指针->成员名
在代码二中，我们排序结构体类型数据。
//代码二
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
//定义结构体
struct Stu
{
char name[20];
int age;
};
//按name排序
int cmp_stu_by_name(const void* p1, const void* p2)
{
//按名字比较二个结构体数据
//名字是字符串，字符串比较是使用strcmp()函数的
return strcmp( ((struct Stu*)p1)->name , ((struct Stu*)p2)->name );
}
//按age排序
int cmp_stu_by_age(const void* p1, const void* p2)
{
return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age ;
}
//打印排序后的数据
print(struct Stu* arr, size_t sz)
{
for (int i = 0; i < sz; i++)
{
printf("%s\n", (*(arr + i)).name);//结果为lisi wangwu zhangsan
}
}
//测试qsort，排序结构体数据，name
test2()
{
struct Stu arr[]={{"zhangsan",20},{"lisi",35},{"wangwu",18}};
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
print(arr, sz);
}
//测试qsort，排序结构体数据，age
test3()
{
struct Stu arr[]={{"zhangsan",20},{"lisi",35},{"wangwu",18}};
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
}
int main()
{
test2();//按name排序
test3();//按age排序
return 0;
}
strcmp()函数比较的是字符串对应字母的ascll码值的大小，不是比较字符串的长度。strcmp(p1,p2)中，如果p1大于p2，返回大于0的数；如果p1等于p2，返回等于0的数;如果p1大小于p2，返回小于0的数。
注意我们知道qsort函数默认排序为升序，那么我们怎么改变为排序为降序呢？由于qsort函数是库函数不能对里面的数据运算进行更改，那么我们就只能从qsort函数的形参部分入手。
return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age ;
//在代码二中，p1 - p2符合了升序条件
//那么我们将p1和p2的位置互换一下
return ((struct Stu*)p2)->age - ((struct Stu*)p1)->age ;
//这样就是将排序的逻辑反了过来，符合了降序
三、qsort函数的模拟实现
我们是否可以将bubble_sort函数改造成通用的算法，可以排序任意类型的数据？其实我们模仿qsort函数就可以了。
既然是模拟qsort函数，那么bubble_sort函数的形参类型和个数应该与qsort函数一样
void qsort(void * base, //base是指向待排序数组的第一个元素的指针
size_t num , //num是base指向的数组中的元素个数
size_t size , //size是base指向的数组中一个元素的大小，单位是字节
int(*cmp)(const void*, const void*) //函数指针 --- 传递函数的地址
//把你需要比较具体数据类型的函数提供给qsort就可以了
//qsort会根据你写的函数来排序大小
)
//想一想，为什么这些形参的类型要是这样？形参个数为什么就要着几个？
void bubble(void * base,
//base指针是指向待排序数组的第一个元素的地址，
//void* 代表着有人使用bublle时，实参可能是各种各样的数据类型地址，所以用void* 无具体类型指针接收
//那么有了数组的首地址，就可以排序了吗？并不可以，因为不知道元素的字节大小，找不到各个元素的位置，就比较不了二个数据
//想想排序需要哪些数据？1.二个数据的比较，就需要找到二个数据 2.要比较几次,就需要元素个数 3.两个数据是如何进行比较的，因为字符串、结构体、整型的比较方式不同
size_t num ,
//num 代表着数组元素的个数，这样就可以知道要进行几次数据的比较了
size_t size ,
//size 代表着一个元素的字节大小是多少，这样就可以知道大概的数据类型是什么，也可以通过指针+-整数去找到各个元素，即可以找到二个元素去比较
int(*cmp)(const void* p1, const void* p2)
//p1和p2代表着指向的二个元素，void* 代表着各种各样的数据类型
//cmp是函数指针，指向的函数是如何对两个数据进行比较的大小的,字符串、结构体、整型
//比较之后返回大小关系，就可以进行数据的排序了，靠返回值来确定两个数据是否符合交换条件
//cmp指向的函数需要自己根据自己所需要排序的数据类型来写出函数的比较大小
)
上面代码中，对函数的形参部分进行了具体讲解和作用，希望大家可以慢慢理解，比较知识不可能一蹴而就的。
此时有了上面的知识，我就先给出全部的模拟代码，后面在一点一点剖析原因。
#include <stdio.h>
int int_cmp(const void * p1, const void * p2)
{
return (*( int *)p1 - *(int *) p2);
}
void swap(void *p1, void * p2, int size)
{
int i = 0;
for (i = 0; i< size; i++)
{
char tmp = *((char *)p1 + i);
*(( char *)p1 + i) = *((char *) p2 + i);
*(( char *)p2 + i) = tmp;
}
}
void bubble(void *base, int count , int size, int(*cmp )(void* p1, void* p2))
{
int i = 0;
int j = 0;
for (i = 0; i< count - 1; i++)
{
for (j = 0; j<count-i-1; j++)
{
if (cmp ((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[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
int i = 0;
bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
{
printf( "%d ", arr[i]);
}
printf("\n");
return 0;
}
接下来，我们对其中各个关键部分都进行剖析
部分一:主函数main()中bubble()函数的传参，有着4个实参需要传递。（从左往右）
- 第一个实参：传递你需要排序的数据的数组的起始地址，或者是数组名
- 第二个实参：传递你数组名中需要排序的数据的个数
- 第三个实参：传递你需要排序的数组中每一个元素的大小（字节）
- 第四个实参：传递函数名，该函数中需要对待排序的数据（自己可以确定的知道要排序的数据类型）进行比较大小。那么数据是升序还是降序排序数据，是由该函数的返回值来确定的。注意:对不同的数据类型比较，该函数的实现是不一样的，比如字符串、结构体、整型等的比较大小是不同的。
此时bubble()函数的第四个实参是int_cmp函数的地址,显然我们要比较的是二个整型数据，那么函数int_cmp()里面要实现两个整型数据的比较。
bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
部分二:对于bubble()函数的定义和实现功能部分
void bubble(void *base, int count , int size, int(*cmp )(void* p1, void* p2))
{
int i = 0;
int j = 0;
for (i = 0; i< count - 1; i++)
{
for (j = 0; j<count-i-1; j++)
{
if (cmp ((char *) base + j*size , (char *)base + (j + 1)*size) > 0)
//比较相邻两个元素的大小
{
swap(( char *)base + j*size, (char *)base + (j + 1)*size, size);
//将符合条件的两个数据进行交换
}
}
}
}
对于bubble()函数定义的4个形参，这里就不多解释了，上面不久已经剖析了，忘了的朋友可以往上看看。
在剖析其他之前，同学们应该知道，我们这里是用冒泡排序算法来实现qsort()库函数的模拟实现。那么再想一想，既然是冒泡排序算法，那么循环的趟数的代码实现就和原本一样（冒泡排序），就不需要更改了。
我们再来剖析bubble()函数中的if条件语句的判断条件：
if (cmp ((char *) base + j*size , (char *)base + (j + 1)*size) > 0)
我们还知道if条件语句的判断部分是比较两个数据的大小，看看数据是否符合交换的条件，符合条件的话，就进行交换。
由于不知道传递进来的是什么类型的数据，所以cmp函数指针就指向了自己需要的类型数据的比较实现部分，该函数需要自己根据不同的数据类型去写。从主函数main()我们就知道要比较的是两个int型数据，那么cmp函数指针就指向了实现两个整型数据的比较实现部分,函数为int_cmp()函数。那么就需要向函数传递指向两个相邻数据的地址给p1和p2指针。看图片解释：
解释一下，为什么要将
(void *)base指针强制转换为(char *)base,想一想，如果使用(int *)base,对于当前代码是没有问题的，但是我们要实现的是qsort库函数的模拟，要实现任意数据类型的交换，所以使用(char *)base就可以满足要求，然后又知道一个元素的字节大小，那么我们就可以找到每一个元素的位置。
所以将(char *) base + j*size传给p1指针,(char *)base + (j + 1)*size传给p2指针。
看下面代码，由于p1和p2也是无类型指针(void *),所以再解引用操作访问数据之前，要将指针强制转化为类型符合的指针。比如我需要比较整型的数据，那么我们就要将指针转化为(int *)p1和(int *)p2。
int int_cmp(const void * p1, const void * p2)
{
return (*( int *)p1 - *(int *) p2);
}
部分三：对于交换函数swap()进行剖析。
在if条件语句判断符合后，程序进入到交换函数swap()
//伪代码，swap函数的实现
void swap(void *p1, void * p2, int size)
{
int i = 0;
for (i = 0; i< size; i++)
{
char tmp = *((char *)p1 + i);
*(( char *)p1 + i) = *((char *) p2 + i);
*(( char *)p2 + i) = tmp;
}
}
//伪代码,swap函数的调用
swap(( char *)base + j*size, (char *)base + (j + 1)*size, size);
由于需要对数据进行交换，那么我们就应该找到数据，这一部分和比较函数传递的参数一样，但是交换数据不仅仅需要访问两个元素，重要在于交换数据。
我们又可以将p1和p2无具体类型指针转化为(char*),交换数据时，我们一个字节一个字节的交换，等到两个元素的每一个字节都进行了交换，那么整个数据也就进行了交换。
那么交换函数swap()就还有比int_cmp()比较函数多一个参数，该参数为一个元素的字节大小。
下面给出对结构体数据的排序，看看与整型的不同，一个对age排序，另一个对name排序
//对age进行排序
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include <string.h>
struct Stu
{
char name[20];
int age;
};
int int_cmp_by_age(const void* p1, const void* p2)
{
return (*(struct Stu*)p1).age - (*(struct Stu*)p2).age ;
}
void swap(void* p1, void* p2, int size)
{
int i = 0;
for (i = 0; i < size; i++)
{
char tmp = *((char*)p1 + i);
*((char*)p1 + i) = *((char*)p2 + i);
*((char*)p2 + i) = tmp;
}
}
void bubble(void* base, int count, int size, int(*cmp)(void* p1, void* p2))
{
int i = 0;
int j = 0;
for (i = 0; i < count - 1; i++)
{
for (j = 0; j < count - i - 1; j++)
{
if (cmp((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 arr[] = { {"zhangsan",20},{"lisi",35},{"wangwu",18}};
bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(struct Stu), int_cmp_by_age);
printf("\n");
return 0;
}
//对name进行排序
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include <string.h>
struct Stu
{
char name[20];
int age;
};
int int_cmp_by_name(const void* p1, const void* p2)
{
return strcmp( ((struct Stu*)p1)->name, ((struct Stu*)p2)->name );
}
void swap(void* p1, void* p2, int size)
{
int i = 0;
for (i = 0; i < size; i++)
{
char tmp = *((char*)p1 + i);
*((char*)p1 + i) = *((char*)p2 + i);
*((char*)p2 + i) = tmp;
}
}
void bubble(void* base, int count, int size, int(*cmp)(void* p1, void* p2))
{
int i = 0;
int j = 0;
for (i = 0; i < count - 1; i++)
{
for (j = 0; j < count - i - 1; j++)
{
if (cmp((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 arr[] = { {"zhangsan",20},{"lisi",35},{"wangwu",18}};
bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(struct Stu), int_cmp_by_name);
printf("\n");
return 0;
}
谢谢观看！希望以上内容帮助到了你，对你起到作用的话，可以一键三连加关注！你们的支持是我更新地动力。
因作者水平有限，有错误还请指出，多多包涵，谢谢！
224
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
