C语言：深入了解指针3

南玖yy2025-02-06 10:37

1.回调函数是什么？

基本概念

回调函数就是⼀个通过函数指针调⽤的函数。

如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数

时，被调⽤的函数就是回调函数。回调函数不是由该函数的实现⽅直接调⽤，⽽是在特定的事件或条件发⽣时由另外的⼀⽅调⽤的，⽤于对该事件或条件进⾏响应。

使用场景

  • 事件驱动编程：在图形用户界面（GUI）编程中，当用户点击按钮、输入文本等操作发生时，系统会调用预先注册的回调函数来处理这些事件。
  • 排序算法 ：标准库中的qsort函数允许用户传入一个比较函数作为回调函数，以实现自定义的排序规则。
  • 异步操作：在多线程或异步编程中，当一个异步任务完成时，可以通过回调函数通知主线程进行后续处理。

实现方式

在 C 语言中，实现回调函数主要涉及函数指针 的使用。函数指针是指向函数的指针变量，它可以存储函数的地址，并且可以通过该指针调用相应的函数。

示例代码

示例 1：简单的回调函数示例
复制代码 
#include <stdio.h>

// 定义回调函数类型
typedef int (*Callback)(int, int);//typedef是自定义类型名字

// 回调函数1：加法
int add(int a, int b) 
{
    return a + b;
}

// 回调函数2：减法
int subtract(int a, int b) 
{
    return a - b;
}

// 主调函数，接受一个回调函数作为参数
int operate(int a, int b, Callback func) //Callback func ==int(*func)(int,int)
{
    return func(a, b);
}

int main() 
{
    int x = 10, y = 5;

    // 使用加法回调函数
    int result1 = operate(x, y, add);//函数k名就是地址
    printf("加法结果: %d\n", result1);

    // 使用减法回调函数
    int result2 = operate(x, y, subtract);
    printf("减法结果: %d\n", result2);

    return 0;
}

代码解释：

1. 定义回调函数类型

typedef int (*Callback)(int, int);

  • typedef 是 C 语言中的一个关键字，用于为已有的数据类型定义一个新的类型名，目的是让代码更具可读性和可维护性。
  • int (*Callback)(int, int) 定义了一个函数指针类型。具体来说，Callback 是一个新的类型名，它代表的是一个指向函数的指针，这个函数接收两个 int 类型的参数，并且返回一个 int 类型的值。

2. 定义回调函数

加法函数 add

int add(int a, int b)

{

return a + b;

}

  • 这是一个普通的函数，它接受两个 int 类型的参数 a 和 b，并返回它们的和。
  • 该函数的参数和返回值类型与前面定义的 Callback 类型相匹配，所以它可以作为 Callback 类型的回调函数使用。
减法函数 subtract

int subtract(int a, int b)

{

return a - b;

}

  • 同样是一个普通函数，接受两个 int 类型的参数 a 和 b，返回它们的差。
  • 它的参数和返回值类型也与 Callback 类型匹配，也能作为回调函数使用。

3. 定义主调函数

int operate(int a, int b, Callback func)

{

return func(a, b);

}

  • operate 是主调函数，它接受三个参数：两个 int 类型的参数 a 和 b，以及一个 Callback 类型的参数 func。
  • Callback func 等价于 int(*func)(int, int)，即 func 是一个函数指针，它指向一个符合 Callback 类型定义的函数。
  • 在函数体中，通过 func(a, b) 调用 func 所指向的函数，并将 a 和 b 作为参数传递给该函数，最后返回该函数的返回值。
4. main 函数

int main()

{

int x = 10, y = 5;

// 使用加法回调函数

int result1 = operate(x, y, add );

printf("加法结果: %d\n", result1 );

// 使用减法回调函数

int result2 = operate(x, y, subtract );

printf("减法结果: %d\n", result2 );

return 0;

}

  • 首先，定义并初始化两个 int 类型的变量 x 和 y，分别赋值为 10 和 5。
  • 调用 operate 函数进行加法运算：
    • operate(x, y, add) 中，将 x 和 y 作为前两个参数传递给 operate 函数，将 add 函数名作为回调函数传递给 operate 函数。在 C 语言中，函数名可以隐式转换为函数的地址，所以 add 实际上传递的是 add 函数的地址。
    • operate 函数内部会通过函数指针 func 调用 add 函数，计算 x 和 y 的和，并将结果返回给 result1。
    • 使用 printf 函数输出加法结果。
  • 调用 operate 函数进行减法运算：
    • 类似地，operate(x, y, subtract) 将 subtract 函数的地址作为回调函数传递给 operate 函数。
    • operate 函数内部通过函数指针 func 调用 subtract 函数，计算 x 和 y 的差，并将结果返回给 result2。
    • 使用 printf 函数输出减法结果。

2. qsort 使⽤举例

函数原型

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

参数解释

  • base：指向要排序的数组的第一个元素的指针。由于使用 void * 类型，所以可以处理任意类型的数组。
  • nmemb：数组中元素的个数。
  • size：数组中每个元素的大小（以字节为单位）。
  • compar：一个指向比较函数的指针。该比较函数用于确定元素之间的顺序关系，它接受两个 const void * 类型的参数，并返回一个整数值，表示两个元素的相对顺序。

比较函数规则

比较函数 int_comp 的返回值规则如下：

  • 如果返回值小于 0，表示第一个参数小于第二个参数。

  • 如果返回值等于 0，表示两个参数相等。

  • 如果返回值大于 0，表示第一个参数大于第二个参数。

    #include <stdio.h>
    #include <stdlib.h>
    //qosrt函数的使⽤者得实现⼀个⽐较函数

    int int_cmp(const void * p1, const void * p2)
    {
    return (*( int *)p1 - *(int *) p2);//小于返回一个负数，大于返回一个正数，等于返回0.
    }

    int main()
    {

    int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    int i = 0;

    qsort(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;
    }

代码解释：

1. 比较函数 int_cmp

  • 参数 ：qsort 函数要求使用者提供一个比较函数，这个比较函数必须接受两个 const void * 类型的参数。const void * 是一种通用的指针类型，可以指向任意类型的数据，使用它是为了让 qsort 函数能够处理不同类型的数组。这里的 p1 和 p2 就是指向要比较的两个元素的指针。
  • 类型转换 ：在比较函数内部，由于 p1 和 p2 是 const void * 类型，不能直接进行解引用操作，所以需要将它们转换为 int * 类型（因为这里要比较的是整数数组），然后再进行解引用，得到具体的整数值。
  • 返回值 ：比较函数的返回值决定了两个元素的相对顺序。如果 *(int *)p1 - *(int *) p2 的结果小于 0，说明 p1 指向的元素小于 p2 指向的元素；如果结果等于 0，说明两个元素相等；如果结果大于 0，说明 p1 指向的元素大于 p2 指向的元素。

2. main 函数

2.1 数组定义与变量声明
  • 定义了一个包含 10 个整数的数组 arr，初始化为 { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 }。
  • 声明一个整型变量 i 用于后续的循环操作。
2.2 调用 qsort 函数进行排序
  • qsort 函数的原型为 void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));。
    • base：指向要排序的数组的第一个元素的指针，这里传入 arr，即数组的首地址。
    • nmemb：数组中元素的个数，通过 sizeof(arr) / sizeof(arr[0]) 计算得到，即数组的总字节数除以单个元素的字节数。
    • size：数组中每个元素的大小（以字节为单位），这里是 sizeof(int)，表示每个整数元素占用的字节数。
    • compar：指向比较函数的指针，这里传入 int_cmp，即前面定义的比较函数。
2.3 输出排序后的数组

  • 使用 for 循环遍历排序后的数组 arr，并使用 printf 函数将每个元素输出，元素之间用空格分隔。

  • 最后使用 printf("\n"); 输出一个换行符，使输出结果更美观。

  • main 函数返回 0 表示程序正常结束。

    综上所述，这段代码的主要功能是使用 qsort 函数对一个整数数组进行排序，并将排序后的数组元素输出。通过自定义比较函数 int_cmp，可以灵活地控制排序的顺序。

3. qsort函数的模拟实现

下面就是模拟qsort函数的模拟实现的

复制代码 
#include<stdio.h>

int cmp_int(const void* p1, const void* p2)//整型排序
{
    return (*(int*)p1 - *(int*)p2);//可以做差返回

}
void print_arr(int arr[], int sz)//打印排序过的数组
{
    int  i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
}

void Swap(char* buf1, char* buf2, size_t width)//比较之后交换的函数
{
    int i = 0;
    char tmp = 0;
    for (i = 0; i < width; i++)
    {
        tmp = *buf1;
        *buf1 = *buf2;
        *buf2 = tmp;

        buf1++;
        buf2++;
    }
}
void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void* p1, const void* p2))//总函数
{   // 趟数
    int i = 0;
    for (i = 0; i < sz - 1; i++)
    {   //一趟内部的两两比较
        int j = 0;
        for (j = 0; j < sz - 1 - i; j++)
        {  //比较两个元素
            if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
            { //  交换两个元素
                Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
            }
        }
    }
}

void test1()//需要比较的
{
    int arr[] = { 9,8,7,4,6,2,10,1,3,5 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);//cmp_int == &cmp_int 地址需要指针接收。
    print_arr(arr, sz);
}
int main()
{
     test1();
    
    return 0;
}

1. 比较函数

1.1 cmp_int 函数

int cmp_int(const void* p1, const void* p2)

{

return (*(int*)p1 - *(int*)p2);

}

  • 功能：用于比较两个整型数据的大小。
  • 参数 ：
    • p1 和 p2：const void* 类型的指针，这是为了使函数具有通用性，可以接收任意类型的指针。
  • 实现细节 ：
    • (int*)p1 和 (int*)p2：将 void* 类型的指针强制转换为 int* 类型，以便可以解引用获取整型值。
    • *(int*)p1 和 *(int*)p2：解引用指针，得到对应的整型值。
    • *(int*)p1 - *(int*)p2：计算两个整型值的差。如果结果大于 0，表示 p1 指向的值大于 p2 指向的值；如果结果小于 0，表示 p1 指向的值小于 p2 指向的值；如果结果等于 0，表示两个值相等。

2. 打印函数

void print_arr(int arr[], int sz)

{

int i = 0;

for (i = 0; i < sz; i++)

{

printf("%d ", arr[i]);

}

}

  • 功能：用于打印整型数组的元素。
  • 参数 ：
    • arr：整型数组。
    • sz：数组的元素个数。
  • 实现细节 ：
    • 使用 for 循环遍历数组的每个元素。
    • 使用 printf 函数以整数格式打印每个元素，并在元素之间添加一个空格。

3. 交换函数 Swap

void Swap(char* buf1, char* buf2, size_t width)

{

int i = 0;

char tmp = 0;

for (i = 0; i < width; i++)

{

tmp = *buf1;

*buf1 = *buf2;

*buf2 = tmp;

buf1++;

buf2++;

}

}

  • 功能：用于交换两个内存块的内容。
  • 参数 ：
    • buf1 和 buf2：char* 类型的指针，指向要交换的两个内存块。
    • width：每个内存块的字节数。
  • 实现细节 ：
    • 使用 for 循环逐字节交换两个内存块的内容。
    • 通过 char 类型的临时变量 tmp 来存储中间值，实现交换。
    • 每次交换一个字节后，将指针 buf1 和 buf2 向后移动一个字节，直到交换完整个内存块。

4. 冒泡排序函数 bubble_sort

复制代码 
void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void* p1, const void* p2)) 
{
    int i = 0;
    for (i = 0; i < sz - 1; i++) 
       {
        int j = 0;
        for (j = 0; j < sz - 1 - i; j++) {
            if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0) {
                Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
            }
        }
    }
}
  • 功能：实现通用的冒泡排序算法。
  • 参数 ：
    • base：void* 类型的指针，指向待排序数组的起始地址，使用 void* 类型可以接收任意类型的数组。
    • sz：数组的元素个数。
    • width：每个元素的字节数。
    • cmp：函数指针，指向一个比较函数，用于确定元素的顺序。
  • 实现细节 ：
    • 外层 for 循环控制排序的趟数，共进行 sz - 1 趟。
    • 内层 for 循环进行每一趟的两两比较，比较相邻的两个元素。
    • cmp((char*)base + j * width, (char*)base + (j + 1) * width)：调用比较函数 cmp 比较相邻两个元素的大小。(char*)base + j * width 和 (char*)base + (j + 1) * width 分别计算相邻两个元素的地址。
    • 如果比较结果大于 0，表示顺序不正确，调用 Swap 函数交换这两个元素的位置。

5. 测试函数

5.1 test1 函数

void test1()

{

int arr[] = { 9,8,7,4,6,2,10,1,3,5 };

int sz = sizeof(arr) / sizeof(arr[0]);

bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);

print_arr(arr, sz);

}

  • 功能 ：创建一个整型数组，调用 bubble_sort 函数对数组进行排序，然后调用 print_arr 函数打印排序后的数组。
  • 实现细节 ：
    • int arr[] = { 9,8,7,4,6,2,10,1,3,5 };：定义一个包含 10 个整数的数组。
    • int sz = sizeof(arr) / sizeof(arr[0]);：计算数组的元素个数。
    • bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);：调用 bubble_sort 函数对数组进行排序，使用 cmp_int 函数作为比较规则。
    • print_arr(arr, sz);：调用 print_arr 函数打印排序后的数组。

6. 主函数

int main()

{

test1();

return 0;

}

  • 功能 ：程序的入口点，调用 test1 函数进行测试。
  • 返回值：返回 0 表示程序正常结束。

下面是我自己画的图（画的不是特别好）方便大家理解理解：

相关推荐
吃饺子不吃馅2 分钟前
如何设计一个 Canvas 事件系统？
前端·canvas·图形学
Baklib梅梅17 分钟前
无头内容管理系统：打造灵活高效的多渠道内容架构
前端·ruby on rails·前端框架·ruby
over69737 分钟前
浏览器里的AI魔法：用JavaScript玩转自然语言处理
前端·javascript
「QT(C++)开发工程师」39 分钟前
【LUA教程】LUA脚本语言中文教程.PDF
开发语言·pdf·lua
小莞尔1 小时前
【51单片机】【protues仿真】基于51单片机热敏电阻数字温度计数码管系统
c语言·stm32·单片机·嵌入式硬件·物联网·51单片机
我不会插花弄玉1 小时前
c语言实现队列【由浅入深-数据结构】
c语言·数据结构
程序定小飞1 小时前
基于springboot的民宿在线预定平台开发与设计
java·开发语言·spring boot·后端·spring
渣渣盟1 小时前
探索Word2Vec：从文本向量化到中文语料处理
前端·javascript·python·文本向量化
Pu_Nine_91 小时前
Vue 3 + TypeScript 项目性能优化全链路实战：从 2.1MB 到 130KB 的蜕变
前端·vue.js·性能优化·typescript·1024程序员节
天天进步20152 小时前
Python全栈项目--基于计算机视觉的车牌识别系统
开发语言·python·计算机视觉
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03BongoCat - 跨平台键盘猫动画工具04GitLab 零基础入门指南：从安装到项目管理全流程05Linux下V2Ray安装配置指南06Labelme从安装到标注：零基础完整指南07NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南08jdk21下载、安装（Windows、Linux、macOS）09在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）102025软件测试面试八股文（含答案+文档）