Estoy buscando una forma de identificar tipos de primitivas en una definición de clase de plantilla.Identificación de tipos primitivos en plantillas
quiero decir, tener esta clase:
template<class T>
class A{
void doWork(){
if(T isPrimitiveType())
doSomething();
else
doSomethingElse();
}
private:
T *t;
};
¿Hay alguna manera de "poner en práctica" isPrimitiveType().
ACTUALIZACIÓN: Desde C++ 11, utilice la plantilla is_fundamental de la librería estándar:
#include <type_traits>
template<class T>
void test() {
if (std::is_fundamental<T>::value) {
// ...
} else {
// ...
}
}
// Generic: Not primitive
template<class T>
bool isPrimitiveType() {
return false;
}
// Now, you have to create specializations for **all** primitive types
template<>
bool isPrimitiveType<int>() {
return true;
}
// TODO: bool, double, char, ....
// Usage:
template<class T>
void test() {
if (isPrimitiveType<T>()) {
std::cout << "Primitive" << std::endl;
} else {
std::cout << "Not primitive" << std::endl;
}
}
el fin de ahorrar la sobrecarga llamada a la función, el uso de estructuras:
template<class T>
struct IsPrimitiveType {
enum { VALUE = 0 };
};
template<>
struct IsPrimitiveType<int> {
enum { VALUE = 1 };
};
// ...
template<class T>
void test() {
if (IsPrimitiveType<T>::VALUE) {
// ...
} else {
// ...
}
}
Como han señalado otros, puede ahorrar su tiempo i El hecho de usarlo y usarlo es fundamental desde la Biblioteca de rasgos de tipo Boost, que parece hacer exactamente lo mismo.
Boost TypeTraits tiene muchas cosas.
Asumiendo por 'Tipo Primitivo' te refieres a los tipos incorporados, puedes hacer una serie de especializaciones de plantillas. Su código se convertiría en:
template<class T>
struct A{
void doWork();
private:
T *t;
};
template<> void A<float>::doWork()
{
doSomething();
}
template<> void A<int>::doWork()
{
doSomething();
}
// etc. for whatever types you like
template<class T> void A<T>::doWork()
{
doSomethingElse();
}
El siguiente ejemplo (. Primero publicado en comp.lang.C++ moderado) ilustra el uso de la especialización parcial para imprimir cosas de manera diferente dependiendo de si están o no están incorporados en los tipos.
// some template stuff
//--------------------
#include <iostream>
#include <vector>
#include <list>
using namespace std;
// test for numeric types
//-------------------------
template <typename T> struct IsNum {
enum { Yes = 0, No = 1 };
};
template <> struct IsNum <int> {
enum { Yes = 1, No = 0 };
};
template <> struct IsNum <double> {
enum { Yes = 1, No = 0 };
};
// add more IsNum types as required
// template with specialisation for collections and numeric types
//---------------------------------------------------------------
template <typename T, bool num = false> struct Printer {
void Print(const T & t) {
typename T::const_iterator it = t.begin();
while(it != t.end()) {
cout << *it << " ";
++it;
}
cout << endl;
}
};
template <typename T> struct Printer <T, true> {
void Print(const T & t) {
cout << t << endl;
}
};
// print function instantiates printer depoending on whether or
// not we are trying to print numeric type
//-------------------------------------------------------------
template <class T> void MyPrint(const T & t) {
Printer <T, IsNum<T>::Yes> p;
p.Print(t);
}
// some test types
//----------------
typedef std::vector <int> Vec;
typedef std::list <int> List;
// test it all
//------------
int main() {
Vec x;
x.push_back(1);
x.push_back(2);
MyPrint(x); // prints 1 2
List y;
y.push_back(3);
y.push_back(4);
MyPrint(y); // prints 3 4
int z = 42;
MyPrint(z); // prints 42
return 0;
}
Esto ayudó, gracias! – Ben
No se puede hacer exactamente de la manera que usted pidió. Así es cómo se puede hacer:
template<class T>
class A{
void doWork(){
bool isPrimitive = boost::is_fundamental<T>::value;
if(isPrimitive)
doSomething();
else
doSomethingElse();
}
private:
T *t;
};
Usted puede obtener una advertencia si se pone el valor de isPrimitive directamente dentro de la instrucción si . Es por eso que introduje una variable temporal.
Otro más ejemplos similares:
#include <boost/type_traits/is_fundamental.hpp>
#include <iostream>
template<typename T, bool=true>
struct foo_impl
{
void do_work()
{
std::cout << "0" << std::endl;
}
};
template<typename T>
struct foo_impl<T,false>
{
void do_work()
{
std::cout << "1" << std::endl;
}
};
template<class T>
struct foo
{
void do_work()
{
foo_impl<T, boost::is_fundamental<T>::value>().do_work();
}
};
int main()
{
foo<int> a; a.do_work();
foo<std::string> b; b.do_work();
}
Su versión es un poco más eficiente que la mía, pero consideré que no compensaba el costo de legibilidad. –
Probablemente haya formas aún mejores de hacerlo. Lo anterior fue pirateado rápidamente en vim para probar la idea ... – Anonymous
supongo que esto puede hacer el trabajo bastante bien, sin múltiples especializaciones:
# include <iostream>
# include <type_traits>
template <class T>
inline bool isPrimitiveType(const T& data) {
return std::is_fundamental<T>::value;
}
struct Foo {
int x;
char y;
unsigned long long z;
};
int main() {
Foo data;
std::cout << "isPrimitiveType(Foo): " << std::boolalpha
<< isPrimitiveType(data) << std::endl;
std::cout << "isPrimitiveType(int): " << std::boolalpha
<< isPrimitiveType(data.x) << std::endl;
std::cout << "isPrimitiveType(char): " << std::boolalpha
<< isPrimitiveType(data.y) << std::endl;
std::cout << "isPrimitiveType(unsigned long long): " << std::boolalpha
<< isPrimitiveType(data.z) << std::endl;
}
y la salida es:
isPrimitiveType(Foo): false
isPrimitiveType(int): true
isPrimitiveType(char): true
isPrimitiveType(unsigned long long): true
Hay es una mejor manera - usando SFINAE. Con SFINAE no tiene que enumerar todos los tipos primitivos. SFINAE es una técnica que depende de la idea de que cuando la especialización de la plantilla falla, vuelve a una plantilla más general. (significa "Fallo de especialización no es un error").
Además, realmente no define si considera que un puntero es un tipo primitivo, por lo que le haré plantillas para todas las combinaciones.
// takes a pointer type and returns the base type for the pointer.
// Non-pointer types evaluate to void.
template < typename T > struct DePtr { typedef void R; };
template < typename T > struct DePtr< T * > { typedef T R; };
template < typename T > struct DePtr< T * const > { typedef T R; };
template < typename T > struct DePtr< T * volatile > { typedef T R; };
template < typename T > struct DePtr< T * const volatile > { typedef T R; };
// ::value == true if T is a pointer type
template < class T > struct IsPointer { enum { value = false }; };
template < class T > struct IsPointer < T * > { enum { value = true }; };
template < class T > struct IsPointer < T * const > { enum { value = true }; };
template < class T > struct IsPointer < T * volatile > { enum { value = true }; };
template < class T > struct IsPointer < T * const volatile > { enum { value = true }; };
// ::value == true if T is a class type. (class pointer == false)
template < class T > struct IsClass
{
typedef u8 yes; typedef u16 no;
template < class C > static yes isClass(int C::*);
template < typename C > static no isClass(...);
enum { value = sizeof(isClass<T>(0)) == sizeof(yes) };
};
// ::value == true if T* is a class type. (class == false)
template < class T > struct IsClassPtr
{
typedef u8 yes; typedef u16 no;
template < class C > static yes isClass(int C::*);
template < typename C > static no isClass(...);
enum { value = sizeof(isClass< typename DePtr<T>::R >(0)) == sizeof(yes) };
};
// ::value == true if T is a class or any pointer type - including class and non-class pointers.
template < class T > struct IsClassOrPtr : public IsClass<T> { };
template < class T > struct IsClassOrPtr < T * > { enum { value = true }; };
template < class T > struct IsClassOrPtr < T * const > { enum { value = true }; };
template < class T > struct IsClassOrPtr < T * volatile > { enum { value = true }; };
template < class T > struct IsClassOrPtr < T * const volatile > { enum { value = true }; };
template < class T > struct IsClassOrClassPtr : public IsClass<T> { };
template < class T > struct IsClassOrClassPtr < T * > : public IsClassPtr< T* > { };
template < class T > struct IsClassOrClassPtr < T * const > : public IsClassPtr< T* const > { };
template < class T > struct IsClassOrClassPtr < T * volatile > : public IsClassPtr< T* volatile > { };
template < class T > struct IsClassOrClassPtr < T * const volatile > : public IsClassPtr< T* const volatile > { };
Tenga en cuenta también que existe la inversa: 'std :: is_class', por ejemplo,https://stackoverflow.com/questions/11287043/is-there-a-way-to-specialize-a-template-to-target-primitives –