深入明白指针与回调函数：从底子到实践

弁言

在C语言中，指针和回调函数是两个非常紧张的概念。指针为我们提供了直接操纵内存的本领，而回调函数则为我们提供了一种机动的编程方式，使得我们可以将函数作为参数通报给其他函数，从而实现更加模块化和可复用的代码。本文将深入探究指针和回调函数的概念，并通过现实的代码示例来展示它们的应用。
1. 回调函数是什么？


1.1 回调函数的界说

回调函数（Callback Function）是一种通过函数指针调用的函数。简单来说，回调函数是一个在特定变乱或条件发生时被调用的函数。回调函数不是由该函数的实现方直接调用，而是通过函数指针通报给另一个函数，由该函数在得当的机遇调用。

1.2 回调函数的作用

回调函数的紧张作用是解耦代码。通过将函数作为参数通报，我们可以将代码的逻辑分离，使得代码更加模块化和可复用。比方，在一个盘算器步调中，我们可以将加法、减法、乘法、除法等操纵封装成差别的函数，然后通过回调函数的方式将这些函数通报给一个同一的处置处罚函数，从而克制重复的代码。

1.3 回调函数的示例

让我们通过一个简单的例子来明白回调函数的使用。假设我们有一个盘算器步调，用户可以选择差别的操纵（加法、减法、乘法、除法），步调会根据用户的选择实验相应的操纵。

1.3.1 使用回调函数改造前

2. #include <stdio.h>
4. int add(int a, int b) {
5.     return a + b;
6. }
8. int sub(int a, int b) {
9.     return a - b;
10. }
12. int mul(int a, int b) {
13.     return a * b;
14. }
16. int div(int a, int b) {
17.     return a / b;
18. }
20. int main() {
21.     int x, y;
22.     int input = 1;
23.     int ret = 0;
25.     do {
26.         printf("**********\n");
27.         printf(" 1:add \n");
28.         printf(" 2:sub \n");
29.         printf(" 3:mul \n");
30.         printf(" 4:div \n");
31.         printf(" 0:exit \n");
32.         printf("**********\n");
33.         printf("请选择：");
34.         scanf("%d", &input);
36.         switch (input) {
37.             case 1:
38.                 printf("输入操作数：");
39.                 scanf("%d %d", &x, &y);
40.                 ret = add(x, y);
41.                 printf("ret = %d\n", ret);
42.                 break;
43.             case 2:
44.                 printf("输入操作数：");
45.                 scanf("%d %d", &x, &y);
46.                 ret = sub(x, y);
47.                 printf("ret = %d\n", ret);
48.                 break;
49.             case 3:
50.                 printf("输入操作数：");
51.                 scanf("%d %d", &x, &y);
52.                 ret = mul(x, y);
53.                 printf("ret = %d\n", ret);
54.                 break;
55.             case 4:
56.                 printf("输入操作数：");
57.                 scanf("%d %d", &x, &y);
58.                 ret = div(x, y);
59.                 printf("ret = %d\n", ret);
60.                 break;
61.             case 0:
62.                 printf("退出程序\n");
63.                 break;
64.             default:
65.                 printf("选择错误\n");
66.                 break;
67.         }
68.     } while (input);
70.     return 0;
71. }

复制代码

在这个代码中，我们使用了switch语句来根据用户的选择调用差别的函数。固然这个代码可以正常工作，但是它存在一个题目：每次添加一个新的操纵时，我们都须要修改switch语句，这会导致代码的冗余和不易维护。

1.3.2 使用回调函数改造后

为了简化代码，我们可以使用回调函数的方式将差别的操纵函数作为参数通报给一个同一的处置处罚函数。如许，当我们添加新的操纵时，只须要添加新的函数，而不须要修改switch语句。

2. #include <stdio.h>
4. int add(int a, int b) {
5.     return a + b;
6. }
8. int sub(int a, int b) {
9.     return a - b;
10. }
12. int mul(int a, int b) {
13.     return a * b;
14. }
16. int div(int a, int b) {
17.     return a / b;
18. }
20. void calculate(int (*func)(int, int)) {
21.     int x, y;
22.     printf("输入操作数：");
23.     scanf("%d %d", &x, &y);
24.     int ret = func(x, y);
25.     printf("ret = %d\n", ret);
26. }
28. int main() {
29.     int input = 1;
31.     do {
32.         printf("**********\n");
33.         printf(" 1:add \n");
34.         printf(" 2:sub \n");
35.         printf(" 3:mul \n");
36.         printf(" 4:div \n");
37.         printf(" 0:exit \n");
38.         printf("**********\n");
39.         printf("请选择：");
40.         scanf("%d", &input);
42.         switch (input) {
43.             case 1:
44.                 calculate(add);
45.                 break;
46.             case 2:
47.                 calculate(sub);
48.                 break;
49.             case 3:
50.                 calculate(mul);
51.                 break;
52.             case 4:
53.                 calculate(div);
54.                 break;
55.             case 0:
56.                 printf("退出程序\n");
57.                 break;
58.             default:
59.                 printf("选择错误\n");
60.                 break;
61.         }
62.     } while (input);
64.     return 0;
65. }

复制代码

在这个改造后的代码中，我们界说了一个calculate函数，它担当一个函数指针作为参数。这个函数指针指向一个担当两个int参数并返回int的函数。在main函数中，我们根据用户的选择将差别的操纵函数通报给calculate函数，从而实现了代码的简化和模块化。
2. qsort使用举例


2.1 qsort函数简介

qsort是C标准库中的一个函数，用于对数组举行排序。它的原型如下：

2. void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));

复制代码

base：指向要排序的数组的第一个元素的指针。
nmemb：数组中元素的个数。
size：数组中每个元素的巨细（以字节为单元）。
compar：指向比力函数的指针。这个函数用于比力两个元素的巨细。
2.2 使用qsort函数排序整型数据

让我们通过一个简单的例子来演示怎样使用qsort函数对整型数组举行排序。

2. #include <stdio.h>
3. #include <stdlib.h>
5. int int_cmp(const void *p1, const void *p2) {
6.     return (*(int *)p1 - *(int *)p2);
7. }
9. int main() {
10.     int arr[] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 0};
11.     int i = 0;
13.     qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
15.     for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
16.         printf("%d ", arr[i]);
17.     }
18.     printf("\n");
20.     return 0;
21. }

复制代码

在这个例子中，我们界说了一个int_cmp函数，用于比力两个整型数的巨细。然后我们使用qsort函数对数组arr举行排序。qsort函数会根据int_cmp函数的返回值来决定元素的次序。
2.3 使用qsort排序布局数据

qsort函数不光可以用于排序根本数据范例，还可以用于排序布局体数据。让我们通过一个例子来演示怎样使用qsort函数对布局体数组举行排序。

2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
6. struct Stu {
7.     char name[20];
8.     int age;
9. };
11. int cmp_stu_by_age(const void *e1, const void *e2) {
12.     return ((struct Stu *)e1)->age - ((struct Stu *)e2)->age;
13. }
15. int cmp_stu_by_name(const void *e1, const void *e2) {
16.     return strcmp(((struct Stu *)e1)->name, ((struct Stu *)e2)->name);
17. }
19. void test2() {
20.     struct Stu s[] = {{"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15}};
21.     int sz = sizeof(s) / sizeof(s[0]);
23.     qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
25.     for (int i = 0; i < sz; i++) {
26.         printf("%s %d\n", s[i].name, s[i].age);
27.     }
28. }
30. void test3() {
31.     struct Stu s[] = {{"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15}};
32.     int sz = sizeof(s) / sizeof(s[0]);
34.     qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
36.     for (int i = 0; i < sz; i++) {
37.         printf("%s %d\n", s[i].name, s[i].age);
38.     }
39. }
41. int main() {
42.     test2();
43.     test3();
44.     return 0;
45. }

复制代码

在这个例子中，我们界说了一个Stu布局体，包罗门生的姓名和年事。我们界说了两个比力函数cmp_stu_by_age和cmp_stu_by_name，分别用于按照年事和姓名对门生举行排序。然后我们使用qsort函数对布局体数组举行排序，并输出排序后的效果。
3. qsort函数的模仿实现

3.1 冒泡排序简介

冒泡排序是一种简单的排序算法。它重复地遍历要排序的数组，比力相邻的两个元素，假如它们的次序错误就互换它们。遍历数组的工作会重复举行，直到没有须要互换的元素为止。
3.2 使用回调函数模仿实现qsort

我们可以使用冒泡排序的头脑来模仿实现qsort函数。为了支持差别范例的数组，我们须要使用void *指针和回调函数。

2. #include <stdio.h>
4. int int_cmp(const void *p1, const void *p2) {
5.     return (*(int *)p1 - *(int *)p2);
6. }
8. void _swap(void *p1, void *p2, int size) {
9.     int i = 0;
10.     for (i = 0; i < size; i++) {
11.         char tmp = *((char *)p1 + i);
12.         *((char *)p1 + i) = *((char *)p2 + i);
13.         *((char *)p2 + i) = tmp;
14.     }
15. }
17. void bubble(void *base, int count, int size, int (*cmp)(void *, void *)) {
18.     int i = 0;
19.     int j = 0;
20.     for (i = 0; i < count - 1; i++) {
21.         for (j = 0; j < count - i - 1; j++) {
22.             if (cmp((char *)base + j * size, (char *)base + (j + 1) * size) > 0) {
23.                 _swap((char *)base + j * size, (char *)base + (j + 1) * size, size);
24.             }
25.         }
26.     }
27. }
29. int main() {
30.     int arr[] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 0};
31.     int i = 0;
33.     bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
35.     for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
36.         printf("%d ", arr[i]);
37.     }
38.     printf("\n");
40.     return 0;
41. }

复制代码

在这个代码中，我们界说了一个bubble函数，它担当一个void *指针作为数组的基地点，数组的元素个数，每个元素的巨细，以及一个比力函数。bubble函数使用冒泡排序算法对数组举行排序。为了支持差别范例的数组，我们使用void *指针和_swap函数来互换元素。
4. 总结

通过本文的学习，我们深入明白了指针和回调函数的概念，并通过现实的代码示例展示了它们的应用。回调函数为我们提供了一种机动的编程方式，使得我们可以将函数作为参数通报给其他函数，从而实现更加模块化和可复用的代码。qsort函数是C标准库中的一个强大的排序函数，它通过回调函数的方式支持对差别范例的数据举行排序。我们还通过模仿实现qsort函数，进一步加深了对指针和回调函数的明白。