7

我正在尝试使用一种简单形式的 CRTP（Curiously Recurring Template Pattern），因为我有几个类，每个类都有几个相关的类，我想要一种将它们绑定在一起的方法（例如，我有像 Widget 这样的类， Doobry 和 Whatsit，以及相关的类 WidgetHandle、DoobryHandle 和 WhatsitHandle）。

我用来继承的每个类都Base添加了一个value_typetypedef，以便基类可以将其引用为typename TWrapper::value_type.

struct WidgetHandle {};

template <typename TWrapper>
class Base
{
public:
    Base(typename TWrapper::value_type value_) 
        : value(value_) {}

    typename TWrapper::value_type   value;
};

class Widget : public Base<Widget>
{
public:
    typedef WidgetHandle value_type;

    Widget(WidgetHandle value_) : Base<Widget>(value_) {}
};

int main(int argc, char* argv[])
{

    Widget i(WidgetHandle());
    return 0;
}

但是，我收到编译错误：

scratch1.cpp(10): error C2039: 'value_type' : is not a member of 'Widget'
scratch1.cpp(16) : see declaration of 'Widget'
scratch1.cpp : see reference to class template instantiation 'Base<TWrapper>' being compiled
1>          with
1>          [
1>              TWrapper=Widget
1>          ]
scratch1.cpp(10): error C2039: 'value_type' : is not a member of 'Widget'

这是VS2010，虽然我在clang中遇到了类似的错误。我在这里想念什么？

4

2 回答 2

1

你不能有循环依赖：Base 需要在 Base 实例化时未知的 Widget value_type。

可能的解决方案是：将 value_type 作为 Base 模板参数传递，使用额外的 Traits 模板，...

示例：

template <typename W> 
struct WidgetTraits {};

template <typename W>
class Base
{
    public:
    typedef typename WidgetTraits<W>::value_type value_type;
};

class Widget;

template<>
struct WidgetTraits<Widget>
{
    typedef WidgetHandle value_type;
};

class Widget : public Base<Widget>
{
};

另一个（略有不同）示例：

template <typename C, typename A>
class B : public A
{
    public:
    typedef typename A::value_type value_type;
};


class A
{
    public:
    typedef WidgetHandle value_type;
};


class C : public B<C, A>
{
};
于 2013-08-22T13:48:37.360 回答
1

更改 Base 的定义，将句柄类型作为第二个参数，以避免循环依赖。

struct WidgetHandle {};

template <typename TWrapper, typename HandleType>
class Base
{
public:
    typedef HandleType value_type;

    Base(HandleType value_) 
        : value(value_) {}

    HandleType value;
};

class Widget : public Base<Widget, WidgetHandle>
{
public:
    Widget(WidgetHandle value_) : Base(value_) {}
};

int main(int argc, char* argv[])
{

    Widget i(WidgetHandle());
    return 0;
}

您还可以使用特征类来获取 Widget 的 WidgeHandle 类型。

struct WidgetHandle {};
class Widget;

template<class T>
struct Handle
{
};

template<>
struct Handle<Widget>
{
  typedef WidgetHandle type;  
};

template <typename TWrapper, typename HandleType = Handle<TWrapper>::type>
class Base
{
public:
    typedef HandleType value_type;

    Base(HandleType value_) 
        : value(value_) {}

    HandleType value;
};

class Widget : public Base<Widget>
{
public:
    Widget(WidgetHandle value_) : Base(value_) {}
};

int main(int argc, char* argv[])
{

    Widget i(WidgetHandle());
    return 0;
}
于 2013-08-22T13:54:06.650 回答