C语言|回调函数的不同用法

回调函数是个高级操作技巧，也是日常项目中常常使用到的技能。之所以说回调函数是个高级操作技巧，是因为它让异步操作更加方便，众所周知程序执行分为同步操作和异步操作，同步操作故名思意就是按代码顺序执行，而异步则是按需求进行回调执行，为了实时性一般回调要尽可能的快进快出，避免影响同步操作。下面简单学习一下回调函数的不同用法：

| 用法一

相信很多读者都听过注册回调，其实这是两个步骤的统称，先是对回调进行注册，再在特定的场景进行回调，一般会用在事件触发回调：

#include "stdio.h"

// 注册事件
void login_event(int event_type, void (*callback)(void))
{
    printf("event %d login
", event_type);
    if (callback != NULL)
    {
        callback();
    }
}

// 回调处理
void callback_function()
{
    printf("callback function handle
");
}

int main()
{
    login_event(1, callback_function);
    login_event(2, NULL);
    return 0;
}

| 用法二

通过参数对事件参数化，简单理解就是通过输入参数，判断回调函数触发的事件：

#include "stdio.h"

void callback_handle(int state, int (*handle)(int))
{
    handle(state);
}

int handle(int state)
{
    switch (state)
    {
    case 0x00:
        printf("state %d handle
", state);
        break;
    case 0x01:
        printf("state %d handle
", state);
        break;
    case 0x02:
        printf("state %d handle
", state);
        break;
    case 0x03:
        printf("state %d handle
", state);
        break;
    default:
        break;
    }
}

int main()
{
    callback_handle(0, handle);
    callback_handle(1, handle);
    return 0;
}
| 用法三

回调函数除了常规用法，还可以通过typedef关键字，把回调函数变成一种自定义类型的函数，这样就更方便使用：

#include "stdio.h"

typedef int (*callback_t)(int, int);

int callback_handle(int data1, int data2, callback_t callback)
{
    int data = callback(data1, data2);
    return data;
}

int sum_handle(int data1, int data2)
{
    return (data1 + data2);
}

int minus_handle(int data1, int data2)
{
    return (data1 - data2);
}

int main()
{
    int user_data = 0;
    user_data = callback_handle(1, 2, sum_handle);
    printf("user_data:%d
", user_data);
    user_data = callback_handle(2, 1, minus_handle);
    printf("user_data:%d
", user_data);
    return 0;
}

| 用法四

回调函数除了单个单独使用，还可以同类整合使用，这个同类是作者本人自认为的，通过把一些类似的函数整合在回调函数数组里：

#include "stdio.h"

typedef void (*callback_t)(int, int);

void add_handle(int a, int b)
{
    printf("%d + %d = %d
", a, b, a + b);
}

void sub_handle(int a, int b)
{
    printf("%d - %d = %d
", a, b, a - b);
}

int main()
{
    callback_t callback[2] = {add_handle, sub_handle};
    int size = sizeof(callback) / sizeof(callback_t);
    for (int i = 0; i < size; i++)
    {
        callback[i](i, i + 1);
    }
    return 0;
}

| 高级技巧

众所周知C语言是面向过程的，但是也可以通过技巧来实现，这次通过回调函数来实现面向对象的多态，多态按字面的意思就是多种形态。多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数，下边的写法存在一定的不合理，只是为了展示实现方式：

#include "stdio.h"

typedef struct overall
{
    void (*handle)(struct overall *);
} overall_t;

typedef struct
{
    overall_t shape;
} section_1_t;

typedef struct
{
    overall_t shape;
} section_2_t;

void section_1_handle(overall_t *shape)
{
    printf("section_1_t handle
");
}

void section_2_handle(overall_t *shape)
{
    printf("section_2_t handle
");
}

int main()
{
    overall_t *overall = NULL;
    section_1_t section_1 =
        {
            .shape = {section_1_handle},
        };
    section_2_t section_2 =
        {
            .shape = {section_2_handle},
        };
    overall = (overall_t *)§ion_1;
    overall->handle(overall);
    overall = (overall_t *)§ion_2;
    overall->handle(overall);
    return 0;
}
编辑：黄飞