C++设计模式之工厂模式

参考原文：https://www.cnblogs.com/chengjundu/p/8473564.html

工厂模式分为简单工厂模式，工厂方法模式，抽象工厂模式。

目录

工厂模式

1 简单工厂模式

1.1 概述

1.2 代码描述：

1.3 UML描述

2. 工厂方法模式

2.1 概述

2.2 代码描述

2.3 UML描述

3. 抽象工厂模式

3.1 概述

3.2 代码描述

3.3  UML描述

4. 总结

---

工厂模式

1 简单工厂模式

1.1 概述

一个工厂生产多种类型的产品，产品类型根据产品类型模板来判断。在本例中，产品模型有Tank56，Tank96，在选中工厂的产品类型后，再去生产哪种类型的产品。

特点：需要在工厂类中做判断，从而创造相应的产品，当增加新产品时，需要修改工厂类。使用简单工厂模式，我们只需要知道具体的产品型号就可以创建一个产品。

 

1.2 代码描述：

/*
关键代码：创建过程在工厂类中完成。
*/
​
#include <iostream>
​
using namespace std;
​
//定义产品类型信息
typedef enum
{
    Tank_Type_56,
    Tank_Type_96,
    Tank_Type_Num
}Tank_Type;
​
//抽象产品类
class Tank
{
public:
    virtual const string& type() = 0;
};
​
//具体的产品类
class Tank56 : public Tank
{
public:
    Tank56():Tank(),m_strType("Tank56")
    {
    }
​
    const string& type() override
    {
        cout << m_strType.data() << endl;
        return m_strType;
    }
private:
    string m_strType;
};
​
//具体的产品类
class Tank96 : public Tank
{
public:
    Tank96():Tank(),m_strType("Tank96")
    {
    }
    const string& type() override
    {
        cout << m_strType.data() << endl;
        return m_strType;
    }
​
private:
    string m_strType;
}; 
​
//工厂类
class TankFactory
{
public:
    //根据产品信息创建具体的产品类实例，返回一个抽象产品类
    Tank* createTank(Tank_Type type)
    {
        switch(type)
        {
        case Tank_Type_56:
            return new Tank56();
        case Tank_Type_96:
            return new Tank96();
        default:
            return nullptr;
        }
    }
};
​
​
int main()
{
    TankFactory* factory = new TankFactory();
    Tank* tank56 = factory->createTank(Tank_Type_56);
    tank56->type();
    Tank* tank96 = factory->createTank(Tank_Type_96);
    tank96->type();
​
    delete tank96;
    tank96 = nullptr;
    delete tank56;
    tank56 = nullptr;
    delete factory;
    factory = nullptr;
​
    return 0;
}

1.3 UML描述

2. 工厂方法模式

2.1 概述

一个产品对应一个工厂。定义一个创建对象的接口， 其子类去实现这个接口以完成具体的产品创建。

2.2 代码描述

/*
关键代码：创建过程在其子类执行。
*/
​
#include <iostream>
​
using namespace std;
​
//产品抽象类
class Tank
{
public:
    virtual const string& type() = 0;
};
​
//具体的产品类
class Tank56 : public Tank
{
public:
    Tank56():Tank(),m_strType("Tank56")
    {
    }
​
    const string& type() override
    {
        cout << m_strType.data() << endl;
        return m_strType;
    }
private:
    string m_strType;
};
​
//具体的产品类
class Tank96 : public Tank
{
public:
    Tank96():Tank(),m_strType("Tank96")
    {
    }
    const string& type() override
    {
        cout << m_strType.data() << endl;
        return m_strType;
    }
​
private:
    string m_strType;
}; 
​
//抽象工厂类，提供一个创建接口
class TankFactory
{
public:
    //提供创建产品实例的接口，返回抽象产品类
    virtual Tank* createTank() = 0;
};
​
//具体的创建工厂类，使用抽象工厂类提供的接口，去创建具体的产品实例
class Tank56Factory : public TankFactory
{
public:
    Tank* createTank() override
    {
        return new Tank56();
    }
};
​
//具体的创建工厂类，使用抽象工厂类提供的接口，去创建具体的产品实例
class Tank96Factory : public TankFactory
{
public:
    Tank* createTank() override
    {
        return new Tank96();
    }
};
​
​
int main()
{
    TankFactory* factory56 = new Tank56Factory();
    Tank* tank56 = factory56->createTank();
    tank56->type();
    
    TankFactory* factory96 = new Tank96Factory();
    Tank* tank96 = factory96->createTank();
    tank96->type();
​
    delete tank96;
    tank96 = nullptr;
    delete factory96;
    factory96 = nullptr;
​
    delete tank56;
    tank56 = nullptr;
    delete factory56;
    factory56 = nullptr;
​
    return 0;
}

2.3 UML描述

 

3. 抽象工厂模式

3.1 概述

非人话：

抽象工厂模式提供创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

当存在多个产品系列，而客户端只使用一个系列的产品时，可以考虑使用抽象工厂模式。

人话就是：一个产品，包含2个组成部分part1 ,part2，2个部分又都有的型号A, B。

3.2 代码描述

#include<iostream>
using namespace std;

class Factory{
    public:
 
      virtual Coat* createCoat() = 0;
      virtual Pants* createPants() = 0;
};

class Coat
{
public:
    virtual const string& color() = 0;
};

class BlackCoat: public Coat
{
public:
    BlackCoat():Coat(),m_strColor("Black Coat")
    {
    }
    const string& color() override
    {
         cout << m_strColor.data() << endl;
         return m_strColor;
    }
private:
    string m_strColor;
}

class WhiteCoat: public Coat
{
public:
    WhiteCoat():Coat(),m_strColor("White Coat")
    {
    }
    const string& color() override
    {
         cout << m_strColor.data() << endl;
         return m_strColor;
    }
private:
    string m_strColor;
}

class Pants
{
public:
    virtual const string& color() = 0;
};

class BlackPants: public Coat
{
public:
    BlackPants():Coat(),m_strColor("Black Coat")
    {
    }
    const string& color() override
    {
         cout << m_strColor.data() << endl;
         return m_strColor;
    }
private:
    string m_strColor;
}

class WhitePants: public Coat
{
public:
    WhitePants():Coat(),m_strColor("White Coat")
    {
    }
    const string& color() override
    {
         cout << m_strColor.data() << endl;
         return m_strColor;
    }
private:
    string m_strColor;
}

  //抽象工厂类，提供衣服创建接口
class Factory
{
public:
    //上衣创建接口，返回抽象上衣类
    virtual Coat* createCoat() = 0;
    //裤子创建接口，返回抽象裤子类
    virtual Pants* createPants() = 0;
};

class WhiteFactory : public Factory
{
public:
    virtual Coat* createCoat()
    {
        return new WhiteCoat();
    }
    virtual Pants* createBants()
    {
        return new WhileBants();
    }
}

class BlockFactory : public Factory
{
public:
    virtual Coat* createCoat()
    {
        return new BlockCoat();
    }
    virtual Pants* createPants()
    {
        return new BlockPants();
    }     
}
    

3.3  UML描述

 

4. 总结

工厂模式，共分为简单工厂模式， 工厂方法模式，抽象工厂模式。

简单工厂模式：根据一个依赖的标志量来在Factory类内生产与标志对应的产品类。当产品过多，代码会很臃肿。当程序

工厂方法模式：一个产品一个工厂，同时工厂也会应以产品方法，来供客户端直接使用。当产品过多时，工厂类会过多。

抽象工厂模式：描述上可以从多维角度看，如做一个跨平台的UI界面，一维空间是button，checkbox等，但控件有windows，linux，mac等平台控件。二维空间是windows的工厂，linux工厂，mac工厂，windows工厂专生产windows

的button，等控件，linux工厂只生产linux平台控件，mac工厂只生产mac平台控件。综上所述，一个工厂类派生出多个类型的工厂类，且派生出来的每个工厂类下面都会有多个且相同类型的产品。（注意，类型相同，但工厂不同）.当存在多个产品系列，而程序员只使用一个系列的产品时，可以考虑使用抽象工厂模式。

但当增加一个新系列的产品时，不仅需要现实具体的产品类，还需要增加一个新的创建接口，扩展相对困难。