Как написать любопытно повторяющиеся шаблоны с более чем 2 слоями наследования?
Весь материал, который я прочитал на шаблоне "Любопытно повторяющийся шаблон", кажется одним уровнем наследования, т.е. 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 параметров, многие из которых являются необязательными и имеют приемлемые значения по умолчанию. Чтобы избежать скуки необязательных параметров, лучшим решением является использование идиомы именованных параметров.
Основная проблема с этой идиомой заключается в том, что функции класса параметров должны возвращать объект, к которому они обращаются, однако некоторые параметры передаются GuiElement, некоторые - Window, а некоторые - AlertBox. Вам нужен способ написать это:
AlertBox box = AlertBoxOptions()
.GuiElementParameter(1)
.WindowParameter(2)
.AlertBoxParameter(3)
.create();
Тем не менее, это может произойти сбой, потому что, например, GuiElementParameter(int), вероятно, возвращает GuiElementOptions&, который не имеет функции WindowParameter(int).
Об этом уже спрашивалось, и решение, похоже, немного напоминает шаблон любопытно повторяющегося шаблона. Особый вкус, который я использую, здесь.
Хотя каждый раз, когда я создаю новый элемент Gui, нужно писать много кода. Я искал способы упростить это. Основной причиной сложности является тот факт, что я использую CRTP для решения проблемы Named-Parameter-Idiom, но у меня есть три слоя, а не два (GuiElement, Window и AlertBox), и мой текущий обходной путь в четыре раза превышает количество классов, которые у меня есть, (!) Например, Window, WindowOptions, WindowBuilderT и WindowBuilder.
Это подводит меня к моему вопросу, в котором я, по сути, ищу более элегантный способ использования CRTP в длинных цепочках наследования, таких как GuiElement, Window и Alertbox.
3 ответа
Вот то, на чем я остановился, используя вариант 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;
};
Я не совсем понимаю, чего вы надеетесь достичь, но это очень близко к тому, о чем вы, похоже, просите.
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 еще не существует
Я думаю, что невозможно реализовать какой-то общий механизм. Вы должны явно указывать точный параметр шаблона каждый раз, когда наследуете базовый класс, независимо от того, сколько уровней косвенности расположено между ними (судя по вашему ответу: теперь есть 2 уровня: вы не передаете C непосредственно в базу, но Си, завернутый в структуру тегов, выглядит как змея, которая кусает свой хвост)
Возможно, для вашей задачи было бы лучше использовать стирание типа, а не любопытно повторяющийся шаблон. Может быть, это будет полезно