유형 목록에서 상속하고 상속 된 멤버 목록에서 멤버를 호출하는 방법?

Question

다음 구조를 가진 클래스 집합이 있습니다.

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

이 클래스 중 하나 이상을 클래스 X로 작성할 수 있어야합니다. 의사 코드 :

template<class TypeSequence> 
class X that derives publicly from all the classes in TypeSequence 
{ 
    X(int): all bases are initialized with the integer passed 
    {} 
    //if the above constructor is impossible, then the following will do as well: 
    X(int) 
    { 
     Call Init on all bases and pass the given int to them. 
    } 
}; 

mpl이 많이 필요하지만 실제로 잘하지 않습니다. 내가 할 수있는 일은 무엇입니까? 코드 샘플은 훌륭합니다.

내 오류 : 언급을 잊어 버렸습니다. C++ 11 기능을 사용할 수 없습니다. MPL 솔루션을 찾고 있습니다.

Answer 1

음, Boost.MPL에는 메타 기능이 포함되어 있습니다. inherit 및 inherit_linearlyfor_each과 결합하여 두 번째 변형 (init 함수 사용)을 얻을 수 있습니다.

#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); 
} 

Metafunction 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

뭔가 작동합니다. 인스턴스 당 사용되지 않는 기본 유형 당 최대 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

나는 부스트를 사용하지 않고 있으며, 내 솔루션이 얼마나 필요한지 잘 모르겠습니다. 코드를 테스트 한 후

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