Получение типа на основе строкового литерала

Foo< GetType("A") >::hello( 1, 2);

#include<map>
#include<string>
#include<iostream>
using namespace std;
 
 
// --- интерфейс объектов
struct IFoo
{
    virtual ~IFoo(){}
    virtual void work()const =0;
};
 
 
// --- фабрика умеет биндить символьные имена типов на нативные
struct Factory
{
  struct Base{ virtual IFoo * build()const=0;  };
  
  typedef std::string Str;
  typedef std::map<const Str, Base*> Map;
  typedef Map::const_iterator It;
  typedef Map::value_type ValType;
 
  template<class T> struct Builder : Base
  { 
    IFoo* build()const { return new T; };  
  };
 
    
  // --- данная функция регистрирует в фабрике нативный прототип
  // --- и сопоставляем ему символьное имя
  template<class T> static void reg_class(const Str& key)
  {
      reg().insert( ValType(key, new Builder<T>())  );  
  }
 
  // --- конструирует наследника по его символьному имени
  static IFoo* build(const Str& key) 
  {
      It it = reg().find(key);
      return (it==reg().end())? 0l : it->second->build() ;
  }
private:
  static std::map<const Str, Base*>& reg(){ static Map data; return data; }
 
};
 
 
// --- допустим, это наши возможные наследники
struct Bar0 : IFoo
{
    Bar0(){ cout<<"i am Bar0\n"; }
    virtual void work()const { cout<<"Bar0::work\n"; }
};
struct Bar1 : IFoo
{
    Bar1(){ cout<<"i am Bar1\n"; }
    virtual void work()const { cout<<"Bar1::work\n"; }
};
 
int main()
{
    // --- регистрируем наследников в фабрике
    Factory::reg_class<Bar0>("Bar0");
    Factory::reg_class<Bar1>("Bar1");
    
 
    // --- теперь можно конструировать объекты по их символьному имени
    IFoo* ptr = Factory::build("Bar0");
    ptr->work();
}

static std::map<const Str, Base*>& reg(){ static Map data; return data; }

bool detect(char const *)
{
    return true;
}
 
int detect(wchar_t const *)
{
    return 1;
}

#include <iostream>
 
#define GET_SEQ(str) str[0], str[1]
 
using namespace  std;
 
template<char... args>
struct A {
    using T = int;
};
 
 
template<>
struct A<GET_SEQ("AB")> {
    using T = double;
};
 
template<>
struct A<GET_SEQ("AA")> {
    using T = float;
};
 
int main() {
    cout << typeid(typename A<GET_SEQ("AB")>::T).name() << endl;
    cout << typeid(typename A<GET_SEQ("AA")>::T).name() << endl;
    return 0;
}

constexpr uint32_t ct_hash_suffix(unsigned char c, uint32_t seed)
{
    return static_cast<uint32_t>(c) + 0x9e3779b9u + (seed << 6) + (seed >> 2);
}
 
uint32_t hash_value(std::string const & str)
{
    uint32_t seed = 0;
    for(char c : str)
    {
        seed ^= ct_hash_suffix(c, seed);
    }
    return seed;
}
 
constexpr uint32_t ct_hash(char const * str, uint32_t seed = 0)
{
    return *str ? ct_hash(str + 1, seed ^ ct_hash_suffix(*str, seed)) : seed;
}
 
template <uint32_t id>
struct integer_id {};
 
#define GetType(Str) integer_id<ct_hash(Str)>
 
template <typename T>
void foo()
{}
 
int main() 
{
    foo<GetType("string")>();
}

template<typename C, C ...Chars>
struct ct_string
{ };
 
template <typename CharT, CharT ...Chars>
constexpr auto operator"" _S() 
{
    return ct_string<CharT, Chars...>();
}
 
#define GetType(Str) decltype( Str##_S )
 
template <typename T>
void foo()
{ }
 
int main() 
{
    foo<GetType("string")>();
}