強制類型的C++模板

Question

我有一個基本的模板類，但我想限制專業化的類型爲一組類或類型。例如：

template <typename T> 
class MyClass 
{ 
.../... 
private: 
    T* _p; 
}; 

MyClass<std::string> a; // OK 
MYCLass<short> b;  // OK 
MyClass<double> c;  // not OK 

這些僅僅是示例，允許的類型可能會有所不同。

這可能嗎？如果是這樣，怎麼做？

謝謝。

Answer 1

另一個版本是離開它未定義禁種

template<typename T> 
struct Allowed; // undefined for bad types! 

template<> struct Allowed<std::string> { }; 
template<> struct Allowed<short> { }; 

template<typename T> 
struct MyClass : private Allowed<T> { 
    // ... 
}; 

MyClass<double> m; // nono 

Answer 2

看看Boost概念檢查庫： http://www.boost.org/doc/libs/1_42_0/libs/concept_check/concept_check.htm

Answer 3

有各種各樣的技巧，允許檢查一些事情，這取決於你的標準是什麼實例化被允許。在實踐中，您應該爲Boost的Concept Check等人使用更高級別的庫。

Answer 4

Yust一個快速的想法，我敢肯定有更好的方法：

template <typename T> struct protector { 
static const int result = 1; 
}; 

template <> struct protector<double> { 
static const int result = -1; 
}; 

template <typename T> 
class MyClass 
{ 
    private: 
    char isfine[protector<T>::result]; 
}; 

這可能是更好的，但是，把脂肪評論過你的代碼，以保持用戶從錯誤類型的實例： - ）

Answer 5

林不知道這一點，但您可以添加其他模板專用雙 模板

class MyClass 
{ 
.../... 
private: 
    T* _p; 
}; 

template <double> class MyClass 
{}; 

這會爲你工作例如，但不適用於一般情況。

通常，我會添加一個編譯斷言來檢查不需要的類型。

希望它有幫助。

Answer 6

通常沒有必要限制哪些類型的模板可以被實例化。模板可以與給定的類型進行編譯（並且可以正常工作），或者它不是（並且在編程器部分沒有任何努力就會產生編譯器錯誤）。

---

如果你需要把限制，一般類型有共同的東西，可能通過某種類型的特質，已經上市（標準庫，boost::type_traits）來描述，也可以創建一個新的類型特徵他們。

例如，以下是一個只允許整數類型的模板類，使用std::numeric_limits來檢查它（如果您編寫自己的數值類型，則可以將其專門化，以便它也適用於您的新整數類型）。 static_assert僅爲C++ 0x，如果不可用，請使用BOOST_STATIC_ASSERT或其他一些技巧。

#include <limits> 
#include <string> 

template <class T> 
class X 
{ 
    static_assert(std::numeric_limits<T>::is_integer, "X can be only instantiated with integer types"); 
    //... 
}; 

int main() 
{ 
    X<int> xi; 
    X<char> xc; 
    //X<double> xd; 
    //X<std::string> xs; 
} 

---

如果你只打算支持任意類型的任何共同之處一小撮（這是從你的假設的例子明顯），一個方法是使用類型串。再次提升可能會讓任務變得更容易，但這裏是您如何推出自己的（這只是中途，需要額外的工作來宣佈類型列表更漂亮）。

struct no_type {}; 

template <class T, class U = no_type> 
struct t_list 
{ 
    typedef T head; 
    typedef U tail; 
}; 

//trait to check if two types are identical 
template <class T, class U> 
struct is_same 
{ 
    static const bool value = false; 
}; 

template <class T> 
struct is_same<T, T> 
{ 
    static const bool value = true; 
}; 

//compile-time recursion to check if T matches any type in list L 
template <class T, class L> 
struct in_type_list 
{ 
    static const bool value = 
     is_same<T, typename L::head>::value || in_type_list<T, typename L::tail>::value; 
}; 

//terminates recursion 
template <class T> 
struct in_type_list<T, no_type> 
{ 
    static const bool value = false; 
}; 

template <class T> 
class X 
{ 
    typedef t_list<double, t_list<int, t_list<char> > > allowed_types; //double, int, char 

    //poor man's static_assert 
    typedef int check_type [in_type_list<T, allowed_types>::value ? 1 : -1]; 
    //... 
}; 

int main() 
{ 
    X<char> xc; 
    X<int> xi; 
    X<double> xd; 
    //X<float> xf; 
}