typedef 上与 CRTP 相关的编译器错误

Question

我想，关于 CRTP 的问题相当简单，但我似乎找不到答案它。大概是因为太简单了，所以没有人想到去问。我对这个概念很陌生，所以，请不要笑得太厉害；）。

下面是代码（有点类似于 STL 容器的尝试）：

template< typename tT >
struct TBase
{
  typedef tT T;
};

template< typename tTBase >
struct TTraitsBase
{
  typedef typename tTBase::T T;
};

template< typename tTHelpee, typename tTTraits >
struct THelper
{

  typedef typename tTTraits::T T;
  typedef typename tTHelpee::T Th; /* This generates a compiler error:
                                      'T' not being a member of TDerived<tT> */
  T Foo( void )
  {
   return static_cast< tTHelpee* > ( this )->mVal;
  }
};

template< typename tT >
struct TDerived : TBase< tT > , THelper< TDerived< tT > , TTraitsBase< TBase< tT > > >
{
 using TBase< tT >::T;
  T mVal;
};

int main()
{
 TDerived< int >::T lTmp = -1;
 TDerived< int > lObj;

 lObj.mVal = -1;
 std::cout << lObj.Foo() << std::endl;

 return 0;
}

如果我注释有问题的 typedef typename _THelpee::T Th;，一切都会编译。让我困惑的是：如果编译器不喜欢 typedef typename _THelpee::T Th;，为什么它会让 static_cast通过？ _THelpee* > （这个）->mVal？我认为，这与实例化TDerived时无法实例化THelper有关，但没有明确的理解。有人可以对这里发生的事情给出简短的解释和/或一些参考吗？谢谢。

编辑：删除了“_T”前缀。

Answer 1

隐式实例化类不会实例化其成员函数定义。类模板的每个成员仅在使用时才会实例化（除非您使用显式实例化）。

您隐式实例化的第一件事是 TDerived，位于 main 的第一行。为了实例化它，编译器会查找 TDerived 模板，发现有几个依赖基类，因此尝试实例化它们。 TBase 实例化没有问题。但在尝试实例化 THelper< TDerived、TTraitsBase< TBase> >，尝试获取成员 TDerived::T，但 TDerived 仍然是不完整类型。

实例化 THelper< ... > 还注意到有一个成员函数 int Foo()，但不评估其定义的语义。

当您从 main 调用 lObj.Foo() 时，它会实例化 int THelper... >::Foo()，TDerived 是一个完整的类型，所以那里没有问题。

Answer 2

发布的代码有几个问题。由于我无法弄清楚其意图，因此我将列出我发现错误的内容。

(1) 使用不完整类型：

template< typename _T >
struct TDerived : TBase< _T > , THelper< TDerived< _T > , TTraitsBase< TBase< _T > > >
                                         ^^^^^^^^^^^^^^ it's incomplete

IMO，当您定义 TDerived<_T> 的主体时，不应使用与任何东西的参数。

(2) 类型定义不当。

using TBase< _T >::T;

应该是

typedef typename TBase< _T >::T T;

Answer 3

我想说你的 CRTP 中有一个循环依赖（正如其本质一样），但这意味着基模板类不允许使用其任何参数类，因为该参数类尚未定义 - 在实例化 Base 时它仍然是一个不完整的类型。

所以，这是可以的：

template <typename T> struct Base
{
  T * impl;  // incomplete type is OK
};

class Foo : public Base<Foo> { /* ... */ };

但这不是：

template <typename T> struct Base
{
  T x; // need to know T, but T depends on Base<T>!
};