强制类型的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; 
}