template<class T>
void foo(T & val, typename std::enable_if< is_simple_type<T>::value>::type* = 0 )
{
}

template <typename T>
static uint32_t hash()
{
    static const uint32_t index = ++last_added_;
    return index;
}

// Example

typedef vector<char,int,unsigned,long,unsigned long> types;
typedef find<types,unsigned>::type iter;

BOOST_MPL_ASSERT(( is_same< deref<iter>::type, unsigned > ));
BOOST_MPL_ASSERT_RELATION( iter::pos::value, ==, 2 );

 template<class T>
XC>void foo(T & val, typename std::enable_if< is_simple_type<T>::value>::type* = 0 )
XC>{
XC>}

#include <iostream>
#include <type_traits>

int GetId()
{
  static int id = 0;
  id++;
  return id;
}

template <class T>
struct TypeId
{
  typedef T type;
  static const int id;
};


template <class T>
struct TypeId<T*>
{
  typedef T* type;
  static const int id = -1;
};


//static 
template <class T>
const int TypeId<T>::id = GetId();


class A
{
};

class B
{
};


class C
{
  public:
    C()
    {
      std::cout << "id of this for C = "   << TypeId<std::remove_pointer<decltype(this)>::type>::id   << std::endl;
    }
};


template<class T>
void foo(T & val)
{
    std::cout << "foo, id of T = " << TypeId<T>::id << std::endl;
}


int main(int argc, char* argv[])
{
    int n = 0;
    foo(n);
    int* pn = &n;
    foo(pn);
    char ch = 'a';
    foo(ch);
    char* pch = &ch;
    foo(pch);


    std::cout << "id of A = "    << TypeId<A>::id    << std::endl;
    std::cout << "id of C = "    << TypeId<C>::id    << std::endl;
    std::cout << "id of A = "    << TypeId<A>::id    << std::endl;
    std::cout << "id of B = "    << TypeId<B>::id    << std::endl;
    std::cout << "id of C = "    << TypeId<C>::id    << std::endl;
    std::cout << "id of int = "  << TypeId<int>::id  << std::endl;
    std::cout << "id of int* = " << TypeId<int*>::id << std::endl;
    std::cout << "id of A* = "   << TypeId<A*>::id   << std::endl;

    return 0;
}

Remark: an implementation should return different values for two type_info objects which do not compare equal.

W>Конечно, для ограниченного множества типов можно проверить, что hash_code попарно не совпадают (например у типов signed и unsigned ), и если это так, то использовать этот метод. Но что программа должна будет делать, hash_code внезапно начнут совпадать? Использовать другой метод? Тогда лучше на него сразу и переключится.

enum FType { zerro, one, two };

#include <tuple>
#include <iostream>

int main(void)
{
    std::tuple<char, int, float> x { 'a', 12345, 3.14f };
    std::cout << std::get<0>(x) << std::endl;
    std::cout << std::get<1>(x) << std::endl;
    std::cout << std::get<2>(x) << std::endl;
}

#include <tuple>
#include <iostream>

int main(void)
{
    std::tuple<char, int, float> x { 'a', 12345, 3.14f };
    std::cout << std::get<char>(x) << std::endl;
    std::cout << std::get<int>(x) << std::endl;
    std::cout << std::get<float>(x) << std::endl;
}

E>Я могу сделать такой же нешаблонный, где нигде тип int использоваться не будет...

E>Это утверждение более чем спорное...

enum FType { zerro, one, two };

E>Этот не использует...

An enumeration is a distinct type whose value is restricted to a range of values (see below for details), which may include several explicitly named constants ("enumerators"). The values of the constants are values of an integral type known as the underlying type of the enumeration.
cppreference.com/enumeration declaration

E>Ну и нет проблем через трится "фунламентальным" типам ID назначить...

там же начнется головная боль с алиазами (считать uint8_t и char псевдонимами друг друга или нет?). да и зачем меня нагружать этой рутиной, когда могли бы в тайптрейтс (если это так просто) засунуть?

E>>Да, это тип для работы с числами, такой же как short, наример. Чем он менее "фундаментальный" чем short?

enum { start = 0, end = 10000 };

__>ага, а как же unsigned char и signed char, uint8_t, int8_t, short и прочие. вы уверены, что они все будут разные типы на всех платформах?

#include <tuple>
#include <string>
#include <cstdint>
#include <iostream>

int main(void)
{
    using namespace std;
    tuple<int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t,
        bool, signed char, unsigned char, signed short, unsigned short, signed int, unsigned int,
        signed long, unsigned long, signed long long, unsigned long long, string> x
    { 'a', 'b', 3, 4, 5, 6, 7, 8, true, 'c', 'd', 12, 13u, 14, 15u, 16l, 17ul, 18ll, 19ull, "abcde"s };
    cout << get<0>(x) << ' ' << get<1>(x) << ' ' << get<2>(x) << ' ' << get<3>(x) << ' '
        << get<4>(x) << ' ' << get<5>(x) << ' ' << get<6>(x) << ' ' << get<7>(x) << ' '
        << get<8>(x) << ' ' << get<9>(x) << ' ' << get<10>(x) << ' ' << get<11>(x) << ' '
        << get<12>(x) << ' ' << get<13>(x) << ' ' << get<14>(x) << ' ' << get<15>(x) << ' '
        << get<16>(x) << ' ' << get<17>(x) << ' ' << get<18>(x) << ' ' << get<19>(x) << endl;
}

E>>>Да, это тип для работы с числами, такой же как short, наример. Чем он менее "фундаментальный" чем short?

enum { start = 0, end = 10000 };

E>И то и то поддерживается процессором, и то и то числа, поддиапазон int, и то и то занимает 2 байта...

E>И что? Это шаблонной магии не мешает..

E>Тогда я совсем не понимаю, что ты называешь "фундаментальный"...

Objects, references, functions including function template specializations, and expressions have a property called type, which both restricts the operations that are permitted for those entities and provides semantic meaning to the otherwise generic sequences of bits.

тип = множество значений + множество допустимых операций над этими значениями (включая оперирование с бинарным представлением)

фундаментальным (в моем понимании) называется тип, определение которого не опирается на существование и свойства других типов.

E>Псевдоним у тебя фундаментальный, а enum нет?

E>Ну это фигня. Легко делается. Вот если ты ещё потребуешь, что бы если номер разнй, то будут вести по-разному, то будет хуже...

__>>ага, а как же unsigned char и signed char, uint8_t, int8_t, short и прочие. вы уверены, что они все будут разные типы на всех платформах?

T>Уверен:

T>#include <tuple>
T>#include <string>
T>#include <cstdint>
T>#include <iostream>

T>int main(void)
T>{
T>    using namespace std;
T>    tuple<int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t,
T>        bool, signed char, unsigned char, signed short, unsigned short, signed int, unsigned int,
T>        signed long, unsigned long, signed long long, unsigned long long, string> x
T>    { 'a', 'b', 3, 4, 5, 6, 7, 8, true, 'c', 'd', 12, 13u, 14, 15u, 16l, 17ul, 18ll, 19ull, "abcde"s };
T>    cout << get<0>(x) << ' ' << get<1>(x) << ' ' << get<2>(x) << ' ' << get<3>(x) << ' '
T>        << get<4>(x) << ' ' << get<5>(x) << ' ' << get<6>(x) << ' ' << get<7>(x) << ' '
T>        << get<8>(x) << ' ' << get<9>(x) << ' ' << get<10>(x) << ' ' << get<11>(x) << ' '
T>        << get<12>(x) << ' ' << get<13>(x) << ' ' << get<14>(x) << ' ' << get<15>(x) << ' '
T>        << get<16>(x) << ' ' << get<17>(x) << ' ' << get<18>(x) << ' ' << get<19>(x) << endl;
T>}
T>

cplusplus.com/reference/cstdint
<cstdint> (stdint.h)
Types
The following are typedefs of fundamental integral types or extended integral types.

E>Ну делаешь mpl-массив из всех фундаментальных типов с их псевдонимами, и что бы узнать id типа просто ищешь его в этом массиве и его индекс и есть id. А если не нашёл, то тип не фундаментальный...

E>Ну это если в качестве PoC на бусте сваять, можно чуть компактнее, конечно, ту же идею реализовать...

get_fundamental_type_id(type)

cast_to_fundamental_type(fundamental_type_id, val)

cast_to_fundamental_type(fundamental_type_id, val)

__>cast_to_fundamental_type(fundamental_type_id, val)
__>

#include <iostream>

template<int id> 
struct IdToType
{
    typedef void type;
    static const int s_nTypeId = -1;
};


template<class T> 
struct TypeToId
{
    typedef T type;
    static const int s_nTypeId = -1;
};


template<> struct IdToType<1>    {typedef int   type; static const int s_nTypeId = 1;};
template<> struct TypeToId<int>  {typedef int   type; static const int s_nTypeId = 1;};
                                                
template<> struct IdToType<2>    {typedef char  type; static const int s_nTypeId = 2;};
template<> struct TypeToId<char> {typedef char  type; static const int s_nTypeId = 2;};
                                 
template<> struct IdToType<3>    {typedef short type; static const int s_nTypeId = 3;};
template<> struct TypeToId<short>{typedef short type; static const int s_nTypeId = 3;};

template<> struct IdToType<4>    {typedef float type; static const int s_nTypeId = 4;};
template<> struct TypeToId<float>{typedef float type; static const int s_nTypeId = 4;};


int main(int argc, char* argv[])
{
    std::cout << "id of int = "   << TypeToId<int>::s_nTypeId   << std::endl;
    std::cout << "id of float = " << TypeToId<float>::s_nTypeId << std::endl;

    float f = 97.234f;
    IdToType<1>::type n = static_cast<IdToType<1>::type>(f);

    std::cout << "n = " << n << std::endl;

    auto ch = static_cast<IdToType<TypeToId<char>::s_nTypeId>::type>(f);
    std::cout << "ch = " << ch << std::endl;

    return 0;
}

fundamental_type_to_id<uint64t>::id;
fundamental_id_to_type<15>::type;

fundamental_type_to_id<uint64t>::id;
E>fundamental_id_to_type<15>::type;

class Variant
{
  int m_type_id;
  char m_buff[8];

public:
  //------------------------
  Variant():m_type_id(-1){}
  //------------------------
  template<typename T>
  void setVal(T val)
  {
     m_type_id = get_fundamental_type_id<T>();
     *reinterpret_cast<T*>(m_Buffer) = val;
  }
  //------------------------
  template<typename T>
  bool is(void)const
  {
     return get_fundamental_type_id<T>() == m_type_id;
  }
  //------------------------
  template<typename T>
  T get_casted_val()
  {
     return cast_to_fundamental_type(m_type_id, m_buff);
  }
  //------------------------
}