如何实现宏根据传入参数访问不同结构体成员？

我定义了两个结构体struct s1和struct s2，分别包含成员x和y。想通过宏（或函数）根据传入的ID参数区分并访问对应成员，但编写的宏编译报错，推测是因为宏在预处理阶段的展开方式不符合预期。请问在C语言中该如何实现这个功能？

原代码 #

struct s1 {
    int x;
};

struct s2 {
    int y;
};

#define MY_MACRO(ID, TYPE) do {  \
    TYPE new;                    \
    if(ID == 1) {                \
        new.x = 10;              \
    } else {                     \
        new.y = 20;              \
    }                            \
} while(0);

int main()
{
    MY_MACRO(1, struct s1);
    MY_MACRO(2, struct s2);

    return 0;
}

编译错误信息 #

$ gcc test2.c 
test2.c: In function ‘main’:
test2.c:18:12: error: ‘struct s1’ has no member named ‘y’
   18 |         new.y = 20;        \
      |            ^
test2.c:24:5: note: in expansion of macro ‘MY_MACRO’
   24 |     MY_MACRO(1, struct s1);
      |     ^~~~~~~~
test2.c:16:12: error: ‘struct s2’ has no member named ‘x’
   16 |         new.x = 10;  \
      |            ^
test2.c:25:5: note: in expansion of macro ‘MY_MACRO’
   25 |     MY_MACRO(2, struct s2);

错误核心是宏展开后，无论传入哪种TYPE，代码中同时存在new.x和new.y的访问语句，而目标结构体只包含其中一个成员，导致编译失败。需要确保编译时只生成对应类型的有效成员访问代码，以下是几种可行方案：

方案1：使用C11 _Generic 编译期分支（推荐） #

_Generic 是C11引入的特性，能在编译期根据变量类型选择对应代码分支，不会生成无效代码：

struct s1 {
    int x;
};

struct s2 {
    int y;
};

#define SET_MEMBER(ID, TYPE) do {  \
    TYPE new;                      \
    _Generic((new),                \
        struct s1: new.x = 10,     \
        struct s2: new.y = 20      \
    );                             \
} while(0);

int main()
{
    SET_MEMBER(1, struct s1);
    SET_MEMBER(2, struct s2);

    return 0;
}

展开后，传入struct s1时只会保留new.x = 10的代码，传入struct s2时只会保留new.y = 20的代码，完全避免无效成员访问。

方案2：预编译期宏分支（兼容旧标准） #

如果需要兼容C11之前的版本，可以通过预编译条件让宏直接展开为对应类型的代码：

struct s1 {
    int x;
};

struct s2 {
    int y;
};

// 针对不同类型定义专用宏
#define SET_S1() do { struct s1 new; new.x = 10; } while(0)
#define SET_S2() do { struct s2 new; new.y = 20; } while(0)

// 用宏选择对应的专用实现
#define MY_MACRO(ID, TYPE) _Generic((TYPE){0}, struct s1: SET_S1(), struct s2: SET_S2())

int main()
{
    MY_MACRO(1, struct s1);
    MY_MACRO(2, struct s2);

    return 0;
}

这种方式同样在编译期就确定了要执行的代码，不会生成无效的成员访问语句。

方案3：函数实现（类型不安全，不推荐） #

如果必须用函数，可以通过void*传递对象，但会失去编译期类型检查，容易出错：

struct s1 {
    int x;
};

struct s2 {
    int y;
};

void set_member(int id, void* obj) {
    if (id == 1) {
        ((struct s1*)obj)->x = 10;
    } else if (id == 2) {
        ((struct s2*)obj)->y = 20;
    }
}

int main()
{
    struct s1 s1_obj;
    struct s2 s2_obj;
    set_member(1, &s1_obj);
    set_member(2, &s2_obj);

    return 0;
}

使用时需要手动保证ID和对象类型匹配，否则会导致未定义行为。

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