Question

我在Curiously Recurring Template Pattern上阅读的所有材料似乎都是一层继承，即Base和Derived : Base<Derived>。如果我想更进一步怎么办？

#include <iostream>
using std::cout;


template<typename LowestDerivedClass> class A {
public:
    LowestDerivedClass& get() { return *static_cast<LowestDerivedClass*>(this); }
    void print() { cout << "A\n"; }
};
template<typename LowestDerivedClass> class B : public A<LowestDerivedClass> {
    public: void print() { cout << "B\n"; }
};
class C : public B<C> {
    public: void print() { cout << "C\n"; }
};

int main()
{
    C c;
    c.get().print();

//  B b;             // Intentionally bad syntax, 
//  b.get().print(); // to demonstrate what I'm trying to accomplish

    return 0;
}

如何重写此代码以进行编译而不会出现错误并显示

Ç
乙

使用c.get（）。print（）和b.get（）。print（）？

动机：假设我有三个班级，

class GuiElement { /* ... */ };
class Window : public GuiElement { /* ... */ };
class AlertBox : public Window { /* ... */ };

每个类在其构造函数中使用6个左右的参数，其中许多是可选的并且具有合理的默认值。要avoid the tedium of optional parameters，最好solution是使用Named Parameter Idiom。

这个习惯用法的一个基本问题是参数类的函数必须返回它们被调用的对象，但是一些参数被赋予GuiElement，一些参数被赋予Window，一些参数被赋予AlertBox。你需要一种方法来写这个：

AlertBox box = AlertBoxOptions()
    .GuiElementParameter(1)
    .WindowParameter(2)
    .AlertBoxParameter(3)
    .create();

然而，这可能会失败，因为，例如，GuiElementParameter（int）可能返回GuiElementOptions＆amp;，它没有WindowParameter（int）函数。

之前已经asked，解决方案似乎是奇怪的重复模板模式的一些风格。我使用的特殊风味是here。

每次创建新的Gui Element时都要编写很多代码。我一直在寻找简化它的方法。复杂性的一个主要原因是我使用CRTP来解决命名参数 - 成语问题，但我有三层而不是两层（GuiElement，Window和AlertBox），而我的current workaround数量是四倍我有课。（！）例如，Window，WindowOptions，WindowBuilderT和WindowBuilder。

这让我想到了我的问题，其中我基本上寻找一种更优雅的方式在长链继承上使用CRTP，例如GuiElement，Window和Alertbox。

Answer 1

我对你希望完成的事情并不完全清楚，但这是你似乎要求的近似值。

template<typename LowestDerivedClass> class A {
public:
    LowestDerivedClass& get() { return *static_cast<LowestDerivedClass*>(this); }
    void print() { cout << "A"; }
};
template<typename LowestDerivedClass> class Bbase 
  : public A<LowestDerivedClass> {
public: void print() { cout << "B"; this->A<LowestDerivedClass>::print(); }
};

class B : public Bbase<B> {
};

class C : public Bbase<C> {
public: void print() { cout << "C"; this->Bbase<C>::print(); }
};

int main() {
  C c;
  c.print();
  cout << endl;
  B b;
  b.print();
  cout << endl;
}

我更改了输出以更好地说明继承。在您的原始代码中，您不能假装B不是模板[您希望的最好的是B<>]，所以这样的事情可能是处理它的最不妥当的方式。< / p>

从你的答案来看，（2）是不可能的。如果函数的参数足以推断它们，你可以省去函数的模板参数，但是你必须提供一些类。（1）可以做到，但其尴尬。离开所有各层：

template<typename T> struct DefaultTag { typedef T type; };
template<typename Derived = void>
class B : public A<Derived> { /* what B should do when inherited from */ };
template<>
class B<void> : public A<DefaultTag<B<void> > > { /* what B should do otherwise */ };

你必须在每个级别做类似的事情。就像我说的那样，很尴尬。您不能简单地说typename Derived = DefaultTag<B> >或类似的东西，因为B尚不存在。

Answer 2

以下是我已经解决的问题，使用CRTP的变体来解决我的动机示例中提出的问题。从底部开始向上滚动可能是最好的阅读..

#include "boost/smart_ptr.hpp"
using namespace boost;

// *** First, the groundwork....
//     throw this code in a deep, dark place and never look at it again
//
//     (scroll down for usage example)

#define DefineBuilder(TYPE, BASE_TYPE) \
    template<typename TargetType, typename ReturnType> \
    class TemplatedBuilder<TYPE, TargetType, ReturnType> : public TemplatedBuilder<BASE_TYPE, TargetType, ReturnType> \
    { \
    protected: \
        TemplatedBuilder() {} \
    public: \
        Returns<ReturnType>::me; \
        Builds<TargetType>::options; \

template<typename TargetType>
class Builds
{
public:
    shared_ptr<TargetType> create() {
        shared_ptr<TargetType> target(new TargetType(options));
        return target;
    }

protected:
    Builds() {}
    typename TargetType::Options options;
};

template<typename ReturnType>
class Returns
{
protected:
    Returns() {}
    ReturnType& me() { return *static_cast<ReturnType*>(this); }
};

template<typename Tag, typename TargetType, typename ReturnType> class TemplatedBuilder;
template<typename TargetType> class Builder : public TemplatedBuilder<TargetType, TargetType, Builder<TargetType> > {};

struct InheritsNothing {};
template<typename TargetType, typename ReturnType>
class TemplatedBuilder<InheritsNothing, TargetType, ReturnType> : public Builds<TargetType>, public Returns<ReturnType>
{
protected:
    TemplatedBuilder() {}
};

// *** preparation for multiple layer CRTP example *** //
//     (keep scrolling...)

class A            
{ 
public: 
    struct Options { int a1; char a2; }; 

protected:
    A(Options& o) : a1(o.a1), a2(o.a2) {}
    friend class Builds<A>;

    int a1; char a2; 
};

class B : public A 
{ 
public: 
    struct Options : public A::Options { int b1; char b2; }; 

protected:
    B(Options& o) : A(o), b1(o.b1), b2(o.b2) {}
    friend class Builds<B>;

    int b1; char b2; 
};

class C : public B 
{ 

public: 
    struct Options : public B::Options { int c1; char c2; };

private:
    C(Options& o) : B(o), c1(o.c1), c2(o.c2) {}
    friend class Builds<C>;

    int c1; char c2; 
};


// *** many layer CRTP example *** //

DefineBuilder(A, InheritsNothing)
    ReturnType& a1(int i) { options.a1 = i; return me(); }
    ReturnType& a2(char c) { options.a2 = c; return me(); }
};

DefineBuilder(B, A)
    ReturnType& b1(int i) { options.b1 = i; return me(); }
    ReturnType& b2(char c) { options.b2 = c; return me(); }
};

DefineBuilder(C, B)
    ReturnType& c1(int i) { options.c1 = i; return me(); }
    ReturnType& c2(char c) { options.c2 = c; return me(); }
};

// note that I could go on forever like this, 
// i.e. with DefineBuilder(D, C), and so on.
//
// ReturnType will always be the first parameter passed to DefineBuilder.
// ie, in 'DefineBuilder(C, B)', ReturnType will be C.

// *** and finally, using many layer CRTP builders to construct objects ***/

int main()
{
    shared_ptr<A> a = Builder<A>().a1(1).a2('x').create();
    shared_ptr<B> b = Builder<B>().a1(1).b1(2).a2('x').b2('y').create();
    shared_ptr<B> c = Builder<C>().c2('z').a1(1).b1(2).a2('x').c1(3).b2('y').create(); 
    // (note: any order works)

    return 0;
};

Answer 3

我认为实现一些通用机制是不可能的。每次继承基类时都必须明确指定确切的模板参数，无论间接层有多少层次（根据你的答案判断：现在有两个级别：你不直接将C传递给基础，但是C包裹在标签结构中，它看起来像一条蛇咬自己的尾巴）

或许，您的任务使用类型擦除更好，而不是好奇地重复模板模式。可能是this会很有用

如何编写具有2层以上继承的奇怪重复模板？

3 个答案: