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 внезапно начнут совпадать? Использовать другой метод? Тогда лучше на него сразу и переключится.