Liste de facto 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 d'une instance de cette classe. Je me demande si quelqu'un connaît des références officielles ou semi-officielles (de facto?) De tous les types de données primitifs qui pourraient éventuellement vous intéresser?

Seules les primitives et aucun type abstrait, comme chaîne ou handle .

Merci.

Answer 1

La seule référence officielle est la ISO / CEI 14882 Standard C ++.

Answer 2

Avez-vous envisagé de laisser une autre bibliothèque faire le travail lourd?

Il existe Boost.Variant qui le fait probablement ce dont vous avez besoin, entièrement testé, typé et correct, et plutôt efficace.

Ou si vous voulez faire le vôtre, utilisez Boost.TypeTraits

Answer 3

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

Answer 4

Utilisez n'importe quelle variante tierce.

Tous les types de données que vous pouvez trouver en standard.

Answer 5

Vous n'avez besoin de rien savoir 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 soit allouée dynamiquement. Je voulais juste montrer que l’allocation sur place fonctionne aussi, si vous connaissez la taille du type le plus grand.