工厂模式：包括简单工厂模式、抽象工厂模式、工厂方法模式

简单工厂模式：主要用于创建对象。用一个工厂来根据输入的条件产生不同的类，然后根据不同类的虚函数得到不同的结果。
工厂方法模式：修正了简单工厂模式中不遵守开放封闭原则。把选择判断移到了客户端去实现，如果想添加新功能就不用修改原来的类，直接修改客户端即可。
抽象工厂模式：定义了一个创建一系列相关或相互依赖的接口，而无需指定他们的具体类。

简单工厂模式

主要用于创建对象。用一个工厂来根据输入的条件产生不同的类，然后根据不同类的虚函数得到不同的结果。

应用场景：

适用于针对不同情况创建不同类时，只需传入工厂类的参数即可，无需了解具体实现方法。例如：计算器中对于同样的输入，执行不同的操作：加、减、乘、除。

实现方式

  1. #include <iostream>
  2. #include <vector>
  3. using namespace std;
  5. // Here is the product class
  6. class Operation
  7. {
  8. public:
  9.     int var1, var2;
  10.     virtual double GetResult()
  11.     {
  12.         double res = 0;
  13.         return res;
  14.     }
  15. };
  17. class Add_Operation : public Operation
  18. {
  19. public:
  20.     virtual double GetResult()
  21.     {
  22.         return var1 + var2;
  23.     }
  24. };
  26. class Sub_Operation : public Operation
  27. {
  28. public:
  29.     virtual double GetResult()
  30.     {
  31.         return var1 - var2;
  32.     }
  33. };
  35. class Mul_Operation : public Operation
  36. {
  37. public:
  38.     virtual double GetResult()
  39.     {
  40.         return var1 * var2;
  41.     }
  42. };
  44. class Div_Operation : public Operation
  45. {
  46. public:
  47.     virtual double GetResult()
  48.     {
  49.         return var1 / var2;
  50.     }
  51. };
  53. // Here is the Factory class
  54. class Factory
  55. {
  56. public:
  57.     static Operation *CreateProduct(char op)
  58.     {
  59.         switch (op)
  60.         {
  61.         case '+':
  62.             return new Add_Operation();
  64.         case '-':
  65.             return new Sub_Operation();
  67.         case '*':
  68.             return new Mul_Operation();
  70.         case '/':
  71.             return new Div_Operation();
  73.         default:
  74.             return new Add_Operation();
  75.         }
  76.     }
  77. };
  79. int main()
  80. {
  81.     int a, b;
  82.     cin >> a >> b;
  83.     Operation *p = Factory::CreateProduct('+');
  84.     p->var1 = a;
  85.     p->var2 = b;
  86.     cout << p->GetResult() << endl;
  88.     p = Factory::CreateProduct('*');
  89.     p->var1 = a;
  90.     p->var2 = b;
  91.     cout << p->GetResult() << endl;
  93.     return 0;
  94. }

工厂方法模式

修正了简单工厂模式中不遵守开放封闭原则。把选择判断移到了客户端去实现，如果想添加新功能就不用修改原来的类，直接修改客户端即可。

应用场景：

一个类不知道它所需要的对象的类：在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建；客户端需要知道创建具体产品的工厂类。
一个类通过其派生类来指定创建哪个对象：在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其派生类来确定具体要创建的对象，利用面向对象的多态性和里氏代换原则，在程序运行时，派生类对象将覆盖父类对象，从而使得系统更容易扩展。
将创建对象的任务委托给多个工厂派生类中的某一个，客户端在使用时可以无须关心是哪一个工厂派生类创建产品派生类，需要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。

  1. #include <iostream>
  2. #include <vector>
  3. using namespace std;
  5. // Here is the product class
  6. class Operation
  7. {
  8. public:
  9.     int var1, var2;
  10.     virtual double GetResult()
  11.     {
  12.         double res = 0;
  13.         return res;
  14.     }
  15. };
  17. class Add_Operation : public Operation
  18. {
  19. public:
  20.     virtual double GetResult()
  21.     {
  22.         return var1 + var2;
  23.     }
  24. };
  26. class Sub_Operation : public Operation
  27. {
  28. public:
  29.     virtual double GetResult()
  30.     {
  31.         return var1 - var2;
  32.     }
  33. };
  35. class Mul_Operation : public Operation
  36. {
  37. public:
  38.     virtual double GetResult()
  39.     {
  40.         return var1 * var2;
  41.     }
  42. };
  44. class Div_Operation : public Operation
  45. {
  46. public:
  47.     virtual double GetResult()
  48.     {
  49.         return var1 / var2;
  50.     }
  51. };
  53. class Factory
  54. {
  55. public:
  56.     virtual Operation *CreateProduct() = 0;
  57. };
  59. class Add_Factory : public Factory
  60. {
  61. public:
  62.     Operation *CreateProduct()
  63.     {
  64.         return new Add_Operation();
  65.     }
  66. };
  68. class Sub_Factory : public Factory
  69. {
  70. public:
  71.     Operation *CreateProduct()
  72.     {
  73.         return new Sub_Operation();
  74.     }
  75. };
  77. class Mul_Factory : public Factory
  78. {
  79. public:
  80.     Operation *CreateProduct()
  81.     {
  82.         return new Mul_Operation();
  83.     }
  84. };
  86. class Div_Factory : public Factory
  87. {
  88. public:
  89.     Operation *CreateProduct()
  90.     {
  91.         return new Div_Operation();
  92.     }
  93. };
  95. int main()
  96. {
  97.     int a, b;
  98.     cin >> a >> b;
  99.     Add_Factory *p_fac = new Add_Factory();
  100.     Operation *p_pro = p_fac->CreateProduct();
  101.     p_pro->var1 = a;
  102.     p_pro->var2 = b;
  103.     cout << p_pro->GetResult() << endl;
  105.     Mul_Factory *p_fac1 = new Mul_Factory();
  106.     Operation *p_pro1 = p_fac1->CreateProduct();
  107.     p_pro1->var1 = a;
  108.     p_pro1->var2 = b;
  109.     cout << p_pro1->GetResult() << endl;
  111.     return 0;
  112. }

抽象工厂模式

定义了一个创建一系列相关或相互依赖的接口，而无需指定他们的具体类。

应用场景：

一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是重要的。
系统中有多于一个的产品族，而每次只使用其中某一产品族。
属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。
产品等级结构稳定，设计完成之后，不会向系统中增加新的产品等级结构或者删除已有的
产品等级结构。
////

  1. #include <iostream>
  2. #include <vector>
  3. using namespace std;
  5. // Here is the product class
  6. class Operation_Pos
  7. {
  8. public:
  9.     int var1, var2;
  10.     virtual double GetResult()
  11.     {
  12.         double res = 0;
  13.         return res;
  14.     }
  15. };
  17. class Add_Operation_Pos : public Operation_Pos
  18. {
  19. public:
  20.     virtual double GetResult()
  21.     {
  22.         return var1 + var2;
  23.     }
  24. };
  26. class Sub_Operation_Pos : public Operation_Pos
  27. {
  28. public:
  29.     virtual double GetResult()
  30.     {
  31.         return var1 - var2;
  32.     }
  33. };
  35. class Mul_Operation_Pos : public Operation_Pos
  36. {
  37. public:
  38.     virtual double GetResult()
  39.     {
  40.         return var1 * var2;
  41.     }
  42. };
  44. class Div_Operation_Pos : public Operation_Pos
  45. {
  46. public:
  47.     virtual double GetResult()
  48.     {
  49.         return var1 / var2;
  50.     }
  51. };
  52. /*********************************************************************************/
  53. class Operation_Neg
  54. {
  55. public:
  56.     int var1, var2;
  57.     virtual double GetResult()
  58.     {
  59.         double res = 0;
  60.         return res;
  61.     }
  62. };
  64. class Add_Operation_Neg : public Operation_Neg
  65. {
  66. public:
  67.     virtual double GetResult()
  68.     {
  69.         return -(var1 + var2);
  70.     }
  71. };
  73. class Sub_Operation_Neg : public Operation_Neg
  74. {
  75. public:
  76.     virtual double GetResult()
  77.     {
  78.         return -(var1 - var2);
  79.     }
  80. };
  82. class Mul_Operation_Neg : public Operation_Neg
  83. {
  84. public:
  85.     virtual double GetResult()
  86.     {
  87.         return -(var1 * var2);
  88.     }
  89. };
  91. class Div_Operation_Neg : public Operation_Neg
  92. {
  93. public:
  94.     virtual double GetResult()
  95.     {
  96.         return -(var1 / var2);
  97.     }
  98. };
  99. /*****************************************************************************************************/
  101. // Here is the Factory class
  102. class Factory
  103. {
  104. public:
  105.     virtual Operation_Pos *CreateProduct_Pos() = 0;
  106.     virtual Operation_Neg *CreateProduct_Neg() = 0;
  107. };
  109. class Add_Factory : public Factory
  110. {
  111. public:
  112.     Operation_Pos *CreateProduct_Pos()
  113.     {
  114.         return new Add_Operation_Pos();
  115.     }
  116.     Operation_Neg *CreateProduct_Neg()
  117.     {
  118.         return new Add_Operation_Neg();
  119.     }
  120. };
  122. class Sub_Factory : public Factory
  123. {
  124. public:
  125.     Operation_Pos *CreateProduct_Pos()
  126.     {
  127.         return new Sub_Operation_Pos();
  128.     }
  129.     Operation_Neg *CreateProduct_Neg()
  130.     {
  131.         return new Sub_Operation_Neg();
  132.     }
  133. };
  135. class Mul_Factory : public Factory
  136. {
  137. public:
  138.     Operation_Pos *CreateProduct_Pos()
  139.     {
  140.         return new Mul_Operation_Pos();
  141.     }
  142.     Operation_Neg *CreateProduct_Neg()
  143.     {
  144.         return new Mul_Operation_Neg();
  145.     }
  146. };
  148. class Div_Factory : public Factory
  149. {
  150. public:
  151.     Operation_Pos *CreateProduct_Pos()
  152.     {
  153.         return new Div_Operation_Pos();
  154.     }
  155.     Operation_Neg *CreateProduct_Neg()
  156.     {
  157.         return new Div_Operation_Neg();
  158.     }
  159. };
  161. int main()
  162. {
  163.     int a, b;
  164.     cin >> a >> b;
  165.     Add_Factory *p_fac = new Add_Factory();
  166.     Operation_Pos *p_pro = p_fac->CreateProduct_Pos();
  167.     p_pro->var1 = a;
  168.     p_pro->var2 = b;
  169.     cout << p_pro->GetResult() << endl;
  171.     Add_Factory *p_fac1 = new Add_Factory();
  172.     Operation_Neg *p_pro1 = p_fac1->CreateProduct_Neg();
  173.     p_pro1->var1 = a;
  174.     p_pro1->var2 = b;
  175.     cout << p_pro1->GetResult() << endl;
  177.     return 0;
  178. }