工厂模式：封装对象的创建（二、多态工厂）

在上篇中，静态成员函数  static Shape* factory(const string& type) 迫使所有创建对象的操作都集中在一个地方，

因此这个地方就是唯一需要修改代码的地方。这是一个合理的决解方法，因为它完美的封装了对象的创建过程。

但是工厂方法模式——可以使不同类型的的工厂派生自基本类型的工厂。工厂方法事实上就是多态工厂模式的一个特例。

所以下面例子是——工厂方法模式做为一个单独的类中的虚函数出现。

#include <stdexcept>
#include <cstddef>
#include <string>
#include <vector>
#include <algorithm>
#include <iostream>


using namespace std;


template<class Seq> void purge(Seq& c)  
{
    typename Seq::iterator i;
    for(i = c.begin(); i != c.end(); ++i) 
    {   
        delete *i; 
        *i = 0;
    }   
}


// Iterator version:
template<class InpIt> void purge(InpIt begin, InpIt end) 
{
    while(begin != end) 
    {   
        delete *begin;
        *begin = 0;
        ++begin;
    }   
}


class Shape
{
public:
    virtual void draw() = 0;
    virtual void erase() = 0;
    virtual ~Shape() {}
};




class ShapeFactory 
{
    virtual Shape* create() = 0;
    static map< string , ShapeFactory* > factories;
public:
    virtual ~ShapeFactory(){}
    friend class ShapeFactoryInitializer;
    class BadShapeCreation : public logic_error
    {   
    public:
        BadShapeCreation(string type): logic_error("Cannot create type " + type) {}
    };  


    static Shape * createShape(const string& id) throw(BadShapeCreation)
    {   
        if(factories.find(id) != factories.end())
            return factories[id]->create();
        else
            throw BadShapeCreation(id);
    }   


};

//define static object
map< string , ShapeFactory* > ShapeFactory::factories;




class Circle : public Shape 
{
    Circle() {} // Private constructor
    friend class ShapeFactoryInitializer;
    class Factory;
    friend class Factory;
    class Factory:public ShapeFactory
    {
        public:
            Shape* create()
            {
                return new Circle;
            }
            friend class ShapeFactoryInitializer;
    };
public:
    void draw()
    {
        cout << "Circle::draw" << endl;
    }
    void erase()
    {
        cout << "Circle::erase" << endl;
    }


    ~Circle()
    {
        cout << "Circle::~Circle" << endl;
    }
};

class Square : public Shape 
{
    Square() {}
    friend class ShapeFactoryInitializer;
    class Factory;
    friend class Factory;
    class Factory:public ShapeFactory
    {
        public:
            Shape* create()
            {
                return new Square;
            }
            friend class ShapeFactoryInitializer;
    };
public:
    void draw()
    {
        cout << "Square::draw" << endl;
    }
    void erase()
    {
        cout << "Square::erase" << endl;
    }
    ~Square()
    {
        cout << "Square::~Square" << endl;
    }
};


//Singleton to initialize the ShapeFactory
class ShapeFactoryInitializer
{
    static ShapeFactoryInitializer si;
    ShapeFactoryInitializer()
    {
        ShapeFactory::factories["Circle"]=new Circle::Factory;
        ShapeFactory::factories["Square"]=new Square::Factory;
    }
    ~ShapeFactoryInitializer()
    {
        map<string,ShapeFactory*>::iterator it=ShapeFactory::factories.begin();
        while(it!=ShapeFactory::factories.end())
            delete it++->second;
    }
};

//static member definition
ShapeFactoryInitializer ShapeFactoryInitializer::si;




char* sl[] = { "Circle", "Square", "Square","Circle", "Circle", "Circle", "Square"};




int main()
{


    vector<Shape*> shapes;
    try {
        for(size_t i = 0; i < sizeof sl / sizeof sl[0]; i++)
            shapes.push_back(ShapeFactory::createShape(sl[i]));
    } catch(ShapeFactory::BadShapeCreation e)
    {
        cout << e.what() << endl;


        return -1;
    }
    for(size_t i = 0; i < shapes.size(); i++)
    {
        shapes[i]->draw();
        shapes[i]->erase();
    }
    purge(shapes);
}

工厂方法模式作为virtual create() 出现在它自己的 ShapeFactory 类中，这是一个私有的成员函数。意味着不能直接调用它，但是可以被覆盖。

Shape 的子类必须创建各自的 ShapeFactory子类，并且覆盖成员函数 create（）以创建其自身类型的对象。

这些工厂是私有的，只能被工厂方法模式访问。采用这种方法的所有客户代码都必须通过工厂方法模式创建对象。

Shape对象的实际创建是通过调用ShapeFactory::createShape() 完成对的，这是一个静态成员函数，

使用ShapeFactory 中的map 根据传递给它的标识符找到相应的工厂对象。

工厂直接创建Shape 对象，但是可以设想一个更为复杂的问题：在某个地方返回一个合适的工厂对象。然后该工厂对象被调用者用于以更复杂的方法创建一个对象。

然而，似乎在大多数情况下不需要这么复杂地使用多态工厂方法模式。

注意，ShapeFactory 必须通过装载它的map 与工厂对象进行初始化，这些操作发生在单例ShapeFactoryInitializer, 以便将工厂的一个实例插入到map中。

这些额外的复杂的操作再次暗示，如果不需要创建独立的工厂对象，应该尽可能使用静态（static）工厂方法模式