如何禁止模板类使用相同参数值进行多次派生？

我有一个采用CRTP实现静态多态的继承体系，其中基类的一个模板参数是整数值。我需要确保该数值在所有派生类中唯一，禁止出现以下重复使用的情况：

template<class R, quint16 N>
class Base
{...};

class DerA : Base<DerA, 10>
{...};

class DerB : Base<DerB, 10>
{...}; // 错误：10已被使用

优先通过static_assert()触发清晰的编译错误，也可以接受其他阻止编译的方式。

我尝试过思考类型特性类方案，但遇到难点：派生类的基类会随模板参数不同而成为不同的实例，无法共享状态；如果引入非模板基类，又无法和模板参数交互。由于缺乏模板元编程经验，这部分比较棘手。

如果必须通过派生类之外的额外代码（比如宏）实现，也可以接受，但前提是遗漏该代码会直接触发编译错误，不能有容易被遗忘且无即时提示的情况。另外，派生类是可扩展的，无法预先知晓所有N的取值。

我的目标是让每个派生类对应唯一的状态/错误类型，每个类型都能通过静态成员和虚方法访问唯一的“代码”。我已经想到运行时初始化阶段的检查方案：通过一个避免SIOF（静态初始化顺序问题）的std::set，让派生类通过基类的静态成员在构造时自动注册并检查重复，但更希望能在编译时完成检查。

编译时方案：宏强制注册+模板特化检查 #

这个方案通过宏强制用户注册派生类，同时利用模板特化的唯一性来检测重复代码，完全在编译阶段完成检查，遗漏注册或重复注册都会触发明确的编译错误。

实现代码 #

#include <type_traits>
#include <cstdint>

// 用于标记代码是否已被注册的模板
template<std::uint16_t N>
struct UsedCode : std::false_type {};

template<class Derived, std::uint16_t Code>
class Base {
    // 强制用户必须通过宏注册代码，否则触发错误
    static_assert(UsedCode<Code>::value, "错误：必须使用DECLARE_DERIVED_CLASS宏定义派生类");
    // 静态多态接口示例
public:
    static constexpr std::uint16_t code = Code;
    void doSomething() {
        static_cast<Derived*>(this)->doSomethingImpl();
    }
};

// 宏：同时完成代码注册和派生类定义
#define DECLARE_DERIVED_CLASS(CLASS_NAME, CODE) \
template<> struct UsedCode<CODE> : std::true_type {}; \
class CLASS_NAME : public Base<CLASS_NAME, CODE> { \
public: \
    void doSomethingImpl(); \
};

// 使用示例
DECLARE_DERIVED_CLASS(DerA, 10); // 正常注册
DECLARE_DERIVED_CLASS(DerB, 10); // 编译错误：重复特化UsedCode<10>
// class DerC : Base<DerC, 20> {}; // 编译错误：未使用宏注册，UsedCode<20>为false

// 实现派生类的具体逻辑
void DerA::doSomethingImpl() {
    // ...
}

方案说明 #

• 强制注册：基类中的static_assert会检查UsedCode<Code>是否为true，只有通过宏特化UsedCode<Code>为true才能通过检查，避免用户遗漏注册步骤。
• 重复检测：当两个派生类使用同一个代码时，宏中的模板特化会触发“重复特化”编译错误，直接阻止重复代码的使用。
• 编译时检查：所有错误都在编译阶段触发，错误信息清晰，无需运行时检查。

运行时方案：静态成员自动注册+集合检查 #

如果编译时方案无法满足需求（比如需要支持动态扩展的场景），可以采用运行时注册的方案，利用静态成员的初始化顺序自动完成代码注册和重复检查，同时避免SIOF问题。

实现代码 #

#include <set>
#include <stdexcept>
#include <cstdint>

// 非模板基类，负责代码注册和管理
class CodeRegistry {
protected:
    // 局部静态变量避免SIOF
    static std::set<std::uint16_t>& getRegisteredCodes() {
        static std::set<std::uint16_t> codes;
        return codes;
    }

    // 注册代码，重复则抛出异常
    static void registerCode(std::uint16_t code) {
        auto& codes = getRegisteredCodes();
        auto [it, inserted] = codes.insert(code);
        if (!inserted) {
            throw std::runtime_error("错误：代码值" + std::to_string(code) + "已被占用");
        }
    }
};

template<class Derived, std::uint16_t Code>
class Base : public CodeRegistry {
    // 静态成员，程序启动时自动注册代码
    static const bool isRegistered;
public:
    static constexpr std::uint16_t code = Code;
    // 静态多态接口示例
    void doSomething() {
        static_cast<Derived*>(this)->doSomethingImpl();
    }
};

// 初始化静态成员，完成代码注册
template<class Derived, std::uint16_t Code>
const bool Base<Derived, Code>::isRegistered = [](){
    CodeRegistry::registerCode(Code);
    return true;
}();

// 派生类示例
class DerA : public Base<DerA, 10> {
public:
    void doSomethingImpl() { /* ... */ }
};

class DerB : public Base<DerB, 10> {
public:
    void doSomethingImpl() { /* ... */ }
};

方案说明 #

• 自动注册：基类的静态成员isRegistered会在程序启动时初始化，通过lambda调用注册函数，自动完成代码注册。
• 重复检测：注册时会检查std::set中是否已存在该代码，重复则抛出runtime_error。
• 避免SIOF：使用局部静态变量存储注册集合，确保在第一次访问时才初始化，避免静态初始化顺序问题。

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