自学内容网 自学内容网

指针的奥秘(四):回调函数+qsort使用+qsort模拟实现冒泡排序

一.回调函数是什么?

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

上一篇我们写了一个简单的计算器,如下:

#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;
}
void menu()
{
printf("*************************\n");
printf("**1:add***********2:sub**\n");
printf("**3:mul***********4:div**\n");
printf("*********0:exit**********\n");
printf("*************************\n");

}
int main()
{
int x = 0;
int y = 0;
int input = 0;
int ret = 0;
do
{
menu();
printf("请输入:");
scanf("%d", &input);
switch (input)
{
case 0:
break;
case 1:
printf("请输入两个数:");
scanf("%d %d", &x, &y);
ret = Add(x, y);
printf("%d+%d=%d\n", x, y, ret);
break;
case 2:
printf("请输入两个数:");
scanf("%d %d", &x, &y);
ret = Sub(x, y);
printf("%d-%d=%d\n", x, y, ret);
break;
case 3:
printf("请输入两个数:");
scanf("%d %d", &x, &y);
ret = Mul(x, y);
printf("%d*%d=%d\n", x, y, ret);
break;
case 4:
printf("请输入两个数:");
scanf("%d %d", &x, &y);
ret = Div(x, y);
printf("%d/%d=%d\n", x, y, ret);
break;
default:
printf("输入错误,请重新输入\n");
break;
}
} while (input);
return 0;
}

可以看到输入输出操作是冗余的,有没有办法,简化⼀些呢?只有调用函数的逻辑是有差异的,我们可以把调用的函数的地址以参数的形式传递过去,使用函数指针接收,函数指针指向什么函数就调用什么函数,这里其实使用的就是回调函数的功能。如下:

#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;
}
void Calc(int(*pf)(int, int))
{
int ret = 0;
int x = 0;
int y = 0;
printf("请输入两个数:");
scanf("%d %d", &x, &y);
ret = pf(x, y);
printf("%d\n", ret);
}
void menu()
{
printf("*************************\n");
printf("**1:add***********2:sub**\n");
printf("**3:mul***********4:div**\n");
printf("*********0:exit**********\n");
printf("*************************\n");

}
int main()
{
int x = 0;
int y = 0;
int input = 0; 
do
{
menu();
printf("请输入:");
scanf("%d", &input);
switch (input)
{
case 0:
break;
case 1:
Calc(Add);
break;
case 2:
Calc(Sub);
break;
case 3:
Calc(Mul);
break;
case 4:
Calc(Div);
break;
default:
printf("输入错误,请重新输入\n");
break;
}
} while (input);
return 0;
}

二.qsort函数使用

1.qsort介绍

  qsort函数是C语言中的一个库函数,头文件——stdlib.h,这个函数对任意类型的数据都能排序

void qsort(void* base, size_t num, size_t size, int( *compare)(const void *elem1, const void *elem2);

  1. void* base:指向待排序数组的第一个元素的指针。
  2. size_t num:待排序数组中的元素个数。
  3. size_t size:待排序数组中的每个元素的大小,单位是字节。
  4. int( *compare)(const void *elem1, const void *elem2):函数指针——传递函数的地址。

注意:int compare(const void *elem1, const void *elem2)——比较函数,需要使用qsort函数的程序员自己提供,并且有下面这些要求:
在这里插入图片描述

2.qsort排序整型数据

#include<stdio.h>
#include<stdlib.h>
//1.0测试qsort排序整形数据
void Print(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
int cmp_int(const void* e1, const void* e2)
{
    //e1指向的一个数组元素,e2指向的是下一个数组元素
/*if (*(int*)e1 > *(int*)e2)
return 1;
else if (*(int*)e1 < *(int*)e2)
return -1;
else
return 0;*/
return (*(int*)e1 - *(int*)e2);//想逆序改变e1与e2即可
}
void 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);
Print(arr, sz);
}
int main()
{
test1();
return 0;
}

在这里插入图片描述

3.qsort排序结构体数据

  结构体成员访问操作符有两种

操作符 . 结构体变量.成员名
操作符 -> 结构体指针->成员名

int main()
{
struct stu s = { "zhangsan",66 };
printf("%s %d\n", s.name, s.age);

struct stu* ps = &s;
printf("%s %d\n", (*ps).name, (*ps).age);
printf("%s %d\n", ps->name, ps->age);
return 0;
}

在这里插入图片描述

1.通过结构体中的整形成员排序

#include<stdio.h>
#include<stdlib.h>
void Print(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
struct stu
{
char name[20];
int age;
};
//按照年龄比较,排序结构体数组
int cmp_stu_by_age(const void* e1, const void* e2)
{
//return (*((struct stu*)e1)).age > (*((struct stu*)e2)).age;
return ((struct stu*)e1)->age - ((struct stu*)e2)->age;
}
void 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_age);//通过age排序
}
int main()
{
test2();
return 0;
}

在这里插入图片描述

2.通过结构体中的字符串成员排序

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void Print(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
struct stu
{
char name[20];
int age;
};
//按照名字比较,排序结构体数组
int cmp_stu_by_name(const void* e1, const void* e2)
{
//注意:强转是暂时的需要带上()
return strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
//这里借助strcmp函数比较字符串,返回值恰好与函数的返回值要求相同
}
void 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);
}
int main()
{
test2();
return 0;
}

在这里插入图片描述

三.qsort模拟实现冒泡排序

给出简单的冒泡排序,代码如下:

void Print(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
void BubbleSort(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz - 1; i++)
{
int j = 0;
for (j = 0; j < sz - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main()
{
int arr[] = { 3,1,7,9,4,2,6,5,8,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
BubbleSort(arr, sz);
Print(arr, sz);
}

该函数只能排序整形元素,我们可以借助qsort函数来模拟实现冒泡排序用于排序各种类型数据。如下代码:

void Print(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
struct stu
{
char name[20];
int age;
};
void Swap(char* buf1, char* buf2, int width)
{
int i = 0;
char temp;
for (i = 0; i < width; i++)
{
temp = *buf1;
*buf1 = *buf2;
*buf2 = temp;
buf1++;
buf2++;
}
}
void BubbleSort(void* base,size_t sz,size_t width,int(*cmp)(const void* e1,const void* e2))
{
int i = 0;
for (i = 0; i < sz - 1; i++)
{
int j = 0;
for (j = 0; j < sz - i - 1; j++)
{
//比较两个元素
if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
{
//交换两个元素
Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
}

}
}
}
int cmp_int(const void* e1, const void* e2)
{
return (*(int*)e1 - *(int*)e2);
}
void test4()
{
int arr[] = { 3,1,7,9,4,2,6,5,8,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
BubbleSort(arr, sz, sizeof(arr[0]), cmp_int);
Print(arr, sz);
}
int cmp_stu_by_int(const void* e1, const void* e2)
{
return ((struct stu*)e1)->age - ((struct stu*)e2)->age;
}
void test5()
{
struct stu arr[] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
int sz = sizeof(arr) / sizeof(arr[0]);
BubbleSort(arr, sz, sizeof(arr[0]), cmp_stu_by_int);
}
int cmp_stu_by_name(const void* e1, const void* e2)
{
return strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
}
void test6()
{
struct stu arr[] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
int sz = sizeof(arr) / sizeof(arr[0]);
BubbleSort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}
int main()
{
//test4();
//test5();
test6();
return 0;
}

在这里插入图片描述
这里的cmp_int,cmp_struct_by_age,cmp_struct_by_name就是典型的回调函数,在冒泡排序中传入函数指针,通过函数指针调用的函数就是回调函数,可以传入不同的函数指针,实现排序不同的数据。

思考:为什么使用的都是泛型指针void*呢?

  1. 由于不知道排序什么数据类型。若排序整形,用int*,那排序短整型,字符串呢?就不方便了。
  2. 泛型指针void*可以配合数组元素的个数每个元素字节的大小,精准定位每个元素的地址,就很方便交换元素了。
  3. 交换元素由于不知道元素的类型,可以考虑交换每一个字节的内容,配合每个元素字节的大小,可以达到整体交换的效果,可谓是精彩绝伦!

指针部分到这就结束了,但是学习仍未止步!!!
创作不易,如果能帮到你的话能赏个三连吗?感谢啦!!!
在这里插入图片描述


原文地址:https://blog.csdn.net/2203_76003626/article/details/138706698

免责声明:本站文章内容转载自网络资源,如本站内容侵犯了原著者的合法权益,可联系本站删除。更多内容请关注自学内容网(zxcms.com)!