c++ 设计模式——工厂模式

c++ 设计模式——工厂模式

理解

工厂模式就是定义一个虚基类，在一个工厂类中通过不同的创建标识来实现不同类型的基类子类的创建过程。

分类

1. 简单工厂模式
2. 工厂方法模式
3. 抽象工厂模式

简单工厂模式（simpleFactory）

简单工厂模式是一种最简单的一种实现，对于不同的产品的创建定义一个工厂类，将产品的类型作为参数传入到工厂类的创建函数中，从而根据不同的类型分支来选择不同的产品的构造函数。

simple_factory.h源码

# ifndef _SIMPLE_FACTORY_H_
# define _SIMPLE_FACTORY_H_

using namespace std;

//定义一个枚举标识产品的类型
typedef enum ProductTypeTag{
    TypeA = 0,
    TypeB,
    TypeC
}PRODUCTTYPE;

//定义产品的虚基类
class Product{
public:
    virtual void Show() = 0;
};

class ProductA:public Product{
public:
    void Show(){
        cout << "I am ProductA" << endl;
    }
};

class ProductB:public Product{
public:
    void Show(){
        cout << "I am ProductB" << endl;
    }
};

class ProductC:public Product{
public:
    void Show(){
        cout << "I am ProductC" << endl;
    }
};

class Factory{
public:
    Product * CreateProduct(PRODUCTTYPE type){
        switch(type){
            case TypeA:
                return new ProductA();
            case TypeB:
                return new ProductB();
            case TypeC:
                return new ProductC();
            default:
                return nullptr;
        }  
    }
};

# endif

sim_fac_test.cc源码如下

# include <iostream>
# include "simple_factory.h"

using namespace std;

int main(int argc,char ** argv){
    Factory productCreator;
    Product * productA =productCreator.CreateProduct(TypeA);    
    Product * productB =productCreator.CreateProduct(TypeB);    
    Product * productC =productCreator.CreateProduct(TypeC);    

    productA->Show();
    productB->Show();
    productC->Show();

    if(nullptr != productA){
        delete productA;
        productA = nullptr;
    }

    if(nullptr != productB){
        delete productB;
        productB = nullptr;
    }

    if(nullptr != productC){
        delete productC;
        productC = nullptr;
    }

    return 0;
}

输出结果；\

[cc@localhost designMode]$ ./a.out 
I am ProductA
I am ProductB
I am ProductC

工厂方法模式（factoryMethod）

简单工厂模式是一个简单的创建过程的封装，算不上是真正的工厂模式。工厂方法模式在简单工厂模式的基础上增加了对工厂的基类，不同的产品创建采用不同的工厂创建（从工厂的抽象基类派生），这样创建不同的产品过程就由不同的工厂分工解决：FactoryA就专门生产ProductA，FactoryB就专门生产ProductB，FactoryC就专门生产ProductC，不同的工厂之间没有联系。

该模式相对于简单工厂模式的有事在于：便于后期产品种类的扩展。

factory_method.h源码：

# ifndef _SIMPLE_FACTORY_H_
# define _SIMPLE_FACTORY_H_

using namespace std;

//定义一个枚举标识产品的类型
typedef enum ProductTypeTag{
    TypeA = 0,
    TypeB,
    TypeC
}PRODUCTTYPE;

//定义产品的虚基类
class Product{
public:
    virtual void Show() = 0;
};

class ProductA:public Product{
public:
    void Show(){
        cout << "I am ProductA" << endl;
    }
};

class ProductB:public Product{
public:
    void Show(){
        cout << "I am ProductB" << endl;
    }
};

class ProductC:public Product{
public:
    void Show(){
        cout << "I am ProductC" << endl;
    }
};

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

class FactoryA:public Factory{
public:
    Product * CreateProduct(){
        return new ProductA();
    }
};

class FactoryB:public Factory{
public:
    Product * CreateProduct(){
        return new ProductB();
    }
};

class FactoryC:public Factory{
public:
    Product * CreateProduct(){
        return new ProductC();
    }
};

# endif

fac_meth_test.cc源码：

# include <iostream>
# include "factory_method.h"

using namespace std;

int main(int argc,char ** argv){
    Factory * factoryA = new FactoryA();
    Product * productA = factoryA->CreateProduct();    

    Factory * factoryB = new FactoryB();
    Product * productB = factoryB->CreateProduct();    

    Factory * factoryC = new FactoryC();
    Product * productC = factoryC->CreateProduct();    

    productA->Show();
    productB->Show();
    productC->Show();

    if(nullptr != factoryA){
        delete factoryA;
        factoryA = nullptr;
    }

    if(nullptr != factoryB){
        delete factoryB;
        factoryB = nullptr;
    }

    if(nullptr != factoryC){
        delete factoryC;
        factoryC = nullptr;
    }

    if(nullptr != productA){
        delete productA;
        productA = nullptr;
    }

    if(nullptr != productB){
        delete productB;
        productB = nullptr;
    }

    if(nullptr != productC){
        delete productC;
        productC = nullptr;
    }

    return 0;
}

测试结果：

[cc@localhost designMode]$ g++ fac_meth_test.cc -std=c++11 
[cc@localhost designMode]$ ./a.out 
I am ProductA
I am ProductB
I am ProductC

抽象工厂模式（abstractFactory）

抽象工厂模式对工厂方法模式进行了更加一般化的描述。工厂方法模式适用于产品种类单一的场合，为一类产品提供创建的接口；而抽象工厂模式适用于产品多元化的场合，就是当具有多个抽象产品类型时，抽象工厂便可以派上用场。

抽象工厂更适合实际的情况，受生产线所限，低端工厂生产不同的低端产品，高端工厂生产不同的高端产品。

简单理解一下，代码应该就很容易这里就不写了。