5

当使用奇怪的重复模板模式时，我无法引用属于派生类的 typedef，只有当我尝试从基类中引用它们时；gcc 抱怨no type named 'myType' in class Derived<...>。这似乎与使用 typedef、模板和奇怪的重复关系可能实现的不一致。

考虑：

/* crtp.cpp */

#include <iostream>
using namespace std;

// case 1. simple.

class Base {
public:
    typedef int a_t;

    a_t foo;
};

class Derived : public Base {
    a_t bar;
};

// case 2. template.

template<typename T>
class tBase {
public:
    typedef T b_t;
    T foo;
};

template <typename T>
class tDerived : public tBase<T> {
    typename tBase<T>::b_t bar;
};

// case 3. curiously recurring.

template <typename T, typename D>
class tCuriousBase {
public:
    typedef T c_t;
    c_t foo;
};

template <typename T>
class tCuriousDerived : public tCuriousBase<T,tCuriousDerived<T> > {
    typename tCuriousBase<T,tCuriousDerived<T> >::c_t bar;
};

// case 4. curiously recurring with member reference.

template <typename T, typename D>
class tCuriousMemberBase {
public:
    T foo;

    T get() {
        return static_cast<D*>(this)->bar;
    }
};

template <typename T>
class tCuriousMemberDerived : public tCuriousMemberBase<T, tCuriousMemberDerived<T> > {
public:
    T bar;

    tCuriousMemberDerived(T val) : bar(val) {}
};

// case 5. curiously recurring with typedef reference.

template <typename T, typename D>
class tCuriousTypeBase {
public:
    typedef T d_t;
    d_t foo;
    typename D::c_t baz;
};

template <typename T>
class tCuriousTypeDerived : public tCuriousTypeBase<T, tCuriousTypeDerived<T> > {
public:
    typedef T c_t;
    typename tCuriousTypeBase<T,tCuriousTypeDerived<T> >::d_t bar;
};

// entry point

int main(int argc, char **argv) {
    Derived::a_t one = 1;
    tDerived<double>::b_t two = 2;
    tCuriousDerived<double>::c_t three = 3;
    double four = tCuriousMemberDerived<double>(4).get();
    tCuriousTypeBase<double, tCuriousDerived<double> >::d_t five = 5;
    // tCuriousTypeDerived<double>::d_t six = 6; /* FAILS */

    cout << one   << endl;
    cout << two   << endl; 
    cout << three << endl;
    cout << four  << endl;
    cout << five  << endl;
    // cout << six << endl;
}

从 (1) 中，我们看到 typedef 确实是从基类继承到派生类；基类中声明的 typedef 可以通过派生类访问。

从 (2) 中，我们看到如果两个类都是模板，这仍然是正确的。

从 (3) 中，我们看到这种 typedef 继承在存在奇怪重复的模板关系的情况下仍然可以存在；我们在声明中通过派生类引用基类的 typedef three。

从（4）中，我们看到派生类的成员变量可以很容易地从基类中访问。

从 (5) 中，我们看到我们可以访问定义在模板参数上的 typedef（这在我们声明five使用与继承无关的类型时有效）。

然而，一旦我们在 (6) 中将模板参数设为派生类，typedef 突然变得不可访问，即使它看起来与派生类中的任何成员变量一样定义良好。

为什么是这样？

4

1 回答 1

9

这是“循环依赖”，或“不完整型”的另一个自我。

模板“元编程”是“编程类型”，但它需要一定程度的语义才能正确实例化类型。

考虑这个类比：

class A; //forwarded

class B
{
   A* pa; //good: we know how wide a pointer is, no matter if we don't know yet anything about A.
   A a; // bad: we don't know how much space it requires
};

class A
{
  float m;
}; // now we know, but it's too late

这可以通过将 A 放在 B 之前来解决，但如果 A 是

class A
{
   B m;
};

除了指针之外没有其他解决方案，因为递归将是无限的。（A 应该包含自己，而不是引用另一个副本）

现在，用同样的比喻，让我们编写“类型”：

template<class D>
class A
{
   typedef typename D::inner_type my_type; //required D to be known when A<D> is instantiated...
   my_type m; // ... otherwise we cannot know how wide A<D> will be.
};

这个声明本身并不坏，直到我们开始将 D 定义为...

class D: //here we only know D exist
    public A<D> //but A size depende on D definition...
{
  ....
  typedef long double; inner_type
  ....
}; // ....we know only starting from here

所以，基本上，我们不知道（还）当时 A 有多宽需要用它来创建 D。

打破这种“循环”的一种方法是在 CRT 循环之外使用一些“特征类”：

struct traits
{
   typedef long double inner_type;
   ....
};

template<class D, class Traits>
class A
{
  // this is easy: Traits does not depend itself on A
  typedef typename Traits::inner_type my_type;
  ....
};

template<class Traits>
class D: public A<D, Traits>
{
  typedef typename Traits::inner_type inner_type;
};

我们终于可以宣布

typedef D<traits> D_Inst;

换句话说， 和 之间的连贯性A::my_type由D::inner_type保证traits::inner_type，其定义是独立的。

于 2013-04-19T07:59:32.230 回答