ファクトリパターンを使用した名前によるクラスのインスタンス化

A, B, C, ...すべてがから継承するクラスのリストがあるとしBaseます。

ユーザーからクラス名を文字列として取得し、適切なクラスをインスタンス化して、へのポインターを返したいと思いますBase。これをどのように実装しますか？

クラス名をキーとするハッシュテーブルと、適切なクラスをインスタンス化してを返す関数への関数ポインターを使用することを考えましたBase *。

ただ、ここでファクトリパターンを使えばもっと楽になるかもしれないと思いますが、よく覚えていないので、提案をお願いしたいと思います。

一般的なファクトリの実装例を次に示します。

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

これは、すべての状況で最適であることを意味するわけではありませんが、最初の概算であり、前述のタイプの関数stijnを手動で実装するよりも便利なデフォルトであることが意図されています。各階層がそれ自体を登録する方法はFactoryによって義務付けられていませんが、前述のメソッドgfが好きかもしれません（これはシンプルで明確、そして非常に便利です。そうです、これはこの場合のマクロに固有の問題を克服します）。

ここだ簡単な例工場のは：

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

多くの分野で最も速くて非常に使いやすい方法は、次のようなものになります

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();
}

Boostクラスのファクトリ実装を調べることもできます。

• 派生クラスが少ない場合は、「if、else」リストを使用できます。
• 多くの派生クラスを計画している場合は、「if、else」リストを使用するよりも、クラス登録プロセスを整理することをお勧めします（Georgが述べたように）。

Boostファクトリメソッドとクラス登録を使用した簡単な例を次に示します。

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"]());

まず、はい、それがファクトリパターンの目的です。
（ちなみに、あなたの他のアイデアはファクトリパターンの可能な実装です）

大規模なプロジェクトでこれを行う場合（そうでない場合は、stijns answerを使用してください）、明示的な分岐の代わりに連想コンテナをどこかに使用し、登録責任をクラスに移動することを検討することをお勧めします。

• 1つの追加の場所（工場）でのコード変更を回避する
• そして次に、クラスを追加するときに、（ヘッダー内の実装の場合）非常に長い再コンパイル時間を回避します。

クラスへの便利な登録を実現するには、この提案のようなものを使用して、派生クラスをインスタンス化し、ベースへのポインターを返すエントリに関数ポインターまたはファンクターを追加します。
マクロを恐れていない場合は、宣言に1つの小さなマクロを追加するだけで、ファクトリにクラスを追加できます。