Существует ли способ инстанцировать объектов от строки, содержащей их имя класса?

Нет, нет ни одного, если Вы не делаете отображение себя. C++ не имеет никакого механизма для создания объектов, типы которых определяются во времени выполнения. Можно использовать карту, чтобы сделать то отображение себя, хотя:

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>;

И затем можно сделать

return map[some_string]();

Получение нового экземпляра. Другая идея состоит в том, чтобы иметь регистр типов themself:

// 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");

Вы могли решить создать макрос для регистрации

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

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

, я уверен, что существуют лучшие названия тех двух все же. Другая вещь, которая, вероятно, имеет смысл использовать здесь, shared_ptr.

, Если у Вас есть ряд несвязанных типов, которые не имеют никакого общего базового класса, можно дать указателю функции тип возврата boost::variant<A, B, C, D, ...> вместо этого. Как то, если у Вас есть класс Нечто, Панель и Baz, это похоже на это:

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;

А boost::variant похож на объединение. Это знает, какой тип хранится в нем путем взгляда, какой объект использовался для инициализации или присвоения ей. Взгляните на его документацию здесь . Наконец, использование необработанного указателя функции является также немного староватым. Современный код C++ должен быть разъединен от определенных функций / типы. Можно хотеть изучить Boost.Function для поиска лучшего пути. Это было бы похоже на это тогда (карта):

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

std::function будет доступно в следующей версии C++ также, включая [1 111].