Подтвердить что ты не робот

Как писать любопытно повторяющиеся шаблоны с более чем двумя слоями наследования?

Весь материал, который я прочитал на 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
В

Использование c.get(). print() и b.get(). print()?

Мотивация: Предположим, что у меня есть три класса,

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

Каждый класс принимает 6 или около того параметров в своем конструкторе, многие из которых являются необязательными и имеют разумные значения по умолчанию. Чтобы избежать скуки дополнительных параметров, лучшим решением является использование Именованный идентификатор параметров.

Основная проблема с этой идиомой заключается в том, что функции класса параметров должны возвращать объект, на который они вызваны, но некоторые параметры передаются в GuiElement, некоторые - в Window, а некоторые - в AlertBox. Вам нужен способ написать это:

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

Но это, вероятно, потерпит неудачу, потому что, например, GuiElementParameter (int), вероятно, возвращает GuiElementOptions &, который не имеет функции WindowParameter (int).

Ранее это было , и это решение кажется некоторым вкусом шаблона Curiously Recurring Template. Особый вкус, который я использую, здесь.

Это много кода, чтобы писать каждый раз, когда я создаю новый элемент Gui. Я искал способы упростить его. Основной причиной сложности является тот факт, что я использую CRTP для решения проблемы с Именованным параметром-Идиомом, но у меня есть три слоя не два (GuiElement, Window и AlertBox) и мой текущее обходное решение в четыре раза превышает количество классов, которые у меня есть. (!) Например, Window, WindowOptions, WindowBuilderT и WindowBuilder.

Это подводит меня к моему вопросу, в котором я ищу более элегантный способ использования CRTP в длинных цепочках наследования, таких как GuiElement, Window и Alertbox.

4b9b3361

Ответ 1

Вот что я решил, используя вариант 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;
};

Ответ 2

Я не совсем понимаю, что вы надеетесь достичь, но это приблизительное приближение к тому, что вы, кажется, просите.

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<>], поэтому что-то вроде этого, вероятно, является наименее неуклюжим способом его обработки.


Из вашего другого ответа (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 еще не существует.

Ответ 3

Я думаю, что невозможно реализовать какой-то общий механизм. Вы должны явно указывать точный параметр шаблона каждый раз, когда вы наследуете базовый класс, независимо от того, сколько уровней косвенности помещено между ними (судя по вашему ответу: теперь есть 2 уровня: вы не передаете C непосредственно на базу, но C, завернутый в структуру тега, выглядит как змея, которая кусает собственный хвост)

Возможно, было бы лучше, если бы ваша задача использовала стирание типа, а не любопытно повторяющийся шаблон шаблона. Может быть, этот будет полезен