设计模式---工厂模式（Factory）

 工厂模式（Factory），专门实例化类的对象，隐藏类对象的创建过程。

先看UML图和对应C++代码：

#include <iostream>
using namespace std;

class base
{
    public:
    virtual void foo() = 0;
    virtual ~base(){}
};
class derived1:public base
{
    public:
    void foo()
    {
        cout << "called derived1's foo" << endl;
    }
};
class derived2:public base
{
    public:
    void foo()
    {
        cout << "called derived2's foo" << endl;
    }
};
class derived3:public base
{
    public:
    void foo()
    {
        cout << "called derived3's foo" << endl;
    }
};
class Proxy:public base
{
    public:
    Proxy(base *p):pb(p){}
    void foo()
    {
        pb->foo();
    }
    private:
    base *pb;
};
class Factory
{
    public:
    Factory():pb(NULL){}
    base* Createderived1()
    {
        return pb = new derived1;
    }
    base* Createderived2()
    {
        return pb = new derived2;
    }
    base* Createderived3()
    {
        return pb = new derived3;
    }
    ~Factory()
    {
        if(NULL != pb)
            delete pb;
    }
    private:
    base* pb;
};
class Client
{
    public:
    void Function(Proxy* p)
    {
        p->foo();
    }
};

int main()
{
    Factory mf;
    Proxy mpr(mf.Createderived1());
    Client mc;
    mc.Function(&mpr);
    return 0;
}

这个模式是因为代理模式暴漏了类对象的创建过程，因此在这个不完美的基础上加上工厂模式来隐藏对象的创建过程。

其实就是将具体类的创建交给了一个Factory类的接口来执行。这样客户端就只需要知道一个工厂类和一个代理类就可以完成相应的操作，隐藏了具体的类的所有信息。

从维护的角度来看，只需要去查看这两个类就行

从扩展的角度来看，我只要增加相应的具体类，另外在工厂类里加个相应的接口就行了，修改的地方相对很少。

这就最大程度的遵循了开放封闭的原则。但事实上还不够完美，因为我增加功能要修改工厂类并不是完全遵循开放封闭的原则，如果要做到完全不修改可以考虑反射模式。