Modern c++ design 第8章

    Object Factories.

抽象工厂， 基于多态的实现， 面向接口的设计， 为了避免在实现中对具体的派生类的引用。通常使用Object Factories来生成具体对象。

通常的最简单实现方法是， 给Factory传入一个identifyId, 根据id, factory生成一个具体的对象， 返回基类接口。 但是这样的做法， 工厂还是对具体类有依赖， 而且每次加一个新的对象， 都要修改数个文件， 有较强的耦合性。

 用来处理这个问题的办法是： 让工厂维护一个由函数指针构成的集合， 不同的指针生成不同的对象， 需要加入对象的类，只需要在工厂注册自己的id和方法即可。

有了解决方案, 接下来就是泛化这个解决方案了， 思路完全相同， 只是加了几个template参数。 实现如下：

  template
    <
        class AbstractProduct,
        typename IdentifierType,
        typename ProductCreator = AbstractProduct* (*)(),
        template<typename, class>
            class FactoryErrorPolicy = DefaultFactoryError
    >
    class Factory
        : public FactoryErrorPolicy<IdentifierType, AbstractProduct>
    {
    public:
        bool Register(const IdentifierType& id, ProductCreator creator)
        {
            return associations_.insert(
                typename IdToProductMap::value_type(id, creator)).second;
        }
       
        bool Unregister(const IdentifierType& id)
        {
            return associations_.erase(id) == 1;
        }
       
        AbstractProduct* CreateObject(const IdentifierType& id)
        {
            typename IdToProductMap::iterator i = associations_.find(id);
            if (i != associations_.end())
            {
                return (i->second)();
            }
            return this->OnUnknownType(id);
        }
       
    private:
        typedef AssocVector<IdentifierType, ProductCreator> IdToProductMap;
        IdToProductMap associations_;
    };

最后还介绍了一个CloneFactory, 和ObjectFactory很类似， 区别在于CloneFactory依赖typeInfo来找寻Clone函数， 同时函数指针的类型也不同，需要传入一个AbstractProduct对象。 其他基本雷同。如下：

   template
    <
        class AbstractProduct,
        class ProductCreator =
            AbstractProduct* (*)(const AbstractProduct*),
        template<typename, class>
            class FactoryErrorPolicy = DefaultFactoryError
    >
    class CloneFactory
        : public FactoryErrorPolicy<TypeInfo, AbstractProduct>
    {
    public:
        bool Register(const TypeInfo& ti, ProductCreator creator)
        {
            return associations_.insert(
                typename IdToProductMap::value_type(ti, creator)).second;
        }
       
        bool Unregister(const TypeInfo& id)
        {
            return associations_.erase(id) == 1;
        }
       
        AbstractProduct* CreateObject(const AbstractProduct* model)
        {
            if (model == 0) return 0;
           
            typename IdToProductMap::iterator i =
                associations_.find(typeid(*model));
            if (i != associations_.end())
            {
                return (i->second)(model);
            }
            return this->OnUnknownType(typeid(*model));
        }
       
    private:
        typedef AssocVector<TypeInfo, ProductCreator> IdToProductMap;
        IdToProductMap associations_;
    };

当然， Factory一般都是Singleton对象， 可以用前几章介绍的SingletonHolder包装， 一切ok. 省了大量代码， 耦合性也小。

这章重点在于ObjectFactory的概念， 以及如何分离ObjectFactory的需求， 以便将其泛化， 泛化的过程自然解耦。 至于泛化的实现， 相比于泛化的过程， 到显得简单了许多。