C++设计模式之-工厂模式的总结

工厂模式分为3种，即简单工厂模式、工厂方法模式、抽象工厂模式，其实大同小异，总结下来就是：

简单工厂模式：一个工厂，多个产品。产品需要有一个虚基类。通过传入参数，生成具体产品对象，并利用基类指针指向此对象。通过工厂获取此虚基类指针，通过运行时多态，调用子类实现。

 // Factory.cpp : 定义控制台应用程序的入口点。
 //

 #include "stdafx.h"
 #include <iostream>
 #include <string>
 using namespace std;
 class Product
 {
 public:
     virtual void show() = ;
 };
 class Product_A:public Product
 {
 public:
     void show() override
     {
         cout<<"Product_A"<<endl;
     }
 };
 class Product_B:public Product
 {
 public:
     void show() override
     {
         cout<<"Product_B"<<endl;
     }
 };
 class Factory
 {
 public:
     Product* create(int i)
     {
         switch(i)
         {
         case :
             return new Product_A;
             break;
         case :
             return new Product_B;
             break;
         default:
             break;
         }
     }
 };

 int _tmain(int argc, _TCHAR* argv[])
 {
     Factory *factory = new Factory();
     factory->create()->show();
     factory->create()->show();
     system("pause");
     return ;
 }

工厂方法模式：多个工厂，多个产品，每个产品对应于一个工厂。此时工厂和产品都是通过虚基类的方式构建。对于简单工厂模式，当要增加一个新产品时候，就需要在工厂类中修改代码，具体表现为多加一个参数，来识别新的产品类型。此时违反了对扩展开放，对修改关闭的原则。基于此，工厂方法模式应运而生。当增加一个新产品时，同时增加一个新工厂。增加新工厂属于扩展，不会修改以前工厂类和产品类的任何代码。可以看过多个独立的简单工厂模式构成了工厂方法模式。

 // FactoryM.cpp : 定义控制台应用程序的入口点。
 //

 #include "stdafx.h"
 #include<iostream>
 #include <string>
 using namespace std;

 class Product
 {
 public:
     virtual void show() = ;
 };
 class Product_A:public Product
 {
 public:
      void show() override
      {
          cout<<"Product_A"<<endl;
      }
  };
 class Product_B:public Product
 {
 public:
      void show() override
      {
          cout<<"Product_B"<<endl;
      }
 };

 class Factory
 {
 public:
     virtual Product* create()=;
 };

 class Factory_A:public Factory
 {
 public:
     Product* create()
     {
         return new Product_A;
     }
 };
 class Factory_B:public Factory
 {
 public:
     Product* create()
     {
         return new Product_B;
     }
 };

 int _tmain(int argc, _TCHAR* argv[])
 {
     Factory_A *product_a = new Factory_A();
     Factory_B *product_b = new Factory_B();
     product_a->create()->show();
     product_b->create()->show();
     system("pause");
     return ;
 }

抽象工厂模式：多个工厂，多个产品，并且每个产品可以包含多个型号。此时工厂和产品都是通过虚基类的方式构建。每一个工厂类可以生产同一个产品的多个型号。

 // FactoryMUL.cpp : 定义控制台应用程序的入口点。
 //

 #include "stdafx.h"
 #include <iostream>
 #include<string>
 using namespace std;

 class Product1
 {
 public:
     virtual void show() = ;
 };
 class Product_A1:public Product1
 {
 public:
     void show() override
     {
         cout<<"Product_A1"<<endl;
     }
 };
 class Product_B1:public Product1
 {
 public:
     void show() override
     {
         cout<<"Product_B1"<<endl;
     }
 };
 class Product2
 {
 public:
     virtual void show() = ;
 };
 class Product_A2:public Product2
 {
 public:
     void show() override
     {
         cout<<"Product_A2"<<endl;
     }
 };
 class Product_B2:public Product2
 {
 public:
     void show() override
     {
         cout<<"Product_B2"<<endl;
     }
 };
 class Factory
 {
 public:
     virtual Product1 *create1() = ;
     virtual Product2 *create2() = ;
 };
 class Factory_A
 {
 public:
     Product1 *create1(){ return new Product_A1;}
     Product2 *create2(){ return new Product_A2;}
 };
 class Factory_B
 {
 public:
     Product1 *create1(){ return new Product_B1;}
     Product2 *create2(){ return new Product_B2;}
 };
 int _tmain(int argc, _TCHAR* argv[])
 {
     Factory_A *factoryA = new Factory_A();
     factoryA->create1()->show();
     factoryA->create2()->show();

     Factory_B *factoryB = new Factory_B();
     factoryB->create1()->show();
     factoryB->create2()->show();
     system("pause");
     return ;
 }