21

不思議なことに繰り返し発生するテンプレートパターンで読んだすべての資料は、継承の1つの層、つまり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
B

c.get（）。print（）およびb.get（）。print（）を使用しますか？

動機：私が3つのクラスを持っていると仮定します、

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）はWindowParameter（int）関数を持たないGuiElementOptions＆を返す可能性があるため、これはおそらく失敗します。

これは以前に尋ねられたものであり、解決策は不思議なことに繰り返されるテンプレートパターンのフレーバーのようです。私が使用する特定のフレーバーはここにあります。

ただし、新しいGui要素を作成するたびに記述するコードはたくさんあります。私はそれを単純化する方法を探していました。複雑さの主な原因は、CRTPを使用してNamed-Parameter-Idiomの問題を解決しているという事実ですが、2つではなく3つのレイヤー（GuiElement、Window、AlertBox）があり、現在の回避策では、クラスの数が4倍になっています。 。（！）たとえば、Window、WindowOptions、WindowBuilderT、およびWindowBuilder。

それは私の質問に私をもたらします。そこでは、GuiElement、Window、Alertboxなどの継承の長いチェーンでCRTPを使用するためのよりエレガントな方法を本質的に探しています。

4

3 に答える 3

9

私はあなたが何を達成したいと思っているかについて完全には明確ではありませんが、これはあなたが求めているように見えることの近似値です。

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ん。

于 2010-05-12T17:48:30.287 に答える
4

これが、私のモチベーションの例で提示された問題を解決するために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;
};
于 2010-05-12T17:42:04.730 に答える
1

一般的なメカニズムを実装することは不可能だと思います。基本クラスを継承するたびに、間に配置される間接レベルの数に関係なく、正確なテンプレートパラメータを明示的に指定する必要があります（答えから判断すると、2つのレベルがあります：Cを直接ベースに渡さないでください。タグ構造体に包まれたC、それは自分の尻尾を噛むヘビのように見えます）

おそらく、不思議なことに繰り返されるテンプレートパターンではなく、型消去を使用する方がタスクに適しています。たぶん、これは役に立つでしょう

于 2010-05-12T18:17:39.450 に答える