在運行時選擇ctor參數

Question

是否可以解決以下使用mpl在運行時選擇參數的方案？

struct A { 
    A(int number) { /* use number */ } }; 
struct B { }; 

template <typename T, int n> 
struct A_or_B_Holder { 
    A_or_B_Holder() : _t(/* void or 'n', depends on T */) { } 
private: 
    T _t; 
}; 

A_or_B_Holder<B, void> b; 
A_or_B_Holder<A, 3> a; 

理想的情況下，

A_or_B_Holder<B> b; 
A_or_B_Holder<A, 3> a; 

Answer 1

你的第一個問題是：void是一個類型，而不是一個整數。您可以使模板接受兩種類型，第二種是boost::mpl::int_或void。

然後你可以專門化整個結構，或者你可以把數據成員放在一個基類中並且專門化它。

#include <boost/mpl/int.hpp> 

struct A { 
    A(int number) { /* use number */ } }; 
struct B { }; 

template <class T, class Value> 
struct A_or_B_Holder_Base{ 
    A_or_B_Holder_Base(): _t(Value::value) {} 
protected: 
    T _t; 
}; 

template <class T>  
struct A_or_B_Holder_Base<T, void> { 
    A_or_B_Holder_Base(): _t() {} 
protected: 
    T _t; 
}; 

template <typename T, typename Value> 
struct A_or_B_Holder : public A_or_B_Holder_Base<T, Value> { 

}; 

using boost::mpl::int_; 
A_or_B_Holder<A, int_<3> > x; 
A_or_B_Holder<B, void> y; 
A_or_B_Holder<A, void > w; //error, no default constructor 
A_or_B_Holder<B, int_<3> > z; //error, no int constructor 

更自然可能是不要求的參數是一個編譯時間常數（因爲你是無論如何轉動編譯時常到一個運行時間變量）。只是重載構造函數。

struct A { 
    A(int number) { /* use number */ } }; 
struct B { }; 


template <typename T> 
struct A_or_B_Holder { 
    A_or_B_Holder() : _t() { } 
    A_or_B_Holder(int number): _t(number) {} 
private: 
    T _t; 
}; 

A_or_B_Holder<B> b; 
A_or_B_Holder<A> a(3); 

Answer 2

我認爲，通過不同的參數在運行時是不可能的。你必須有一個所有T類型都有的標準構造函數。你可以從std::vector<void*>構造所有的T類型，並使用它來傳遞可變數量的變量類型參數，但這是危險的超級。

但是，您的示例似乎實際上是在編譯時決定，而不是運行時，這是可以解決的。

const int NO_INT_PARAM=INT_MIN; 
template <typename T, int n> 
struct A_or_B_Base { 
    A_or_B_Holder() : _t(n) { } 
private: 
    T _t; 
}; 
template <typename T> 
struct A_or_B_Base<T, NO_INT_PARAM> { 
    A_or_B_Holder() : _t() { } 
private: 
    T _t; 
}; 
template <typename T, int n=NO_INT_PARAM> 
struct A_or_B_Holder : A_or_B_Base<T, n>{ 
    A_or_B_Holder() : A_or_B_Base() { } 
    /* other functions*/ 
}; 

A_or_B_Holder<A, 3> a; //uses A(3) constructor 
A_or_B_Holder<B> b; //uses B() constructor 
A_or_B_Holder<A> c; //compiler error! A() doesn't exist! 
A_or_B_Holder<B, 5> d; //compiler error! B(5) doesn't exist! 
A_or_B_Holder<B, NO_INT_PARAM> e; //same as b, uses B() constructor 

Answer 3

你可以使用一個Boost.Variant

#include <boost/variant.hpp> 

struct A 
{ 
}; 

struct B 
{ 
    B(int) 
    { 
    } 
}; 

int main() 
{ 
    boost::variant<A, B> val; 

    if (/*some condition*/) 
    { 
     val = A(); 
    } 
    else 
    { 
     val = B(5); 
    } 
} 

如果您更感興趣的是，這是如何實現的，而不是你能幹什麼用的，我建議你檢查出Boost.Any和Boost.Variant的實現。