设计模式-创建模式-工厂方法模式

随着产品种类越来越丰富，简单工厂模式有一个弊端。每次增加产品，都需要对工厂进行修改，这就可能对原有生产线引入问题。为了避免这个问题，可以使用工厂方法问题。在简单工厂模式的基础上，对工厂进行抽象，增加一个抽象工厂类，原来的工厂变为一个派生类，而对于新产品，可以增加新工厂，这个增加新工厂的过程对原有生产线没有影响。

以下代码相对与简单工厂模式的例子增加了产品C。

#include <iostream>

using namespace std;

enum ProductType{
    ProductTypeA,
    ProductTypeB,
    ProductTypeC,
};

class Products
{
public:
    virtual void Display() = 0;
    virtual ~Products(){}
};

class ProductA:public Products
{
public:
    void Display()
    {
        cout<<__PRETTY_FUNCTION__<<endl;
    }
};

class ProductB:public Products
{
public:
    void Display()
    {
        cout<<__PRETTY_FUNCTION__<<endl;
    }
};

class ProductC:public Products
{
public:
    void Display()
    {
        cout<<__PRETTY_FUNCTION__<<endl;
    }
};

以下代码对工厂类进行了调整，以AbstractFactory为接口类，原工厂类和新工厂类作为实现类。工厂FactoryForC对新产品C实现了生产方法。

class AbstractFactory
{
public:
    virtual Products* CreateProduct(ProductType Type)=0;
};

class Factory:public AbstractFactory
{
public:
    Products* CreateProduct(ProductType Type)
    {
        switch (Type) {
        case ProductTypeA:
            return new ProductA();
            break;
        case ProductTypeB:
            return new ProductB();
            break;
        default:
            return nullptr;
            break;
        }
    }
};

class FactoryForC:public AbstractFactory
{
public:
    Products* CreateProduct(ProductType Type)
    {
        switch (Type) {
        case ProductTypeC:
            return new ProductC();
            break;
        default:
            return nullptr;
            break;
        }
    }
};

以下代码相对于简单模式的例子增加了对C类产品的生产过程。

int main(void){

    AbstractFactory* factory = new Factory();
    Products* productA = factory->CreateProduct(ProductTypeA);
    productA->Display();
    Products* productB = factory->CreateProduct(ProductTypeB);
    productB->Display();
    delete factory;
    delete productA;
    delete productB;

    factory = new FactoryForC();
    Products* productC = factory->CreateProduct(ProductTypeC);
    productC->Display();
    delete factory;
    delete productC;

    return 0;
}

输出

virtual void ProductA::Display()
virtual void ProductB::Display()
virtual void ProductC::Display()