简单工厂模式
主要特点就是需要在工厂类中做判断，从而创造相应的产品，当增加新的产品时，需要修改工厂类。举例，有家生产处理器核的厂家，仅有一家工厂，能生产两种型号的处理器，客户需要什么样的处理器，一定要显式地告诉工厂生产。
例:
1 enum CTYPE {COREA, COREB}; 2 3 class SingleCore { 4 public: 5 virtual void show() = 0; 6 }; 7 8 //单核A 9 class SingleCoreA: public SingleCore { 10 public: 11 void show() { cout << "SingleCore A" << endl; } 12 }; 13 //单核B 14 class SingleCoreB: public SingleCore { 15 public: 16 void show() { cout << "SingleCore B" << endl; } 17 }; 18 19 //唯一的工厂，可以生产两种型号的处理器核，在内部判断 20 class Factory { 21 public: 22 SingleCore* createSingleCore(enum CTYPE core) { 23 if(core == COREA) { 24 return new SingleCoreA(); 25 }else if(core == COREB) { 26 return new SingleCoreB(); 27 }else 28 return nullptr; 29 } 30 };
缺点：
增加新的处理器核类型，需要修改工厂类，违反了开闭原则:对扩展开放，对更改封闭。
因此工厂方法模式出现了，即定义一个用于创建对象的接口，让子类决定实例化哪一个类，使一个类的实例化延迟到其子类。
接着举例：这家生产处理器核的厂家赚到飞天，就决定再开设一个工厂专门生产B型号的单核，而原来的工厂专门原来生产A单核。如此，客户有需求就直接找生产对应核的工厂就可以，无须告诉工厂需要什么样的核。
例子:
1 class SingleCore { 2 public: 3 virtual void show() = 0; 4 }; 5 6 //单核A 7 class SingleCoreA: public SingleCore { 8 public: 9 void show() { cout << "SingleCore A" << endl; } 10 }; 11 //单核B 12 class SingleCoreB: public SingleCore { 13 public: 14 void show() { cout << "SingleCore B" << endl; } 15 }; 16 17 class Factory { 18 public: 19 virtual SingleCore* createSingleCore() = 0; 20 }; 21 //生产A核的工厂 22 class FactoryA :public Factory{ 23 public: 24 SingleCoreA* createSingleCore() {return new SingleCoreA();} 25 }; 26 27 //生产B核的工厂 28 class FactoryB :public Factory{ 29 public: 30 SingleCoreB* createSingleCore() {return new SingleCoreB();} 31 };
当然，工厂方法模式也有缺点，新的工厂会随着新产品的增加而增加，会需要很多的类定义。
动机
模式定义
随着这家公司技术不断进步，可以生产多核处理器了，抽象工厂模式中，提供一个创建一系列相关或依赖对象的接口，而无须为相关联的不同产品分别指定具体的类。同样，该厂家开设两家工厂，一个专门生产A型号的单核与多核处理器，另一个专门生产B型号的单核与多核处理器。实现如下：
1 class SingleCore { 2 public: 3 virtual void show() = 0; 4 }; 5 6 //单核A 7 class SingleCoreA: public SingleCore { 8 public: 9 void show() { cout << "SingleCore A" << endl; } 10 }; 11 //单核B 12 class SingleCoreB: public SingleCore { 13 public: 14 void show() { cout << "SingleCore B" << endl; } 15 }; 16 17 18 //多核 19 class MultiCore { 20 public: 21 virtual void show() = 0; 22 }; 23 24 class MultiCoreA: public MultiCore { 25 public: 26 void show() { cout << "MultiCore A" << endl; } 27 }; 28 29 class MultiCoreB: public MultiCore { 30 public: 31 void show() { cout << "MultiCore B" << endl; } 32 }; 33 34 //工厂 35 class Factory { 36 public: 37 virtual SingleCore* createSingleCore() = 0; 38 virtual MultiCore* createMultliCore() = 0; 39 }; 40 41 //工厂A，专门用来生产A型号的处理器 42 class FactoryA :public Factory{ 43 public: 44 SingleCore* createSingleCore() {return new SingleCoreA();} 45 MultiCore* createMultiCore() { return new MultiCoreA(); } 46 }; 47 48 //工厂B，专门用来生产B型号的处理器 49 class FactoryB :public Factory{ 50 public: 51 SingleCore* createSingleCore() {return new SingleCoreB();} 52 MultiCore* createMultiCore() { return new MultiCoreB(); } 53 54 };
动机
模式定义
要点总结
原文：https://www.cnblogs.com/y4247464/p/14261680.html