De facto lista de tipos de primitivas utilizáveis ??em C ++

Question

Se, por exemplo, você está indo para escrever uma classe tipo de variante, você naturalmente terá identificação do que digitar uma instância dessa classe é portador. Eu estou querendo saber se alguém sabe de qualquer (de fato?) De referência oficial ou semi-oficial de todos os tipos de dados primitivos seria possivelmente estar interessado?

Somente primitivos, e sem necessidade de tipos abstratos como string ou alça .

Graças.

Answer 1

A única funcionário de referência é a ISO / IEC 14882 C ++ padrão.

Answer 2

Você já pensou em deixar outra biblioteca fazer o trabalho pesado?

Há Boost.Variant que provavelmente faz o que você precisa, totalmente testado, typesafe e correcta, e bastante eficiente.

Ou se você desejar construir sua própria, uso Boost.TypeTraits

Answer 3

O Google Search é sempre um bom começo. Aqui . Agora, rolo a sua pergunta real.

Answer 4

Use qualquer variante de terceiros.

Todos os tipos de dados que você não pode encontrar em padrão.

Answer 5

Você não precisa saber nada sobre os tipos se você usar 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
}

Note que você pode se livrar de max_size, se você pode aceitar que o valor é alocada dinamicamente. Eu só queria mostrar que no lugar de alocação funciona também, se você sabe o tamanho do maior tipo.