Java/C++开发者：如何为多状态便携C API定义带回调的接口？

作为Java/C++程序员，你习惯用接口/纯虚类来抽象状态处理逻辑，换到C语言里，我们可以用函数指针结构体完美模拟这种模式，而且完全符合可移植C标准，适配所有平台。

1. 先定义通用状态数据结构 #

首先和C++里的StateData对应，先定义一个通用的状态数据结构体，用来传递状态相关的信息：

typedef struct {
    int state_code;       // 状态标识
    void* context;        // 自定义上下文数据，用户可以放任意内容
    // 其他你需要的业务字段...
} StateData;

2. 用函数指针结构体模拟"接口" #

这一步对应你C++里的StateHandler纯虚类，我们定义一个结构体，每个成员是对应状态的处理函数指针：

// 前置声明结构体，避免编译时循环引用
typedef struct StateHandler StateHandler;

struct StateHandler {
    // 对应handleState1，参数为状态数据指针
    void (*handleState1)(const StateData* data);
    // 对应handleState2
    void (*handleState2)(const StateData* data);
    // 继续添加其他状态的处理函数指针...
};

每个函数指针的签名要和业务需求匹配，确保用户能拿到足够的状态信息。

3. 实现状态机结构体 #

状态机需要持有这个"接口"的指针，就像C++里持有StateHandler的引用一样：

typedef struct {
    const StateHandler* handler;  // 用户提供的处理逻辑实现
    int current_state;             // 状态机当前状态
    // 状态机自身的内部状态数据...
} StateMachine;

4. 状态机的初始化与处理逻辑 #

提供初始化函数让用户传入自己实现的StateHandler，再实现状态处理的触发逻辑：

// 初始化状态机，绑定用户的处理逻辑
void state_machine_init(StateMachine* machine, const StateHandler* handler) {
    if (!machine || !handler) {
        // 可根据需求添加断言、错误码返回或日志
        return;
    }
    machine->handler = handler;
    machine->current_state = 0;  // 设置初始状态
}

// 状态机处理函数，根据当前状态调用对应的处理逻辑
void state_machine_process(StateMachine* machine, const StateData* data) {
    if (!machine || !machine->handler || !data) {
        return;
    }

    switch (machine->current_state) {
        case 1:
            machine->handler->handleState1(data);
            break;
        case 2:
            machine->handler->handleState2(data);
            break;
        // 其他状态分支...
        default:
            // 处理未知状态，比如打日志或触发默认行为
            break;
    }
}

5. 用户如何使用？ #

用户只需要实现自己的状态处理函数，然后组装成StateHandler实例传给状态机就行，完全和C++里实现接口类一样：

// 用户自定义的State1处理逻辑
void my_handle_state1(const StateData* data) {
    printf("处理State1，状态码：%d\n", data->state_code);
    // 这里写具体的业务逻辑
}

// 用户自定义的State2处理逻辑
void my_handle_state2(const StateData* data) {
    printf("处理State2，上下文地址：%p\n", data->context);
    // 这里写具体的业务逻辑
}

// 组装用户自己的StateHandler实例
const StateHandler my_custom_handler = {
    .handleState1 = my_handle_state1,
    .handleState2 = my_handle_state2,
    // 其他状态的处理函数按需赋值...
};

// 主函数示例
int main() {
    StateMachine my_machine;
    state_machine_init(&my_machine, &my_custom_handler);

    // 模拟状态1的触发
    StateData state1_data = {.state_code = 1, .context = NULL};
    my_machine.current_state = 1;
    state_machine_process(&my_machine, &state1_data);

    // 模拟状态2的触发
    StateData state2_data = {.state_code = 2, .context = (void*)0x1234};
    my_machine.current_state = 2;
    state_machine_process(&my_machine, &state2_data);

    return 0;
}

进阶：给处理函数加实例上下文 #

如果用户需要像C++类那样携带实例数据（比如类的成员变量），可以给StateHandler加一个user_data字段，同时修改函数指针签名：

struct StateHandler {
    void (*handleState1)(const StateData* data, void* user_data);
    void (*handleState2)(const StateData* data, void* user_data);
    void* user_data;  // 用户自定义的实例上下文
};

调用的时候把这个user_data传进去：

// 修改state_machine_process里的调用逻辑
machine->handler->handleState1(data, machine->handler->user_data);

用户就可以把自己的结构体指针存在user_data里，模拟类的实例状态了。

注意事项 #

• 空指针检查：一定要在初始化和调用时检查指针是否为NULL，避免程序崩溃。
• 可移植性：这个方案完全基于标准C，没有依赖任何平台扩展，能在所有支持C的环境运行。
• 函数签名一致性：用户实现的处理函数必须严格匹配你定义的函数指针签名，否则会有未定义行为。

内容的提问来源于stack exchange，提问作者Larry