Liste de fait des types primitifs utilisables en C++

Question

Si, par exemple, vous allez écrire une classe de type variant, vous aurez naturellement besoin d'identifier le type que porte une instance de cette classe. Je me demande si quelqu'un connaît une référence officielle ou semi-officielle (de facto?) De tous les types de données primitifs qui pourraient vous intéresser?

Seules les primitives, et pas besoin de types abstraits comme chaîne ou gérer.

Merci.

Answer 1

La seule référence officielle est la norme C12 ISO/IEC 14882.

Answer 2

La recherche Google est toujours un bon début. Here. Maintenant, déployez votre vraie question.

Answer 3

Utilisez n'importe quel variante tierce.

Tous les types de données que vous ne trouvez pas dans la norme.

Answer 4

Avez-vous envisagé de laisser une autre bibliothèque soulever des charges lourdes?

Il y a Boost.Variant qui fait probablement ce dont vous avez besoin, entièrement testé, sûr et correct, et très efficace.

Ou si vous voulez rouler votre propre, utilisez Boost.TypeTraits

Answer 5

Vous n'avez pas besoin de savoir quoi que ce soit sur les types si vous utilisez typeid:

#include <typeinfo> 
#include <iostream> 

using namespace std; 

struct var_base 
{ 
    const type_info & t; 
    var_base(const type_info & t) : t(t) {}; 

    virtual ~var_base() {}; 
}; 

template<class T> struct var : var_base 
{ 
    T value; 

    var(T x) : var_base(typeid(T)), value(x) {}; 
}; 

struct variant { 
    const static int max_size=16; 

    char data[max_size]; 
    var_base & v; 

    variant() : v(*(var_base*)data) { 
     new (data) var<int>(0); 
    } 

    const type_info & getType() { return v.t; } 

    template<class T> T & get() { 
     assert(getType()==typeid(T)); 
     return static_cast< var<T> &>(v).value; 
    } 

    template<class T> void set(const T & value) { 
      // Compile time assert is also possible here. 
     assert(sizeof(var<T>)<=max_size); 
     v.~var_base(); 
     new (data) var<T>(value); 
    } 
}; 

main() 
{ 
    variant v; 
    v.set<float>(1.2); 
    cout << v.getType().name() << endl; 
    cout << v.get<float>(); 
    cout << v.get<int>(); // Assert fails 
} 

Notez que vous pouvez vous débarrasser de max_size, Si vous pouvez accepter que la valeur est allouée dynamiquement. Je voulais juste montrer que l'allocation de place fonctionne aussi, si vous connaissez la taille du plus grand type.