C++ 常用設計模式學習——工廠模式

阿新 • • 發佈：2021-08-05

在工廠模式中，建立物件時不會對客戶端暴露建立邏輯，並且是通過使用一個共同的介面來指向新建立的物件。工廠模式作為一種建立模式，一般在建立複雜物件時，考慮使用；在建立簡單物件時，建議直接new完成一個例項物件的建立。

簡單工廠模式

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

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

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