C++常見設計模式——工廠模式

設計模式是對設計原則的具體化。用江湖話說就是武林祕籍，總結出來的一些固定套路，可以幫助有根基的程序員迅速打通任督二脈，從此做什麼都特別快。

工廠模式主要是爲創建對象提供了接口。
應用場景如下：
a、 在編碼時不能預見需要創建哪種類的實例。
b、 系統不應依賴於產品類實例如何被創建、組合和表達的細節。

簡單工廠模式

主要特點是需要在工廠類中做判斷，從而創造相應的產品，當增加新產品時，需要修改工廠類。使用簡單工廠模式，我們只需要知道具體的產品型號就可以創建一個產品。

缺點：工廠類集中了所有產品類的創建邏輯，如果產品量較大，會使得工廠類變的非常臃腫。

/*
關鍵代碼：創建過程在工廠類中完成。
*/
​
#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;
}

工廠方法模式

定義一個創建對象的接口，其子類去具體現實這個接口以完成具體的創建工作。如果需要增加新的產品類，只需要擴展一個相應的工廠類即可。

缺點：產品類數據較多時，需要實現大量的工廠類，這無疑增加了代碼量。

/*
關鍵代碼：創建過程在其子類執行。
*/
​
#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;
}

抽象工廠模式

抽象工廠模式提供創建一系列相關或相互依賴對象的接口，而無需指定它們具體的類。

當存在多個產品系列，而客戶端只使用一個系列的產品時，可以考慮使用抽象工廠模式。

缺點：當增加一個新系列的產品時，不僅需要現實具體的產品類，還需要增加一個新的創建接口，擴展相對困難。

/*
* 關鍵代碼：在一個工廠裏聚合多個同類產品。
* 以下代碼以白色衣服和黑色衣服爲例，白色衣服爲一個產品系列，黑色衣服爲一個產品系列。白色上衣搭配白色褲子，   黑色上衣搭配黑色褲字。每個系列的衣服由一個對應的工廠創建，這樣一個工廠創建的衣服能保證衣服爲同一個系列。
*/
​
//抽象上衣類
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 Pants
{
public:
    BlackPants():Pants(),m_strColor("Black Pants")
    {
    }
    const string& color() override
    {
        cout << m_strColor.data() << endl;
        return m_strColor;
    }
​
private:
    string m_strColor;
};
​
//白色褲子類
class WhitePants : public Pants
{
public:
    WhitePants():Pants(),m_strColor("White Pants")
    {
    }
    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:
    Coat* createCoat() override
    {
        return new WhiteCoat();
    }
​
    Pants* createPants() override
    {
        return new WhitePants();
    }
};
​
//創建黑色衣服的工廠類，具體實現創建黑色上衣和白色褲子的接口
class BlackFactory : public Factory
{
    Coat* createCoat() override
    {
        return new BlackCoat();
    }
​
    Pants* createPants() override
    {
        return new BlackPants();
    }
};