Tengo un vector de atributos que puede contener diferentes tipos:

class base_attribute_vector; // no template args

template<typename T>
class raw_attribute_vector : public base_attribute_vector;

raw_attribute_vector<int> foo;
raw_attribute_vector<std::string> foo;

Basado en la entrada de tiempo de ejecución para el tipo, me gustaría crear la estructura de datos adecuada. Pseudocódigo:

std::string type("int");
raw_attribute_vector<type> foo;

Obviamente, esto falla. Una solución fácil, pero fea e imposible de mantener es un cambio de tiempo de ejecución / encadenado si:

base_attribute_vector *foo;
if(type == "int") foo = new raw_attribute_vector<int>;
else if(type == "string") ...

Leí sobre el polimorfismo en tiempo de ejecución con functors, pero lo encontré bastante complejo para una tarea que es conceptualmente fácil.

¿Cuál es la mejor y más limpia forma de hacer que esto funcione? Jugué conboost::hana, descubriendo que si bien puedo crear una asignación de cadena a tipo, la búsqueda solo se puede hacer en tiempo de compilación:

auto types = 
hana::make_map(
    hana::make_pair(BOOST_HANA_STRING("int"), hana::type_c<int>),
    hana::make_pair(BOOST_HANA_STRING("string"), hana::type_c<std::string>)
);

Todos los tipos posibles son conocidos en tiempo de compilación. Cualquier sugerencia es altamente apreciada. En una solución perfecta, crearía la asignación de nombre-> tipo en un solo lugar. Después, lo usaría así

std::vector<base_attribute_vector*> foo;

foo.push_back(magic::make_templated<raw_attribute_vector, "int">);
foo.push_back(magic::make_templated<raw_attribute_vector, "std::string">);

foo[0]->insert(123);
foo[1]->insert("bla");

foo[0]->print();
foo[1]->print();

No es necesario que esta magia suceda en tiempo de compilación. Mi objetivo es tener un código lo más legible posible.