【背景】在软件系统中，经常面临着创建对象的工作。但由于需求的变化，所创建对象的具体类型经常变化。

  1. 如何应对这种变化？
  2. 如何绕过常规的对象创建方法（new），提供一种“封装机制”来避免客户程序和这种“具体对象创建工作”的紧耦合？

    引言

    看一个实例，和它在软件工程中的演化过程。

    原始版本：文件分割器

    ```cpp class FileSplitter { //文件分割器 public: void split() { //核心行为：分割
    1.  //...
    } }

class MainForm : public Form { TextBox txtFilePath; TextBox txtFileNumber; ProgressBar* progressBar;

public: void Button1_Click() { string filePath = txtFilePath->getText(); int number = atoi(txtFileNumber->getText().c_str());

  1.     FileSplitter* splitter = new FileSplitter(filePath, number);
  2.     splitter->split();
  3. }

}

  1. 这是一个很正常的对象使用模式。它有什么问题呢？单独看是看不出问题的。但在需求变化的角度，就能看出一点蛛丝马迹。
  3. <a name="5W4n6"></a>
  4. #### 迭代一：评估需求变化，并抽象出基类
  5. 【评估需求变化】当然你要先评估有没有需求的变化<br />假设目前FileSplitter只支持二进制文件的分割。但是，未来可能会去支持文本文件的分割，图片文件的分割，或者视频文件的分割等等。
  7. 【抽象出基类】当你想到这些变化的时候，你就需要抽象出你的基类
  8. ```cpp
  9. class ISplitter{ //考虑到未来有其他的分割类，这里抽象出一个分割基类
  10. public:
  11.     virtual void split() = 0;
  12.     virtual ~ISplitter() {} 
  13.     //保证资源释放安全性，需要写一个虚析构函数，以便子类能够正常释放
  14. }
  16. class BinarySplitter : public ISplitter{
  17. };
  19. class TxtSplitter: public ISplitter{
  20. };
  22. class PictureSplitter: public ISplitter{
  23. };
  25. class VideoSplitter: public ISplitter{
  26. };
  28. //使用时，即要申明成接口
  29. class MainForm : public Form {
  30.     //...
  31.     void Button1_Click() {
  32.         //...
  33.         //面向接口编程最直接的表示形式就是：变量要申明为抽象基类
  34.         ISplitter* splitter = 
  35.             new BinarySplitter(); //那new后面怎么办呢？这里还是依赖了具体的类
  36.                                   //MainForm编译时，还需要#include"BinarySplitter.h"
  37.         splitter->split();
  38.     }
  39. }

迭代二：去除new带来的细节依赖

【思考】ISplitter* splitter = new ISplitter();这样解决可以吗？
这样解决也不行。ISplitter()是一个抽象类，是不能被new出来的。

【自定义方法来创建】new可以当成一个方法，但是此时new解决不了我们的问题。那我们是不是可以自定义一个方法？来返回一个对象。而此即是工厂设计模式的一个思想。

  1. //SplitterFactory
  2. class SplitterFactory{    //通过一个工厂类，把new的工作抽象出来，由它负责
  3. public:
  4.     ISplitter* CreateSplitter() { 
  5.         return new BinarySplitter(); //创建Splitter对象
  6.     }
  7. }
  9. //MainForm
  10. SplitterFactory factory;
  11. ISplitter* splitter = factory.CreateSplitter();

虽然这样做，很像是把创建的工作抽了出来，很像是有所改善。
但这个问题还没有解决，SplitterFactory依赖BinarySplitter，MainForm依赖SplitterFactory。因此，最后MainForm也要依赖BinarySplitter
也就是你抽离了一层，还是没有把这个问题完全抽象出来。

【思考】

  1. 上面是编译式依赖：即在编译的时候，你需要告诉MainForm SplitterFactory是什么；要告诉SplitterFactory BinarySplitter是什么，不然编译会通不过，它认为这是一个不完整类型
  2. C++中什么是运行时依赖呢？答案是virutal虚函数

【虚函数】

  1. 编译的时候，我们会检查某个类、某个函数的具体实现在哪里（即程序员是否实现了这个类和这个函数）
  2. 但是虚函数会把检查这个动作延迟，延迟到程序运行的时候（即运行时），才根据具体的情况找这个函数的具体实现在哪里，也就是说：下面这段代码编译是可以通过的。

如此，我们可以用virtual虚函数来解决这个问题。

  1. #include<iostream>
  3. using namespace std;
  5. //抽象类
  6. class ISplitter
  7. {
  8. public:
  9.     virtual void split() = 0;
  10.     virtual ~ISplitter() {}
  11. };
  13. //工厂基类
  14. class SplitterFactory
  15. {
  16. public:
  17.     virtual ISplitter* CreateSplitter()
  18.     {
  19.         return nullptr;
  20.     }
  21.     virtual ~SplitterFactory() {}
  22. };
  24. int main()
  25. {
  26.     SplitterFactory factory;
  27.     ISplitter* splitter = factory.CreateSplitter();
  29.     return 0;
  30. }

附：纯需函数的情况也是一样，将检查放到的了运行时

  1. //工厂基类
  2. class SplitterFactory
  3. {
  4. public:
  5.     virtual ISplitter* CreateSplitter() = 0; //如果是纯虚函数，编译也可通过。这也证明了虚函数是一种延迟检查的策略
  6.     virtual ~SplitterFactory() {}
  7. };
  9. //MainForm中使用
  10. SplitterFactory* factory; 
  11. ISplitter* splitter = factory->CreateSplitter();
  12.     //SplitterFactory是一个纯虚基类，应该用指针的方式来使用

最终版本：工厂模式

  1. 抽象类、抽象工厂 ```cpp //抽象类 class ISplitter{ //分割器 public: virtual void split()=0; //接口 virtual ~ISplitter(){} //让子类 };

//工厂基类 class SplitterFactory{ public: virtual ISplitter* CreateSplitter()=0; virtual ~SplitterFactory(){} };

  2. 2. 具体类、具体工厂
  3. ```cpp
  4. //具体类
  5. class BinarySplitter : public ISplitter{ //二进制分割器
  6. };
  8. class TxtSplitter: public ISplitter{    //文本分割器
  9. };
  11. class PictureSplitter: public ISplitter{    //图片分割器
  12. };
  14. class VideoSplitter: public ISplitter{    //音频分割器
  15. };
  17. //具体工厂
  18. class BinarySplitterFactory: public SplitterFactory{
  19. public:
  20.     virtual ISplitter* CreateSplitter(){
  21.         return new BinarySplitter();
  22.     }
  23. };
  25. class TxtSplitterFactory: public SplitterFactory{
  26. public:
  27.     virtual ISplitter* CreateSplitter(){
  28.         return new TxtSplitter();
  29.     }
  30. };
  32. class PictureSplitterFactory: public SplitterFactory{
  33. public:
  34.     virtual ISplitter* CreateSplitter(){
  35.         return new PictureSplitter();
  36.     }
  37. };
  39. class VideoSplitterFactory: public SplitterFactory{
  40. public:
  41.     virtual ISplitter* CreateSplitter(){
  42.         return new VideoSplitter();
  43.     }
  44. };
  1. 应用层：这里要注意，不能写成具体的类，不然还是违背了上面的两种思想。我们应该从外界传进来 ```cpp class MainForm : public Form { SplitterFactory* factory; //只需要一个抽象工厂

public: //通过外界传递进来一个factory //在未来传递一个具体的factory，而不是现在直接指定是哪个具体的factory MainForm(SplitterFactory* factory){ this->factory=factory; }

  1. void Button1_Click(){
  2.     ISplitter * splitter = factory->CreateSplitter(); //多态new
  3.     splitter->split();
  4. }

};

  2. 4. 未来使用
  3. ```cpp
  4. #include"PictureSplitter.h" //加入具体的类
  6. SplitterFactory* factory = new PictureSplitterFactory(); //图片工厂
  7. MainForm form(factory);
  8. form.show();

总结

  1. C++的new没有提供多态的机制，我们可以用虚函数来解决多态创建问题（设计模式是不是也叫“虚函数用法举例”？）
  2. 通过工厂设计模式，MainForm没有和具体的Splitter产生依赖。将依赖放到了未来，未来的某个文件中是需要依赖具体的Splitter的。
  3. 设计模式（or面向对象的松耦合设计）实际上呢，并不是把变化消灭掉，并不是把依赖具体类的这个事情消灭掉了，而是把他们赶到一个局部的地方。举个例子：把变化当成一只猫，我们是把猫关到笼子里，而不是让它在你的代码里跳来跳去。
    面向接口编程
    面向接口编程要求我们，一个对象的类型往往应该申明成抽象类或接口，而不应该申明为具体的类。如果你申明为具体的类，你是没有支持未来的变化的，毕竟你已经把对象的类型定死了。 ```cpp //申明为具体的类：线段Segment Segment seg = new Segment(); //如果之后这个变量要改为Line类型，则需要改为Line line = new Line(); //并且下面使用的方法也需要更改，改动特别大！

//申明为抽象类或接口：抽象类Geometry Geometry geom = new Segment(); //如果之后这个变量要改为Line类型，直接改为Geometry geom = new Line(); //下面的方法就不用改了，可以多态调用

  1. 但其实从`Geometry* geom = new Segment()`可以看出，虽然Geometry*是抽象的，但是Segment还是一个具体类型。这其实也解决不了问题，还是需要更改代码。由此工厂模式应运而生。
  2. <a name="zKPYW"></a>
  3. ##### 依赖倒置原则
  4. 【依赖倒置原则】依赖倒置要求我们应该去依赖抽象，而不应该去依赖实现细节。
  6. 1. `ISplitter* splitter`已经变成**抽象依赖**了，已经是编译式依赖
  7. 1. 但是`new BinarySplitter()`还是一个**细节依赖**，如此也解决不了问题，也打破了依赖倒置原则
  9. 问题所在：`MainForm`在编译的时候，也需要知道`BinarySplitter`存在，才能编译通过。即这还是紧耦合，还是一个编译式的细节依赖，还需要`#include<BinarySplitter.h>`<br />所以，两边都需要改成接口，才能依赖抽象。如此，工厂模式诞生了。解决new带来的细节依赖，避免new过程中导致的紧耦合（依赖具体的类）
  11. 【注释】编译式依赖：编译时，再检查是否存在；你存在，我编译才能通过
  13. <a name="rxPUJ"></a>
  14. ## 工厂模式
  15. <a name="ABTaT"></a>
  16. #### 模式定义
  17. **定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟到子类。——《设计模式》GoF。**<br />目的：解耦；手段：虚函数
  19. 1. 创建对象的接口`SplitterFactory::CreateSplitter`
  20. 1. 决定创建哪个类的子类：`BinarySplitterFactory`、`TxtSplitterFactory`等
  22. <a name="q5826"></a>
  23. #### 结构
  24. ![image.png](https://cdn.nlark.com/yuque/0/2020/png/1465826/1604766079993-630f3ffd-9c90-463c-bfee-bc4f3a16ac2a.png#align=left&display=inline&height=258&margin=%5Bobject%20Object%5D&name=image.png&originHeight=258&originWidth=624&size=58767&status=done&style=none&width=624)
  26. 1. `Product`：产品的抽象基类`ISplitter`<br />
  27. 1. `ConcreteProduct`：产品的具体基类`BinarySplitter`、`TxtSplitter`等
  28. 1. `Creator`：创建者的抽象基类`SplitterFactory`
  29. 1. `ConcreteCreator`：创建者的具体类`BinarySplitterFactory`、`TxtSplitterFactory`
  31. 红色部分是稳定的。MainForm依赖的就是红色部分<br />蓝色部分是变化的。我们做的事情，就是把蓝色的内容隔离出去，让MainForm不依赖于蓝色部分
  32. <a name="mBkan"></a>
  33. #### 要点总结
  35. 1. Factory Method用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系(new)会导致软件的脆弱
  36. 1. Factory Method模式通过面向对象的手法，将所要创建的具体对象工作**延迟**到子类，从而实现一种**扩展（而非更改）**的策略，较好地解决了这种紧耦合关系。
  37. 1. Factory Method模式解决“单个对象”的需求变化。缺点在于要求**创建方法/参数相同**
  38. <a name="FfXxr"></a>
  39. ## C++完整实例：Geometry相关类
  40. 本节来简单介绍工厂模式的完整使用实例，包含工厂模式定义，实现；对象创建与释放；使用等。内容来自GEOS的源码。
  42. <a name="L563k"></a>
  43. #### geometry.h
  44. ```cpp
  45. class GeometryFactory; //前置申明
  47. class Geometry{
  48. ///Geometry相关的类型
  49. public:
  50.        using ConstVect = std::vector<const Geometry*>;    //Geometry常量指针的数组
  51.     using NonConstVect = std::vector<Geometry*>;    //Geometry非常量指针的数组
  52.     using Ptr = std::unique_ptr<Geometry> ;    //unique_ptr智能指针
  54. ///工厂
  55. public:
  56.     friend class GeometryFactory;    //申明为友元
  57.     const GeometryFactory* getFactory() const{
  58.         return _factory;
  59.     }
  60. private:
  61.     const GeometryFactory* _factory;
  63. ///构建与析构
  64. public:
  65.     Geometry(const Geometry& geom);
  66.     Geometry(const GeometryFactory* factory);
  67.     virtual std::unique_ptr<Geometry> clone() const = 0;    //深拷贝
  68.     virtual ~Geometry() {
  69.         _factory->dropRef();
  70.     }
  72. ///分析
  73. public:
  74.     //缓冲区操作：此函数内生成的缓冲区，要返回成unique_ptr单一智能指针的形式
  75.     //1. 不能返回具体类（如Linearring），会带来细节依赖
  76.     //2. 不能返回具体类，就只能返回抽象类的指针
  77.     //3. 为防止内存泄漏，用智能指针来管理指针
  78.     //4. 选择单一智能指针
  79.     std::unique_ptr<Geometry> buffer(double distance) const;
  81.     //...
  82. }

geometryfactory.h

  1. //GEOS并没有使用抽象工厂，直接是具体工厂
  2. //所以此工厂依赖了所有产品Geometry、GeometryCollection、MultiPoint等
  3. #include <geos/geom/Geometry.h>
  4. #include <geos/geom/GeometryCollection.h>
  5. #include <geos/geom/MultiPoint.h>
  6. #include <geos/geom/MultiLineString.h>
  7. #include <geos/geom/MultiPolygon.h>
  8. #include <geos/geom/PrecisionModel.h>
  10. //前置申明
  11. class CoordinateSequenceFactory;
  12. class Coordinate;
  13. class CoordinateSequence;
  14. class Envelope;
  15. class Geometry;
  16. class GeometryCollection;
  17. class LineString;
  18. class LinearRing;
  19. class MultiLineString;
  20. class MultiPoint;
  21. class MultiPolygon;
  22. class Polygon;
  24. class GeometryFactory{
  25. //============================引用计数
  26. private:
  27.     e
  30. //============================Geometry工厂的创建与析构
  31. private:
  32.     bool __autoDestroy;
  33.     struct GeometryFactoryDeleter{ //删除者
  34.         void operator()(GeometryFactory *p) const{
  35.             p->destroy();
  36.         }
  37.     }
  38. public:
  39.     void destroy() {
  40.         assert(!_autoDestroy); // don't call me twice !
  41.         _autoDestroy = true;
  42.         if(! _refCount) {
  43.             delete this;
  44.         }
  45.     }
  46.     //GeometryFactory的单一智能指针
  47.     //在该智能指针被析构时调用GeometryFactoryDeleter()仿函数
  48.     using Ptr = std::unique_ptr<GeometryFactory, GeometryFactoryDeleter>;
  50.     static GeometryFactory::Ptr create() {
  51.         return GeometryFactory::Ptr(new GeometryFactory());
  52.     }
  53.     //static GeometryFactory::Ptr create(const PrecisionModel* pm);
  54.     //...
  56.     //默认工厂
  57.     static const GeometryFactory* getDefaultInstance() {
  58.         static GeometryFactory defInstance;
  59.         return &defInstance;
  60.     }
  62. //============================创建相关产品
  63. public:
  64.     ////创建点
  65.     std::unique_ptr<Point> createPoint(std::size_t coordinateDimension = 2) const{ //创建空的点
  66.         if (coordinateDimension == 3) {
  67.             geos::geom::FixedSizeCoordinateSequence<0> seq(coordinateDimension);
  68.             return std::unique_ptr<Point>(createPoint(seq));
  69.         }
  70.         return std::unique_ptr<Point>(new Point(nullptr, this));
  71.     }
  72.     Point* createPoint(const Coordinate& coordinate) const {
  73.         if(coordinate.isNull()) {
  74.             return createPoint().release();
  75.         }
  76.         else {
  77.             return new Point(coordinate, this);
  78.         }
  79.     }
  80.     Point* createPoint(const CoordinateSequence& coordinates) const;
  81.     //创建Geometry
  82.     std::unique_ptr<Geometry> createEmptyGeometry() const;
  85. }