valor - tipos de datos primitivos en c++

Identificar tipos primitivos en plantillas

Question

Estoy buscando una forma de identificar tipos de primitivas en una definición de clase de plantilla.

Quiero decir, tener esta clase:

template<class T>
class A{
void doWork(){
if(T isPrimitiveType())
doSomething();
else
doSomethingElse();
}
private:
T *t;
};

¿Hay alguna forma de "implementar" isPrimitiveType ()?

Answer 1

Aún otros 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();
}

Answer 2

Asumiendo por ''Tipo Primitivo'' te refieres a los tipos integrados, puedes hacer una serie de especializaciones de plantillas. Tu 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();
}

Answer 3

Creo 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

Answer 4

El siguiente ejemplo (publicado por primera vez en comp.lang.c ++. Moderado) ilustra el uso de la especialización parcial para imprimir cosas de manera diferente según sean o no tipos incorporados.

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

Answer 5

Hay una mejor manera: usar 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 > { };

Answer 6

No se puede hacer exactamente de la manera en que preguntaste. Aquí 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;
};

Puede recibir una advertencia si coloca el valor de isPrimitive directamente dentro de la declaración if . Es por eso que introduje una variable temporal.

Answer 7

Boost TypeTraits tiene muchas cosas.

Answer 8

ACTUALIZACIÓN : desde C ++ 11, use la plantilla is_fundamental de la biblioteca 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;
}
}

Para guardar la llamada de llamada de la función, use structs:

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 tiempo para implementarlo usted mismo y usar is_fundamental de Boost Type Traits Library, que parece hacer exactamente lo mismo.