Как записать любопытно повторяющиеся шаблоны больше чем с 2 слоями наследования?
Весь материал, который я считал на Любопытно Повторяющемся Шаблонном Шаблоне, кажется одному слою наследования, т.е. Base и Derived : Base. Что, если я хочу взять его один шаг вперед?
#include
using std::cout;
template class A {
public:
LowestDerivedClass& get() { return *static_cast(this); }
void print() { cout << "A\n"; }
};
template class B : public A {
public: void print() { cout << "B\n"; }
};
class C : public B {
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
B
Используя c.get () .print () и b.get () .print ()?
Мотивация: Предположим, что у меня есть три класса,
class GuiElement { /* ... */ };
class Window : public GuiElement { /* ... */ };
class AlertBox : public Window { /* ... */ };
Каждый класс берет приблизительно 6 параметров в их конструкторе, многие из которых являются дополнительными и имеют разумные значения по умолчанию. Для предотвращения скуки дополнительных параметров лучшее решение состоит в том, чтобы использовать Именованную Идиому Параметра.
Фундаментальная проблема с этой идиомой состоит в том, что функции класса параметра должны возвратить объект, к ним обращаются, все же некоторые параметры даны GuiElement, некоторым к Окну и некоторым к AlertBox. Вам нужен способ записать это:
AlertBox box = AlertBoxOptions()
.GuiElementParameter(1)
.WindowParameter(2)
.AlertBoxParameter(3)
.create();
Все же это, вероятно, перестало бы работать, потому что, например, GuiElementParameter (интервал), вероятно, возвращает GuiElementOptions&, который не имеет WindowParameter (международной) функцией.
Это спросили прежде, и решение, кажется, некоторая разновидность Любопытно Повторяющегося Шаблонного Шаблона. Специфический аромат, который я использую, здесь.
Это - много кода для записи каждый раз, когда я создаю нового Gui Element все же. Я искал способы упростить его. Основной причиной сложности является то, что я использую CRTP для решения проблемы Именованной Идиомы Параметра, но у меня есть три слоя не два (GuiElement, Окно и AlertBox), и мое текущее обходное решение увеличивает количество в четыре раза классов, которые я имею. (!) например, Окно, WindowOptions, WindowBuilderT и WindowBuilder.
Это приносит мне к моему вопросу, где я по существу ищу более изящный способ использовать CRTP на длинных цепочках наследования, таких как GuiElement, Окно и Окно предупреждений.
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 еще не существует.
Я думаю, что невозможно реализовать какой-то общий механизм. Вы должны явно указывать точный параметр шаблона каждый раз, когда наследуете базовый класс, независимо от того, сколько уровней косвенности размещено между (судя по вашему ответу: теперь есть 2 уровня: вы не передаете C непосредственно в базу, но C, завернутый в структуру тега, выглядит как змея, кусающая себя за хвост)
Вероятно, для вашей задачи было бы лучше использовать стирание типа, а не любопытно повторяющийся шаблон шаблона. Может быть, это пригодится