C语言中如何无分支读取成员相同但偏移不同的结构体字段

针对两个字段相同但内存布局不同的结构体，我们可以通过以下几种方式避免重复编写if-else分支：

方法一：预定义字段偏移表 #

利用C标准库的offsetof宏（需包含<stddef.h>），预计算每个结构体各字段的内存偏移量，将其存入数组。读取字段时直接根据flag选择对应偏移表，通过指针偏移访问目标字段。

示例代码：

#include <stddef.h>

struct type1_A
{
    int a;
    char b;
    char rsvd[10];
    char c;
    int d;
};

struct type1_B
{
    int d;
    char rsvd[12];
    char c;
    char b;
    int a;
};

typedef enum {
    TYPE1_A = 0,
    TYPE1_B = 1
} Type1Type;

// 偏移表：行对应结构体类型，列对应字段a、b、c、d
const size_t type1_field_offsets[2][4] = {
    {offsetof(struct type1_A, a), offsetof(struct type1_A, b), offsetof(struct type1_A, c), offsetof(struct type1_A, d)},
    {offsetof(struct type1_B, a), offsetof(struct type1_B, b), offsetof(struct type1_B, c), offsetof(struct type1_B, d)}
};

// 统一读取字段a的函数
int get_type1_a(void *buffer, Type1Type flag) {
    return *(int *)((char *)buffer + type1_field_offsets[flag][0]);
}

// 统一读取字段b的函数
char get_type1_b(void *buffer, Type1Type flag) {
    return *(char *)((char *)buffer + type1_field_offsets[flag][1]);
}

这种方式的优势是编译期即可确定偏移量，性能与直接访问结构体一致，且无需重复编写分支逻辑。

方法二：函数指针表 #

为每种结构体的字段读取逻辑单独编写函数，再将这些函数存入指针数组。读取时直接通过flag索引数组调用对应函数。

示例代码：

// 针对TYPE1_A的字段读取函数
int get_a_from_A(void *buffer) {
    return ((struct type1_A *)buffer)->a;
}

char get_b_from_A(void *buffer) {
    return ((struct type1_A *)buffer)->b;
}

char get_c_from_A(void *buffer) {
    return ((struct type1_A *)buffer)->c;
}

int get_d_from_A(void *buffer) {
    return ((struct type1_A *)buffer)->d;
}

// 针对TYPE1_B的字段读取函数
int get_a_from_B(void *buffer) {
    return ((struct type1_B *)buffer)->a;
}

char get_b_from_B(void *buffer) {
    return ((struct type1_B *)buffer)->b;
}

char get_c_from_B(void *buffer) {
    return ((struct type1_B *)buffer)->c;
}

int get_d_from_B(void *buffer) {
    return ((struct type1_B *)buffer)->d;
}

// 定义函数指针类型
typedef int (*GetAFunc)(void *);
typedef char (*GetBFunc)(void *);
typedef char (*GetCFunc)(void *);
typedef int (*GetDFunc)(void *);

// 函数指针数组
const GetAFunc get_a_funcs[2] = {get_a_from_A, get_a_from_B};
const GetBFunc get_b_funcs[2] = {get_b_from_A, get_b_from_B};
const GetCFunc get_c_funcs[2] = {get_c_from_A, get_c_from_B};
const GetDFunc get_d_funcs[2] = {get_d_from_A, get_d_from_B};

// 使用方式
int a = get_a_funcs[flag](buffer);
char b = get_b_funcs[flag](buffer);
char c = get_c_funcs[flag](buffer);
int d = get_d_funcs[flag](buffer);

该方法适合字段类型复杂或需要额外处理逻辑的场景，调用时无分支开销。

方法三：封装统一访问接口结构体 #

将所有字段的读取函数封装到一个接口结构体中，每种结构体对应一个接口实例。通过flag获取对应接口后，即可统一调用所有字段的读取方法。

示例代码：

// 定义统一访问接口
typedef struct {
    int (*get_a)(void *);
    char (*get_b)(void *);
    char (*get_c)(void *);
    int (*get_d)(void *);
} Type1AccessInterface;

// TYPE1_A对应的接口实现
Type1AccessInterface interface_A = {
    .get_a = get_a_from_A,
    .get_b = get_b_from_A,
    .get_c = get_c_from_A,
    .get_d = get_d_from_A
};

// TYPE1_B对应的接口实现
Type1AccessInterface interface_B = {
    .get_a = get_a_from_B,
    .get_b = get_b_from_B,
    .get_c = get_c_from_B,
    .get_d = get_d_from_B
};

// 接口数组
const Type1AccessInterface *interfaces[2] = {&interface_A, &interface_B};

// 使用方式
Type1AccessInterface *current_interface = interfaces[flag];
int a = current_interface->get_a(buffer);
char b = current_interface->get_b(buffer);
char c = current_interface->get_c(buffer);
int d = current_interface->get_d(buffer);

这种方式模块化程度最高，适合字段数量多的场景，调用逻辑简洁统一，完全消除分支代码。

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