如何通过偏移量获取C语言结构体字段名并适配指定宏？

假设我们有一个无法修改的COPY_FIELD宏和如下结构体：

#define COPY_FIELD(target, source, field) \
    do { \
        (target) = source.field; \
    } while (0)

struct fields {
  int a;
  int b;
  int c;
};

该宏的常规用法是直接指定字段名，例如：

int return_target() {
    struct fields f;
    int target;
    f.a = 0;
    f.b = 1;
    f.c = 2;
    COPY_FIELD(target, f, c);
    return target;
}

现在需要实现类似通过索引（而非手动写字段名）调用COPY_FIELD的功能，比如以下伪代码的效果（注意此代码无法运行）：

int return_target(int idx) {
    struct fields f;
    int target;
    COPY_FIELD(target, f, (a + idx)); // 语法错误，无法直接通过偏移量计算字段名
    return target;
}

以下是可行的解决思路：

思路1：运行期索引映射（最直接方案） #

由于COPY_FIELD宏要求传入编译期可见的字段名，运行期的变量索引无法直接转换为字段名。可以通过switch-case将索引映射到对应的字段名调用：

int return_target(int idx) {
    struct fields f = {0, 1, 2};
    int target;

    switch (idx) {
        case 0: COPY_FIELD(target, f, a); break;
        case 1: COPY_FIELD(target, f, b); break;
        case 2: COPY_FIELD(target, f, c); break;
        default: target = -1; // 处理非法索引场景
    }
    return target;
}

这种方案完全遵守不能修改原宏的限制，逻辑直观，适合字段数量较少的场景。

思路2：函数指针数组封装（适合多字段场景） #

如果结构体字段数量较多，为避免重复编写switch-case，可以将每个字段的拷贝逻辑封装为独立函数，再通过函数指针数组按索引调用：

#include <stddef.h>

#define COPY_FIELD(target, source, field) \
    do { \
        (target) = source.field; \
    } while (0)

struct fields {
  int a;
  int b;
  int c;
};

typedef void (*CopyFieldFunc)(int*, const struct fields*);

void copy_a(int* target, const struct fields* source) {
    COPY_FIELD(*target, *source, a);
}

void copy_b(int* target, const struct fields* source) {
    COPY_FIELD(*target, *source, b);
}

void copy_c(int* target, const struct fields* source) {
    COPY_FIELD(*target, *source, c);
}

CopyFieldFunc copy_funcs[] = {copy_a, copy_b, copy_c};
const size_t field_count = sizeof(copy_funcs) / sizeof(copy_funcs[0]);

int return_target(int idx) {
    struct fields f = {0, 1, 2};
    int target = -1;

    if (idx >= 0 && (size_t)idx < field_count) {
        copy_funcs[idx](&target, &f);
    }
    return target;
}

思路3：编译期常量索引适配（仅支持编译期已知值） #

如果索引或偏移量是编译期常量，可以通过预处理器宏将其映射为字段名，结合_Generic实现编译期匹配：

#include <stddef.h>

#define COPY_FIELD(target, source, field) \
    do { \
        (target) = source.field; \
    } while (0)

struct fields {
  int a;
  int b;
  int c;
};

#define IDX_TO_FIELD(idx) \
    _Generic((idx), \
        int: _Generic((idx == 0 ? 0 : idx == 1 ? 1 : 2), \
            int: a, \
            int: b, \
            int: c \
        ) \
    )

// 编译期常量索引调用示例
#define CONST_IDX 2
int return_const_target() {
    struct fields f = {0, 1, 2};
    int target;
    COPY_FIELD(target, f, IDX_TO_FIELD(CONST_IDX));
    return target;
}

注意：此方案仅适用于编译期已知的索引，无法处理运行期传入的变量索引。

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