¿Hay alguna manera de crear instancias de objetos a partir de una cadena que contenga su nombre de clase?

No, no hay ninguno, a menos que hagas el mapeo tú mismo. C++ no tiene ningún mecanismo para crear objetos cuyos tipos se determinen en tiempo de ejecución. Sin embargo, puedes usar un mapa para hacer ese mapeo tú mismo:

template<typename T> Base * createInstance() { return new T; }

typedef std::map<std::string, Base*(*)()> map_type;

map_type map;
map["DerivedA"] = &createInstance<DerivedA>;
map["DerivedB"] = &createInstance<DerivedB>;

Y luego puedes hacer

return map[some_string]();

Obteniendo una nueva instancia. Otra idea es que los tipos se registren solos:

// in base.hpp:
template<typename T> Base * createT() { return new T; }

struct BaseFactory {
    typedef std::map<std::string, Base*(*)()> map_type;

    static Base * createInstance(std::string const& s) {
        map_type::iterator it = getMap()->find(s);
        if(it == getMap()->end())
            return 0;
        return it->second();
    }

protected:
    static map_type * getMap() {
        // never delete'ed. (exist until program termination)
        // because we can't guarantee correct destruction order 
        if(!map) { map = new map_type; } 
        return map; 
    }

private:
    static map_type * map;
};

template<typename T>
struct DerivedRegister : BaseFactory { 
    DerivedRegister(std::string const& s) { 
        getMap()->insert(std::make_pair(s, &createT<T>));
    }
};

// in derivedb.hpp
class DerivedB {
    ...;
private:
    static DerivedRegister<DerivedB> reg;
};

// in derivedb.cpp:
DerivedRegister<DerivedB> DerivedB::reg("DerivedB");

Podrías decidir crear una macro para el registro.

#define REGISTER_DEC_TYPE(NAME) \
    static DerivedRegister<NAME> reg

#define REGISTER_DEF_TYPE(NAME) \
    DerivedRegister<NAME> NAME::reg(#NAME)

Aunque estoy seguro de que hay mejores nombres para esos dos. Otra cosa que probablemente tenga sentido usar aquí es shared_ptr.

Si tiene un conjunto de tipos no relacionados que no tienen una clase base común, puede darle al puntero de función un tipo de retorno de boost::variant<A, B, C, D, ...>. Si tienes una clase Foo, Bar y Baz, se ve así:

typedef boost::variant<Foo, Bar, Baz> variant_type;
template<typename T> variant_type createInstance() { 
    return variant_type(T()); 
}

typedef std::map<std::string, variant_type (*)()> map_type;

A boost::variantes como una unión. Sabe qué tipo está almacenado en él al observar qué objeto se usó para inicializarlo o asignarle. Echa un vistazo a su documentación aquí . Finalmente, el uso de un puntero de función sin formato también es un poco anticuado. El código C++ moderno debe estar desacoplado de funciones/tipos específicos. Es posible que desee investigar Boost.Functionpara buscar una mejor manera. Entonces quedaría así (el mapa):

typedef std::map<std::string, boost::function<variant_type()> > map_type;

std::functionTambién estará disponible en la próxima versión de C++, incluido std::shared_ptr.

Feb 24 '2009 16:02 Johannes Schaub - litb