如何在类型依赖于派生类的基模板类中声明成员？

Question

给定一个使用 CRTP 的基类，我正在考虑在基模板类中声明一个成员，其中类型依赖于派生类。

虽然以下工作按预期工作：

template <class T> class BaseTraits;
template <class T> class Base {
    using TypeId = typename BaseTraits<T>::TypeId;
    TypeId id;
 public:
    Base() { id = 123; }
    TypeId getId() { return id; }
};

class Derived;
template <> class BaseTraits<Derived> {
public:
    using TypeId = int;
};

class Derived : public Base<Derived> {};

int main(int argc, char ** argv) {
     Derived foo;
     return foo.getId();
}

我想知道我是否可以简化实现。我可以向Base 模板添加第二个模板参数，并使BaseTraits 更简单，甚至去掉它。然而，上面的 sn-p 已经是尝试删除第二个模板参数了。我正在寻找不涉及 Base 的第二个模板参数的解决方案。

我尝试了类似以下的方法，但它无法编译：

错误：对不完整类型“类派生”的无效使用

template <class T> class Base {
    using TypeId = typename T::TypeId;
    TypeId id;
 public:
    Base() { id = 123; }
    TypeId getId() { return id; }
};

class Derived : public Base<Derived> {
public:
    using TypeId = int;
};

int main(int argc, char ** argv) {
     Derived foo;
     return foo.getId();
}

更新：

• 我仅限于 c++14。
• Base 必须是模板。
• 性能是必须的。

Answer 1

是否可以让成员类型直接依赖于派生类？将 auto 声明的成员函数的结果类型（推导出的返回类型），不可能。

因此，type-trait 的使用就像您在 您的解决方案中所做的那样是最好的也是唯一的解决方案。

原因是基类在定义派生类时必须是一个完整的类型：编译器在解析派生类定义之前必须先实例化和解析基类定义，C++ standard N4140 [derived.class]/2（粗体是我的）：

由基本类型说明符表示的类型应该是一个不是未完全定义的类的类类型；[...]

Answer 2

这样的事情怎么样：

template <typename T, typename TypeId> class Base 
{
private:
    TypeId id;
public:
    Base() { id = 123; }
    TypeId getId() {return id;}
};

class Derived : public Base<Derived, int> {};

Answer 3

这有点简化，但你要为此付出一些代价。

#include <any>

template <class T> class Base {
    std::any id; // expensive, but cannot have T::TypeId here
 public:
    Base() : id(123) {}
    auto getId() { 
         return std::any_cast<typename T::TypeId>(id); 
    } // T::TypeId is OK inside a member function
};

class Derived : public Base<Derived> {
public:
    using TypeId = int;
};

Answer 4

为什么不颠倒类层次结构？

template <class T>
class Base : T {
    using TypeId = typename T::TypeId;
    TypeId id;
 public:
    Base() { id = 123; }
    TypeId getId() { return id; }
};

struct BasicDerived {
    using TypeId = int;
};


using Derived = Base<BasicDerived>;

Answer 5

其实，我想多了……这还不算太不愉快：
你可以有一个绑定结构，甚至可以写成一个宏，在真正的类之前声明。
绑定结构为真实类定义了枚举和不完整的 typedef。
模板是在所有这些之前定义的，但是使用 typename 来延迟它的依赖，但是它是由真实类实例化的，并且只依赖于绑定结构

template <class ThatClassWrapper>
class MyBase
{
protected:
    typedef typename ThatClassWrapper::TypeId TypeId;
    typedef typename ThatClassWrapper::RealClass ThatClass;
    TypeId typeIdValue;
    TypeId  GetTypeId() {   return typeIdValue; }
    std::vector<ThatClass*> storage;
};

class SomeClass;
namespace TypeIdBinding
{
    struct SomeClass
    {
        enum TypeId
        {
            hello, world
        };
        typedef ::SomeClass RealClass;
    };
}
class SomeClass: public MyBase<TypeIdBinding::SomeClass>
{
public:
    bool CheckValue(TypeId id)
    {   return id == typeIdValue;   }
};

请注意，真正的类使用模板库中定义的 TypeId，并且命名成员不直接可见。您可以通过让模板 Base 从绑定结构派生来解决这个问题（确认它以这种方式编译）。尽管我实际上喜欢在 c++11 中这样做，但您可以仅从另一个命名空间导出或 typedef 枚举类型名，并将该类型名用作枚举成员的前缀，有助于避免名称污染。

Answer 6

说实话，你已经碰到了硬循环依赖的墙。 任何出路都会很臭。
最终，两个模板参数似乎是一个很小的代价。

你能声明一个接受 Derived 和 TypeID 的虚拟模板类吗？不过，我认为这对你没有任何好处。

TypeID:Derived 是 1:1 映射吗？用另一个帮助模板过度表示 1:1 映射到从 TypeID 派生的回溯查找会更好吗？请注意，需要在 Derived 类之外定义 TypeID 才能执行此操作。
TypeID 真的需要在类中定义吗？它是否可以过滤掉 Base 中传入的定义以支持内部 typedef 的现有使用？

你能双重包含吗？拆分或修改派生的定义，以便 typeid 位于可以包含在模板之前的基类定义中？这个 DerivedBase 可以在命名空间中声明，并包含指向完整 Derived 类的 typedef 链接，因此 Base 可以找到它以供参考。