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

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

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

 

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

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
class Product
{
public:
    virtual void show() = 0;
};
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 1:
            return new Product_A;
            break;
        case 2:
            return new Product_B;
            break;
        default:
            break;
        }
    }
};

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

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

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

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

class Product
{
public:
    virtual void show() = 0;
};
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()=0;
};

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 0;
}

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

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

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

class Product1
{
public:
    virtual void show() = 0;
};
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() = 0;
};
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() = 0;
    virtual Product2 *create2() = 0;
};
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 0;
}