Tipo de fuerza de la plantilla C++

Question

Tengo una clase de plantilla básica, pero me gustaría restringir el tipo de la especialización a un conjunto de clases o tipos. e.g .:

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

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

Esos son solo ejemplos, los tipos permitidos pueden variar.

¿Eso es posible? Si es así, ¿cómo hacerlo?

Gracias.

Answer 1

Otra versión es dejarlo indefinido para los tipos prohibidos

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

Tome un vistazo a la Boost concepto de verificación Biblioteca: http://www.boost.org/doc/libs/1_42_0/libs/concept_check/concept_check.htm

Answer 3

Hay varios trucos que permiten comprobar si hay algunas cosas, dependiendo de cuáles son sus criterios para la creación de instancias es ser permitido o no. En la práctica, debería usar una biblioteca de palancas más alta para aquellos como Boost's Concept Check.

Answer 4

Yust una idea rápida, estoy seguro que hay mejores enfoques:

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]; 
}; 

Podría ser mejor, sin embargo, para poner un comentario grasa sobre su código para evitar que los usuarios crear instancias de los tipos incorrectos: -)

Answer 5

no estoy seguro de esto, pero se puede añadir otra especialización de plantilla para el doble plantilla

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

template <double> class MyClass 
{}; 

que trabajaría para usted r ejemplo, pero no para el caso general.

En general, agregaría una declaración de compilación para verificar los tipos no deseados.

Espero que ayude.

Answer 6

En general, no es necesario restringir con qué tipos de plantillas se pueden crear instancias. O bien la plantilla es compilable con el tipo dado (y funciona bien) o no (y produce un error de compilación sin ningún esfuerzo por parte del programador).

---

Si usted necesita para poner en restricciones, en general, los tipos tienen algo en común que puede ser descrito por algunos rasgos de tipo que ya están disponibles (biblioteca estándar, boost::type_traits), o puede crear un nuevo rasgo de tipo para ellos.

Por ejemplo, aquí hay una clase de plantilla que solo permite tipos enteros, usando std::numeric_limits para verificarla (si escribe su propio tipo numérico, puede especializarlo para que también funcione con su nuevo tipo entero). static_assert es C++ 0x solamente, si no está disponible use BOOST_STATIC_ASSERT o algún otro truco.

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

---

Si usted sólo va a apoyar a un puñado de tipos arbitrarios que no tienen nada en común (como se desprende de su ejemplo hipotético), una forma es emplear TypeListas. Nuevamente, aumentar la tarea puede hacer que la tarea sea mucho más fácil, pero así es cómo puede hacer la suya (esto solo va a la mitad, se requerirá trabajo adicional para hacer que la lista de tipos sea más bonita).

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