如何编译时检测constexpr类EnumClass实例值的唯一性？

针对你的场景——使用constexpr+namespace实现的类枚举、跨独立库新增服务ID、要求编译时检查值唯一性且无额外依赖，以下是几种可行方案：

1. C++20 constexpr容器方案（推荐，标准兼容） #

利用C++20开始支持的constexpr标准容器，通过全局constexpr集合存储已注册ID，结合static_assert在编译时拦截重复值：

// 核心公共头文件（所有服务库必须包含）
#include <unordered_set>

namespace ServiceIDs {
    // 全局constexpr ID集合，初始为空
    inline constexpr auto& id_registry = []() {
        static constexpr std::unordered_set<int> empty_set{};
        return empty_set;
    }();

    // 注册ID的模板，自动检查唯一性
    template<int TargetID>
    struct IDRegistrar {
        static constexpr bool is_unique = []() {
            auto temp_registry = id_registry;
            auto [_, inserted] = temp_registry.insert(TargetID);
            return inserted;
        }();
        // 重复ID会触发编译错误
        static_assert(is_unique, "ERROR: Duplicate Service ID detected!");
    };
}

// 独立库A的头文件（无需依赖其他库）
namespace ServiceIDs {
    constexpr int AuthService = 1001;
    // 触发注册和检查，[[maybe_unused]]避免未使用警告
    [[maybe_unused]] static constexpr auto auth_reg = IDRegistrar<AuthService>{};
}

// 独立库B的头文件
namespace ServiceIDs {
    constexpr int PaymentService = 1002;
    [[maybe_unused]] static constexpr auto pay_reg = IDRegistrar<PaymentService>{};
    // 若写constexpr int DuplicateService = 1001; 编译时会直接报错
}

兼容性：GCC 11+、Clang 13+、MSVC 2022+完全支持，符合C++20标准。

2. 模板元编程方案（兼容C++17及更早） #

如果项目还在使用C++17或更早标准，可通过模板特化和递归元编程实现编译时ID唯一性检查，无需依赖标准容器：

// 核心公共头文件
#include <type_traits>

namespace ServiceIDs {
    // 编译时ID列表的基类
    template<int... IDs>
    struct CompileTimeIDList {};

    // 递归检查ID是否已存在的元函数
    template<int TargetID, typename List>
    struct IsDuplicateID;

    // 匹配到重复ID的特化
    template<int TargetID, int... RestIDs>
    struct IsDuplicateID<TargetID, CompileTimeIDList<TargetID, RestIDs...>> : std::true_type {};

    // 递归检查剩余ID
    template<int TargetID, int FirstID, int... RestIDs>
    struct IsDuplicateID<TargetID, CompileTimeIDList<FirstID, RestIDs...>> 
        : IsDuplicateID<TargetID, CompileTimeIDList<RestIDs...>> {};

    // 空列表的终止条件
    template<int TargetID>
    struct IsDuplicateID<TargetID, CompileTimeIDList<>> : std::false_type {};

    // 注册ID的模板，触发检查
    template<int TargetID>
    struct IDRegistrar {
        static constexpr bool is_unique = !IsDuplicateID<TargetID, decltype(GetGlobalIDList())>::value;
        static_assert(is_unique, "ERROR: Duplicate Service ID found!");
    };

    // 全局ID列表的初始定义
    inline constexpr auto GetGlobalIDList() {
        return CompileTimeIDList<>{};
    }
}

// 独立库A的头文件
namespace ServiceIDs {
    constexpr int AuthService = 1001;
    // 扩展全局ID列表并触发检查
    template<>
    inline constexpr auto GetGlobalIDList() {
        return CompileTimeIDList<AuthService, decltype(GetGlobalIDList())::value...>{};
    }
    [[maybe_unused]] static constexpr auto auth_reg = IDRegistrar<AuthService>{};
}

特点：兼容C++11及以上，无标准容器依赖，但代码相对繁琐。

3. 编译器内置扩展方案（简洁高效，非标准） #

如果项目允许使用编译器扩展，可利用各主流编译器（GCC/Clang/MSVC）都支持的__COUNTER__宏，封装成安全的注册宏，自动分配唯一ID：

// 核心公共头文件
#define REGISTER_SERVICE_ID(service_name) \
    constexpr int service_name = __COUNTER__ + 1000; \
    static_assert([]() { \
        static constexpr int registered_ids[] = {service_name}; \
        for (size_t i = 0; i < sizeof(registered_ids)/sizeof(registered_ids[0]); ++i) { \
            if (registered_ids[i] == service_name && i != (__COUNTER__ - 1)) return false; \
        } \
        return true; \
    }(), "ERROR: Duplicate Service ID detected!")

// 独立库A的头文件
namespace ServiceIDs {
    REGISTER_SERVICE_ID(AuthService); // 自动分配ID为1000 + __COUNTER__
}

// 独立库B的头文件
namespace ServiceIDs {
    REGISTER_SERVICE_ID(PaymentService);
}

注意：__COUNTER__是非标准特性，但跨主流编译器兼容，适合内部项目快速实现。

所有方案均满足你的核心要求：独立库无需依赖其他服务包、支持在不同头文件新增ID、编译时触发唯一性检查。

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