如何让modifyA函数兼容small与large结构体以修改成员a？

先看你定义的结构体：

typedef struct small {
    int a;
} small;

typedef struct large {
    small* s;
    int b;
} large;

目前你有一个修改a的函数：

void modifyA(small* s, int newVal){
  s->a = newVal;
}

你希望这个函数能通用，既能接收small*，也能直接传large*来修改内部的a，比如像这样调用：

int main(){
  large* l;
  small* s;
  int newVal = 10;

  // 假设l和s的所有成员均已正确初始化

  modifyA(l, 10);  // 直接传large指针修改l->s->a
  modifyA(s, 10);

  return 0;
}

有几种可行的实现方式：

方法1：用C11的_Generic模拟函数重载 #

C语言本身没有函数重载，但C11标准引入的_Generic可以在编译时根据参数类型选择对应函数，完美实现你要的效果：

#include <stdio.h>

typedef struct small {
    int a;
} small;

typedef struct large {
    small* s;
    int b;
} large;

// 专门处理small指针的底层函数
void _modify_small(small* s, int newVal) {
    s->a = newVal;
}

// 专门处理large指针的底层函数
void _modify_large(large* l, int newVal) {
    l->s->a = newVal;
}

// 用宏封装，自动根据参数类型分发
#define modifyA(ptr, val) _Generic((ptr), \
    small*: _modify_small, \
    large*: _modify_large)(ptr, val)

int main() {
    small s = {0};
    large l = {&s, 0};
    int newVal = 10;

    modifyA(&s, newVal);
    printf("s.a = %d\n", s.a); // 输出10

    modifyA(&l, newVal);
    printf("l.s->a = %d\n", l.s->a); // 输出10

    return 0;
}

这种方式调用起来最符合你的预期，编译时就完成类型判断，没有运行时开销。

方法2：手动传入类型标记（兼容旧标准） #

如果需要兼容C11之前的编译器，可以加一个类型枚举，让函数内部自行处理：

#include <stdio.h>

// 定义类型标记
typedef enum {
    TYPE_SMALL,
    TYPE_LARGE
} ObjType;

typedef struct small {
    int a;
} small;

typedef struct large {
    small* s;
    int b;
} large;

void modifyA(void* obj, ObjType type, int newVal) {
    switch(type) {
        case TYPE_SMALL:
            ((small*)obj)->a = newVal;
            break;
        case TYPE_LARGE:
            ((large*)obj)->s->a = newVal;
            break;
        default:
            printf("传入的类型无效\n");
    }
}

int main() {
    small s = {0};
    large l = {&s, 0};
    int newVal = 10;

    modifyA(&s, TYPE_SMALL, newVal);
    printf("s.a = %d\n", s.a);

    modifyA(&l, TYPE_LARGE, newVal);
    printf("l.s->a = %d\n", l.s->a);

    return 0;
}

这种写法兼容性强，但调用时要多传一个类型参数，略显繁琐。

方法3：最简单的调用方式（不用改函数） #

其实如果不想折腾函数，直接在调用large指针时传入l->s就行，也就是你原来写的modifyA(l->s, 10)，这完全不需要修改现有函数，只是调用时多一步成员访问，简单直接。

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