首先得说清楚你这段代码为啥编译失败：你写的enum def { abc, D, E, F };里的abc是之前定义的枚举类型名，不是枚举值，编译器会把它当成一个新的枚举常量，默认值是0，正好和原enum abc里的A（值也是0）撞了，所以switch里就会报重复case的错误。

下面是几种在C语言中扩展已有枚举的常用方法，你可以根据自己的场景选择：

方法1：基于原枚举的最大值扩展（类型安全首选） #

这种方法的核心是让新枚举的值从原枚举的最后一个值+1开始，避免数值冲突。如果原枚举没有预留标记值，就手动用最后一个枚举值+1作为新枚举的起始点。

如果需要在新枚举里直接使用原枚举的值，也可以显式地把原枚举值映射过来（加前缀是为了避免命名冲突，也可以直接用原名称）：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>

// 假设这是来自其他头文件的枚举
enum abc { A, B, C };

// 扩展出的新枚举
enum def {
    // 映射原枚举的所有值（可选，方便统一使用def类型）
    DEF_A = A,
    DEF_B = B,
    DEF_C = C,
    // 从原枚举的下一个值开始定义新常量
    D = C + 1,
    E, // 自动为C+2
    F  // 自动为C+3
};

struct thing_s {
    enum def kind;
    union {
        unsigned n;
        char c;
        char *str;
    } data;
};

void print_thing(struct thing_s *t) {
    switch (t->kind) {
        case DEF_A:
            fprintf(stdout, "%ul\n", t->data.n);
            break;
        case DEF_B:
        case DEF_C:
        case D:
            fprintf(stdout, "%s\n", t->data.str);
            break;
        case E:
        case F:
            fprintf(stdout, "%c\n", t->data.c);
            break;
        default:
            assert(0);
    }
}

int main(int argc, char *argv[]) {
    struct thing_s t;
    t.kind = DEF_A; // 或者直接用A，因为数值相同
    t.data.n = 1;
    print_thing(&t);
    return EXIT_SUCCESS;
}

方法2：用typedef+宏定义实现无类型限制的扩展 #

如果你无法修改原枚举，且希望更灵活地扩展（比如不需要严格的枚举类型检查），可以把枚举统一当作整数类型处理，用宏定义来声明新的常量值：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>

// 来自其他头文件的枚举
enum abc { A, B, C };

// 定义统一的整数类型来承载所有类型标记
typedef int thing_kind_t;

// 用宏定义扩展新的常量
#define D (C + 1)
#define E (C + 2)
#define F (C + 3)

struct thing_s {
    thing_kind_t kind;
    union {
        unsigned n;
        char c;
        char *str;
    } data;
};

void print_thing(struct thing_s *t) {
    switch (t->kind) {
        case A:
            fprintf(stdout, "%ul\n", t->data.n);
            break;
        case B:
        case C:
        case D:
            fprintf(stdout, "%s\n", t->data.str);
            break;
        case E:
        case F:
            fprintf(stdout, "%c\n", t->data.c);
            break;
        default:
            assert(0);
    }
}

int main(int argc, char *argv[]) {
    struct thing_s t;
    t.kind = A;
    t.data.n = 1;
    print_thing(&t);
    return EXIT_SUCCESS;
}

这种方式的好处是不需要维护新的枚举类型，所有标记都用整数承载，缺点是失去了枚举类型的编译期检查。

方法3：修改原枚举（仅当你有权限修改原头文件时） #

如果你能修改原枚举所在的头文件，可以在原枚举里预留一个扩展起始标记，这样后续扩展就不用手动计算最大值了：

// 原头文件中的枚举修改为
enum abc { A, B, C, ABC_EXT_START }; // 预留扩展的起始点

// 你的代码中直接基于这个标记扩展
enum def {
    D = ABC_EXT_START,
    E,
    F
};

这种方式最清晰，但需要确保修改原枚举不会影响其他使用该头文件的代码。

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