CRTP子类和实例列表

Question

我正在尝试实现一种具有多重继承的 CRTP（如果我很好地理解它是什么）。

我的主要目标是有一个统一的方式来访问每个子类的实例列表。

可能的问题似乎在于命名空间的利用率。

这是最简单版本的代码： http://ideone.com/rFab5

我真正的问题更类似于： http://ideone.com/U7cAf

我使用 clang++ 时收到一个附加警告：

test.cpp:28:63: warning: static data member specialization of 'instances' must originally be declared in namespace 'NS1'; accepted as a C++0x extension [-Wc++0x-extensions]
template <> std::list<NS1::Derived*> NS1::Base<NS1::Derived>::instances;
                                                          ^ 
test.cpp:15:34: note: explicitly specialized declaration is here
        static std::list<T*> instances;

问题已更新使用命名空间时它的行为不同。

问题已重新编辑以在 Ideone 上发布代码

Answer 1

问题是您尝试错误地定义列表变量。一般来说，您需要为 Base 提供一个定义 - 您不仅仅为恰好是 Derived 子类的一部分定义它，除非它是显式专业化。

template<typename T> std::list<T*> NS1::Base<T>::instances;

http://ideone.com/Vclac

编译没有错误。不需要任何中间体或类似的东西。

Answer 2

将 Base() 和 Intermediary() 更改为 Base() 和 Intermediary构造函数使代码对于 GCC 来说OK。

在第二种情况下没有理由更改实例的定义：模板与第一种情况相同。

Answer 3

Afaik，您有以下选择。
首先，如果 Intermediate 始终在派生类型上进行模板化，则不需要它的列表，因为它永远不会是最派生的类型。如果它可以在其他类型上模板化/不派生，您可以添加一个默认的非类型 bool 模板参数，如下所示：

template<bool, class A, class B>
struct select_base{
  typedef A type;
};

template<class A, class B>
struct select_base<false,A,B>{
  typedef B type;
};

template<class T, bool IsDerived = false>
class Intermediate
  : public select_base<IsDerived,
                       Base<T>,
                       Base<Intermediate<T> >
                       >::type
{
  // ...
};

// derived use
class Derived : public Intermediate<Derived, true>
{
  // ...
};

// non-derived use:
Intermediate<int> im;

如果中间类未模板化并且尚未从 Base 派生，则您需要在最派生的类中再次从 Base 派生：

class Derived : public Intermediate, public Base<Derived>
{
  // ...
};

当中间体也从 Base 派生但未模板化时，就会出现大问题。您可以添加默认的派生类型，但这会使非派生使用变得更加难看：

#include <type_traits> // C++0x, use std::
//#include <tr1/type_traits> // C++03, use std::tr1::

struct nil_base{};

template<class Derived = nil_base>
class Intermediate
  : public select_base<std::is_same<Derived,nil_base>::value,
                       Base<Intermediate<Derived> >, //
                       Base<Derived>
                       >::type
{
  // ...
};

// derived use now without boolean flag
class Derived : public Intermediate<Derived>
{
  // ...
};

// non-derived use a bit uglier
Intermediate<> im;
//          ^^ -- sadly needed

Answer 4

以下内容可以在 MinGW g++ 4.4.1、MSVC 10.0 和 Comeau Online 4.3.10.1 上编译正常：

#include <list>

template <class T>
class Base
{
protected:
    Base()
    {
        instances.push_back(static_cast<T*>(this));
    }
private:
    static std::list<T*> instances;
};

template <class U>
class Intermediary : public Base<U>
{
protected:
    Intermediary()
    :Base<U>()
    {
    }
};

class Derived : public Intermediary<Derived>
{
public:
    Derived()
    :Intermediary<Derived>()
    {
    }
};

template<class Derived> std::list<Derived*> Base<Derived>::instances;

int main()
{}

instances 定义是从您的问题中逐字复制的。

我说，作为艾萨克·牛顿，我不提出任何假设！

干杯&呵呵，