Создание классов по имени с помощью шаблона factory

Предположим, что у меня есть список классов A, B, C, ..., которые все наследуют от Base.

Я получаю имя класса как строку от пользователя, и я хочу создать экземпляр правильного класса и вернуть указатель на Base. Как вы это реализуете?

Я подумал о том, чтобы использовать хеш-таблицу с именем класса в качестве ключа и указатель функции к функции, создающей правильный класс и возвращающий Base *.

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

ОТВЕТЫ

Ответ 1

Вот общий factory пример:

template<class Interface, class KeyT=std::string>
struct Factory {
    typedef KeyT Key;
    typedef std::auto_ptr<Interface> Type;
    typedef Type (*Creator)();

    bool define(Key const& key, Creator v) {
        // Define key -> v relationship, return whether this is a new key.
        return _registry.insert(typename Registry::value_type(key, v)).second;
    }
    Type create(Key const& key) {
        typename Registry::const_iterator i = _registry.find(key);
        if (i == _registry.end()) {
            throw std::invalid_argument(std::string(__PRETTY_FUNCTION__) +
                                        ": key not registered");
        }
        else return i->second();
    }

    template<class Base, class Actual>
    static
    std::auto_ptr<Base> create_func() {
        return std::auto_ptr<Base>(new Actual());
    }

private:
    typedef std::map<Key, Creator> Registry;
    Registry _registry;
};

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

Здесь простой пример factory:

struct Base {
    typedef ::Factory<Base> Factory;
    virtual ~Base() {}
    virtual int answer() const = 0;

    static Factory::Type create(Factory::Key const& name) {
        return _factory.create(name);
    }
    template<class Derived>
    static void define(Factory::Key const& name) {
        bool new_key = _factory.define(name,
            &Factory::template create_func<Base, Derived>);
        if (not new_key) {
            throw std::logic_error(std::string(__PRETTY_FUNCTION__) +
                                   ": name already registered");
        }
    }

private:
    static Factory _factory;
};
Base::Factory Base::_factory;

struct A : Base {
    virtual int answer() const { return 42; }
};

int main() {
    Base::define<A>("A");
    assert(Base::create("A")->answer() == 42);
    return 0;
}

Ответ 2

самый быстрый, но очень полезный способ во многих областях, будет что-то вроде

Base* MyFactoryMethod( const std::string& sClass ) const
{
  if( sClass == "A" )
    return CreateNewA();
  else if( sClass == "B" )
    return new CreateClassB();
  //....
  return 0;
}

A* CreateClassA() const
{
  return new A();
}

Ответ 3

Вы также можете изучить версию Boost factory.

  • Если есть только несколько производных классов, вы можете использовать список "if, else".
  • Если вы планируете иметь много производных классов, лучше отсортировать процесс регистрации класса (как упоминалось Georg), чем использовать список "if, else".

Вот простой пример использования метода Boost factory и регистрации класса:

typedef boost::function<Parent*()> factory;

// ...

std::map<std::string, factory> factories;

// Register derived classes
factories["Child1"] = boost::factory<Child1*>();
factories["Child2"] = boost::factory<Child2*>();

// ...

// Instantiate chosen derived class
auto_ptr<Parent> pChild = auto_ptr<Parent>(factories["Child1"]());

Ответ 4

Прежде всего, да, это именно то, для чего предназначен шаблон factory.
(Кстати, ваша другая идея - возможная реализация шаблона factory)

Если вы намереваетесь сделать это для большого проекта (если нет, просто выберите stijns answer), вы можете захотеть использовать ассоциативный контейнер где-нибудь вместо явное ветвление и, возможно, даже перенос ответственности регистрации в классы на

  • избегать изменений кода в одном дополнительном месте (ваш factory)
  • и, в свою очередь, избегать, возможно, очень длительных периодов перекомпиляции (для in-header-реализаций) при добавлении класса

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