工厂模式

动机

• 在软件系统中，经常面临着创建对象的工作，由于需求的变化，需要创建的对象的具体类型经常变化。
• 如何应对这种变化？如何绕开常规的对象创建方法（new），提供一种“封装机制”来避免客户程序和这种“具体对象创建工作”的紧耦合？

  模式定义

  定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟到子类（目的：解耦，手段：虚函数）

  未使用该设计模式

  ```cpp class ISplitter { public: virtual void Split() = 0; virtual ~ISplitter() {} }; class BinarySplitter : public ISplitter { };

class txtSplitter : public ISplitter {

};

class PictureSplitter : public ISplitter {

};

class VideoSplitter : public ISplitter {

};

class MainForm { public: void Button1_Click() { //new BinarySplitter是依赖具体类，违背了依赖倒置原则 ISplitter* splitter = new BinarySplitter(filePath, number);

    splitter.split();
}

};

<a name="lFuk7"></a>
### 实现1
```cpp
class SplitterFactory{
public:
    virtual ISplitter* CreateSplitter() = 0;
    virtual ~SplitterFactory() {}
};
class ISplitter
{
public:
    virtual void Split() = 0;
    virtual ~ISplitter() {}
};
class BinarySplitter : public ISplitter 
{
};
class BinarySplitterFactory : public SplitterFactory
{
public:
    ISplitter* CreateSplitter() {
        return new BinarySplitter();
    }
};
class txtSplitter : public ISplitter
{
};
class txtSplitterFactory : public SplitterFactory
{
public:
    ISplitter* CreateSplitter() {
        return new txtSplitter();
    }
};
class PictureSplitter : public ISplitter
{
};
class PictureSplitterFactory : public SplitterFactory
{
public:
    ISplitter* CreateSplitter() {
        return new PictureSplitter();
    }
};
class VideoSplitter : public ISplitter
{
};
class VideoSplitterFactory : public SplitterFactory
{
public:
    ISplitter* CreateSplitter() {
        return new VideoSplitter();
    }
};
class MainForm
{
    SplitterFactory* factory;
public:
    MainForm(SplitterFactory* factory) {    //根据传入的参数创建不同的工厂
        this->factory = factory;
    }
    void Button1_Click() {
        ISplitter* splitter = factory->CreateSplitter();    //多态new
        splitter.split();
    }
};

面向对象的松耦合设计不是将依赖具体的类给消灭掉，而是实际上将变换赶到某个局部。