どのように型のリストから継承し、継承されたメンバのリストでメンバを呼び出すのですか？

Question

次の構造を持つクラスのセットがあります。

class U 
{ 
public: 
    explicit U(int) { ... } 
    U() {...} 
    Init(int) {...} 
}; 

これらのクラスの1つ以上をクラスXに作成する必要があります。 mplがたくさん必要ですが、私はそれを本当によくしていません。私は何をしようとしていますか？コードサンプルは素晴らしいでしょう。

私のFAULT：私はC++ 11の機能を使うことはできません。私はMPLソリューションを探しています。

Answer 1

まあ、Boost.MPLには、メタ機能が含まれています。inheritとinherit_linearlyfor_eachと組み合わせて、（init関数を使用して）2番目のバリアントを得ることができます。

#include <iostream> 
#include <boost/mpl/fold.hpp> 
#include <boost/mpl/vector.hpp> 

struct A 
{ 
    A(int x) { std::cout << "A::A " << x << std::endl; } 
}; 

struct B 
{ 
    B(int x) { std::cout << "B::B " << x << std::endl; } 
}; 

struct C 
{ 
    C(int x) { std::cout << "C::C " << x << std::endl; } 
}; 

int main() 
{ 
    InheritFrom_IntConstructor< boost::mpl::vector<A, B, C> >(1); 
} 

メタ関数InheritFrom_IntConstructorは、コンストラクタのパラメータとして任意のタイプを受け入れるように一般化することができ、一般缶は、任意の数を受け入れることならば、私はよく分からない：

struct Null_IntConstructor 
{ 
    Null_IntConstructor(int) { } 
}; 

struct InheritFrom_IntConstructor_Folder 
{ 
    template<typename T1, typename T2> 
    struct apply 
    { 
    struct type : T1, T2 
    { 
     type(int x) : T1(x), T2(x) { } 
    }; 
    }; 
}; 

template<typename Bases> 
struct InheritFrom_IntConstructor 
    : boost::mpl::fold<Bases, 
        Null_IntConstructor, 
        InheritFrom_IntConstructor_Folder>::type 
{ 
    InheritFrom_IntConstructor(int x) 
    : boost::mpl::fold<Bases, 
         Null_IntConstructor, 
         InheritFrom_IntConstructor_Folder>::type(x) 
    { } 
}; 

使用例：それともboost::mpl::foldとカスタムメタ関数を使用して議論

Answer 2

何か作業をする必要があります：

template<class typeOne> 
class X1 : public typeOne 
{ 
    X(int b): typeOne(b) 
    {} 
}; 
template<class typeOne, class typeTwo> 
class X2 : public typeOne, public typeTwo 
{ 
    X(int b): typeOne(b), typeTwo(b) 
    {} 
}; 
template<class typeOne, class typeTwo, class TypeThree> 
class X3 : public typeOne, public typeTwo, public typeThree 
{ 
    X(int b): typeOne(b), typeTwo(b), typeThree(b) 
    {} 
}; 

か、あなたがオブジェクトごとに数バイトを無駄に喜んでいる場合は、プレースホルダを使用し、唯一の大規模なものを作ることができます。これは、インスタンスごとに使用されていない基本タイプごとに最大で1バイトを無駄にするはずです。

template<int> 
class PlaceHolder { PlaceHolder(int){} }; 

template< 
     class typeOne, 
     class typeTwo=PlaceHolder<2>, 
     class TypeThree=PlaceHolder<3>, 
     class TypeFour=PlaceHolder<4>, 
     class TypeFive=PlaceHolder<5> 
     > 
class X : 
     public typeOne, 
     public typeTwo, 
     public typeThree, 
     public typeFour, 
     public typeFive 
{ 
    X(int b) 
    : typeOne(b), 
    typeTwo(b), 
    typeThree(b), 
    typeFour(b), 
    typeFive(b) 
    {} 

    X(const X& b) 
    : typeOne(b), 
    typeTwo(b), 
    typeThree(b), 
    typeFour(b), 
    typeFive(b) 
    {} 

    X& operator=(const X& b) { 
     typeOne::operator=(b); 
     typeTwo::operator=(b); 
     typeThree::operator=(b); 
     typeFour::operator=(b); 
     typeFive::operator=(b);} 
     return *this; 
    } 
}; 

Answer 3

これはなんですか？

template <typename ...BaseClasses> 
class Aggregator : public BaseClasses... 
{ 
public: 
    Aggregator(int i) : BaseClasses(i)... 
    {} 

}; 

使用例：

Aggregator<U, V, W> a(10); 
Aggregator<U, V> b(15); 
Aggregator<W> c(20); 

注：可変長テンプレートを使用するため、C++ 11が必要です。

Answer 4

私はBoostを使用していないので、私の解決策がどれだけ必要なものに近いか分かりません。コードをテストし、その後、

template<typename typeseq> 
struct X : typeseq::head, X<typename typeseq::tail> 
{ 
    typedef typename typeseq::head base; 
    typedef X<typename typeseq::tail> recursebase; 
    X(int i) : base(i), recursebase(i) {} 
    void init(int i) 
    { 
     base::init(i); 
     recursebase::init(i); 
    } 
}; 

template<> 
struct X<null_type> 
{ 
    X(int i) {} 
    void init(int i) { } 
}; 

をそして：しかし、まだ、私はそれを掲示しています

typedef typelist<S,typelist<U>> typeseq; 
X<typeseq> x(10); 
x.init(100); 

オンラインデモ：http://ideone.com/e6tuM