Создание класса по имени класса

Вы всегда можете сохранить std::function<Base*()>, поскольку вы всегда возвращаете указатели на Base из вашей функции create:

class Base {};

class DerivedA : public Base {};
class DerivedB : public Base {};
class DerivedC : public Base {};

Base* create(const std::string& type)
{
    static std::map<std::string, std::function<Base*()>> type_creator_map =
    {
        {"DerivedA", [](){return new DerivedA();}},
        {"DerivedB", [](){return new DerivedB();}},
        {"DerivedC", [](){return new DerivedC();}}
    };

    auto it = type_creator_map.find(type);
    if(it != type_creator_map.end())
    {
        return it->second();
    }

    return nullptr;
}

Как предложил Энгью, вы должны возвращать std::unique_ptr вместо необработанных указателей. Если пользователю функции create нужен необработанный указатель или std::shared_ptr, он/она может просто "схватить" необработанный указатель и использовать его.

ОБНОВИТЬ:

Следующий метод обеспечивает удобный полуавтоматический способ регистрации новых типов без изменения старого кода.

Я не рекомендую его использовать, потому что это зависит от компоновщика (момент создания глобальных переменных может быть отложен), от того, как вы компилируете код (исполняемый файл, статическая библиотека, динамическая библиотека), он выделяет память до запуска main() и создает глобальные переменные со странными именами.

Используйте его только в том случае, если вы действительно знаете, что делаете, и знаете, на каких платформах вы используете код!

class Base {};

std::map<std::string, std::function<Base*()>>& get_type_creator_map()
{
    static std::map<std::string, std::function<Base*()>> type_creator_map;
    return type_creator_map;
}

template<typename T>
struct RegisterTypeHelper
{
    RegisterTypeHelper(const std::string& id)
    {
        get_type_creator_map()[id] = [](){return new T();};
    }
};

Base* create(const std::string& type)
{
    auto& type_creator_map = get_type_creator_map();
    auto it = type_creator_map.find(type);
    if(it != type_creator_map.end())
    {
        return it->second();
    }

    return nullptr;
}

#define RegisterType(Type) static RegisterTypeHelper<Type> register_type_global_##Type(#Type)

class DerivedA : public Base {};
RegisterType(DerivedA);

class DerivedB : public Base {};
RegisterType(DerivedB);

class DerivedC : public Base {};
RegisterType(DerivedC);

Один из способов решить эту проблему — использовать шаблон проектирования Prototype.

По сути, вы не будете создавать объекты производного класса путем прямой инициализации, а вместо этого клонируете прототип. Ваша функция create() на самом деле является реализацией шаблона проектирования Factory method. Вы можете использовать Prototype внутри реализации, например:

class Base
{
public:
  virtual ~Base() {}
  virtual Base* clone() = 0;
};

class DerivedA : public Base
{
public:
  virtual DerivedA* clone() override { return new DerivedA; }
};


Base* create(const std::string &name)
{
  static std::map<std::string, Base*> prototypes {
    { "DerivedA", new DerivedA },
    { "DerivedB", new DerivedB },
    { "DerivedC", new DerivedC }
  };
  return prototypes[name]->clone();
}

Проверка ошибок исключена из примера для краткости.

В реальном проекте вы, конечно, должны использовать интеллектуальный указатель (например, std::unique_ptr) вместо необработанных указателей для управления временем жизни объектов.

Я мог бы легко автоматизировать процесс создания карты для получения std::map, но понятия не имею, что хранить в качестве значения.

Вам нужно сохранить фабричный метод в качестве значения, например. статический метод, который создает экземпляр вашего класса:

class Base {};

class DerivedA : public Base {
public:
    static Base* create();

    ...
}

...

Base* DerivedA::create() {
    return new DerivedA();
}

Затем вы можете реализовать имя/поиск через карту, например

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

...

factories["ClassA"] = ClassA::create;

если я создам фабрику, используя эту карту, мне все равно нужно будет написать фабричный метод для каждого типа

Поскольку эти фабричные методы очень просты, вы можете автоматизировать их создание с помощью простого инструмента генерации кода (например, с помощью простого сценария оболочки). Вы можете либо сохранить список классов, либо получить этот список из ваших заголовочных файлов (например, с помощью grepping для ключевого слова class и получить последующее имя класса, или, что еще лучше, с помощью какого-либо инструмента анализа, который правильно анализирует заголовочные файлы).

С помощью этой информации вы можете автоматически создать необходимый код для автоматического добавления фабричных методов в каждый класс. Используя тот же подход, вы также можете сгенерировать функцию регистрации, которую нужно вызвать один раз, чтобы ваши объекты были зарегистрированы.