在C/C++中构建大型int到结构体/类的映射方案

现有一个C应用，配置数据与行为逻辑高度碎片化：

// 在一个文件中
#define VAR_1 1
#define VAR_2 2
#define VAR_3 3

// 在另一个文件中
const gNames[] = {
[VAR_1] = (const u8[]) "1",
[VAR_2] = (const u8[]) "2",
[VAR_3] = (const u8[]) "3",
};

// 在第三个文件中
switch (var) {
case VAR_1:
// 一些行为逻辑
break;

case VAR_3:
// 另一些行为逻辑
break;

// 诸如此类

希望将分散的数据与逻辑整合为类似以下的结构：

const Behavior gBehaviors[] = {
  [VAR_1] = {
    .name = (const u8[]) "1",
    .handleFooEvent = Var1FooHandler,
    // ...
  },
  // ...
};

但C不支持匿名函数，C++虽能声明行为类，但对指定初始化器的支持有限，且需保留现有#define枚举的索引，让C代码能通过枚举找到对应行为映射。以下是几种可行的实现方案：

纯C语言方案 #

C完全可以通过结构体+函数指针实现数据与行为的绑定，无需匿名函数：

1. 定义Behavior结构体 #

先统一声明处理函数的类型，再定义包含数据和函数指针的结构体：

// 声明处理函数原型
typedef void (*FooHandler)(void);
typedef void (*BarHandler)(int);

typedef struct {
    const u8* name;
    FooHandler handleFooEvent;
    BarHandler handleBarEvent;
    // 按需添加其他配置字段
} Behavior;

2. 实现独立的处理函数 #

为每个变量对应的逻辑单独实现函数，不用匿名：

void Var1FooHandler(void) {
    // VAR_1对应的Foo事件逻辑
}

void Var1BarHandler(int param) {
    // VAR_1对应的Bar事件逻辑
}

void Var3FooHandler(void) {
    // VAR_3对应的Foo事件逻辑
}
// ... 其他变量的处理函数

3. 用指定初始化器构建行为数组 #

C99及以后支持指定初始化器，直接将数据与函数指针绑定到对应索引：

const Behavior gBehaviors[] = {
    [VAR_1] = {
        .name = (const u8[]) "1",
        .handleFooEvent = Var1FooHandler,
        .handleBarEvent = Var1BarHandler,
    },
    [VAR_2] = {
        .name = (const u8[]) "2",
        // 无对应逻辑时可设为NULL或默认函数
        .handleFooEvent = NULL,
        .handleBarEvent = NULL,
    },
    [VAR_3] = {
        .name = (const u8[]) "3",
        .handleFooEvent = Var3FooHandler,
        .handleBarEvent = NULL,
    },
    // ... 其他变量的配置
};

4. 替代switch的调用逻辑 #

原来的switch分支可以改成直接通过索引访问结构体，调用对应函数：

void processEvent(int var, int eventType, int param) {
    // 先检查索引合法性
    if (var < sizeof(gBehaviors)/sizeof(gBehaviors[0]) && gBehaviors[var].name != NULL) {
        switch(eventType) {
            case EVENT_FOO:
                if (gBehaviors[var].handleFooEvent != NULL) {
                    gBehaviors[var].handleFooEvent();
                }
                break;
            case EVENT_BAR:
                if (gBehaviors[var].handleBarEvent != NULL) {
                    gBehaviors[var].handleBarEvent(param);
                }
                break;
            // ... 其他事件类型
        }
    }
}

C++语言方案 #

C++11及以后支持指定初始化器（针对聚合类），同时可以兼容原有#define常量，且能实现C代码的兼容访问：

1. 定义Behavior聚合类 #

如果是无用户自定义构造函数、无私有/保护成员的聚合类，可直接使用指定初始化器：

#include <cstdint>
using u8 = uint8_t;

// 处理函数类型定义
using FooHandler = void(*)();
using BarHandler = void(*)(int);

struct Behavior {
    const u8* name;
    FooHandler handleFooEvent;
    BarHandler handleBarEvent;
    // 其他配置字段
};

2. 构建行为数组 #

直接沿用C风格的指定初始化器语法，C++11及以上支持：

// 导入原有#define常量
const Behavior gBehaviors[] = {
    [VAR_1] = { (const u8*)"1", Var1FooHandler, nullptr },
    [VAR_2] = { (const u8*)"2", nullptr, nullptr },
    [VAR_3] = { (const u8*)"3", nullptr, Var3BarHandler },
};

若担心指定初始化器的兼容性，也可以先初始化数组再逐个赋值：

constexpr int MAX_VAR = 4; // 设为比最大#define值大1的数
const Behavior gBehaviors[MAX_VAR] = {}; // 先默认初始化所有元素

// 逐个赋值对应变量的配置
gBehaviors[VAR_1] = { (const u8*)"1", Var1FooHandler, nullptr };
gBehaviors[VAR_3] = { (const u8*)"3", nullptr, Var3BarHandler };

3. 兼容C代码访问 #

将结构体定义和数组声明放在extern "C"块中，C代码即可直接访问：

extern "C" {
    typedef void (*FooHandler)(void);
    typedef void (*BarHandler)(int);

    typedef struct {
        const u8* name;
        FooHandler handleFooEvent;
        BarHandler handleBarEvent;
    } Behavior;

    extern const Behavior gBehaviors[];
}

混合方案（C为主，C++辅助） #

若部分逻辑需要C的面向对象特性，可将C类封装为C兼容接口：

1. 在C++中定义Behavior类，包含成员函数和数据
2. 提供C风格的函数指针，指向类的静态成员函数或全局包装函数
3. 将这些函数指针和数据打包为C兼容的结构体，供C代码调用

不过这种方案复杂度较高，若无需C++特性，优先选择纯C方案更简洁直接。

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