De-facto-Liste primitiver Typen, die in C++ verwendbar sind

Question

Wenn Sie beispielsweise eine Klasse eines Variantentyps schreiben, benötigen Sie natürlich eine Identifikation darüber, welchen Typ eine Instanz dieser Klasse enthält. Ich frage mich, ob jemand eine offizielle oder halboffizielle (de-facto?) Referenz aller primitiven Datentypen kennt, an denen man interessiert sein könnte?

Nur Primitive und keine Notwendigkeit für abstrakte Typen wie Zeichenfolge oder Handle.

Danke.

Answer 1

Die einzige offizielle Referenz ist die ISO/IEC 14882 C++ Standard.

Answer 2

Google-Suche ist immer ein guter Anfang. Here. Jetzt rolle deine eigentliche Frage aus.

Answer 3

Verwenden Sie eine beliebige Drittanbieter-Variante.

Alle Datentypen, die Sie im Standard nicht finden können.

Answer 4

Haben Sie darüber nachgedacht, eine andere Bibliothek das schwere Heben durchführen zu lassen?

Es gibt Boost.Variant, die wahrscheinlich tun, was Sie brauchen, vollständig getestet, typsicher und korrekt und ziemlich effizient.

Oder wenn Sie Ihre eigene Rolle möchten, verwenden Sie Boost.TypeTraits

Answer 5

Sie brauchen nichts über Typen wissen, ob Sie typeid verwenden:

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

Beachten Sie, dass Sie von max_size loswerden können, Wenn Sie akzeptieren können, dass der Wert dynamisch zugewiesen wird. Ich wollte nur zeigen, dass die Platzzuweisung auch funktioniert, wenn Sie die Größe des größten Typs kennen.