CRTP设计中如何让基类使用派生类指定的类型实例化成员？

针对你提出的CRTP设计需求，这里提供两种现代C++的高效实现方案，既避免了基类模板参数冗余，又能保证派生类仅需指定一次TType：

方案一：中间类型持有者基类 #

通过让派生类先继承一个轻量的类型持有者基类，CRTP基类可以直接从派生类中获取TType，无需额外模板参数，也不会出现参数不匹配问题。

#include <utility>

// 轻量类型持有者，仅用于传递TType
template<typename T>
struct TTypeHolder {
    using TType = T;
};

// CRTP基类，从派生类Derived中获取TType
template<typename Derived>
class Base {
protected:
    using TType = typename Derived::TType;
    TType value; // 基类用TType实例化成员变量

public:
    TType& get_value() { return value; }
    const TType& get_value() const { return value; }

    // 基类可基于TType实现通用逻辑
    void reset_value() { value = TType{}; }
};

// 用户编写的派生类：仅需继承TTypeHolder指定TType，再继承CRTP基类
class MyDerived : public TTypeHolder<int>, public Base<MyDerived> {
    // 派生类专属逻辑，无需重复指定TType
public:
    void do_something() {
        get_value() += 10;
    }
};

这种方式的核心是利用C++的继承特性，让MyDerived自动继承TTypeHolder<int>的TType别名，Base<MyDerived>通过typename Derived::TType获取该类型时，派生类已经完成了TType的定义（继承顺序保证了TTypeHolder的成员先被解析）。

方案二：延迟实例化成员逻辑到成员函数 #

如果基类的成员变量不需要在类实例化阶段就完成类型解析，可以将依赖TType的逻辑放到成员函数中，利用C++模板成员函数的延迟实例化特性（成员函数直到被调用时才会实例化，此时派生类已经是完整类型）。

#include <utility>

template<typename Derived>
class Base {
public:
    // 成员函数延迟实例化，此时Derived已完整定义，可正常访问TType
    auto& get_value() {
        using TType = typename Derived::TType;
        static TType value; // 静态成员，或改为成员变量（需调整）
        return value;
    }

    const auto& get_value() const {
        using TType = typename Derived::TType;
        static const TType value;
        return value;
    }

    // 基于TType的通用操作
    void reset_value() {
        get_value() = typename Derived::TType{};
    }
};

// 用户的派生类：仅需在类内定义TType
class MyDerived : public Base<MyDerived> {
public:
    using TType = std::string; // 仅指定一次TType
};

如果需要非静态的成员变量，可以将成员变量包装在一个内部模板结构体中，利用模板的延迟实例化特性：

template<typename Derived>
class Base {
private:
    // 辅助结构体，仅当Derived完整定义时才会实例化
    template<typename D>
    struct MemberStorage {
        using TType = typename D::TType;
        TType value;
    };

    MemberStorage<Derived> storage;

public:
    auto& get_value() {
        return storage.value;
    }

    const auto& get_value() const {
        return storage.value;
    }
};

这种方式无需额外基类，完全依赖C++模板的延迟实例化规则，避免了派生类定义阶段的类型解析问题。

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