2. 程式人生 > 其它 >C++設計模式——工廠模式

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

阿新 • • 發佈：2021-10-29

轉載來自：https://www.cnblogs.com/xiaolincoding/p/11524376.html

什麼是工廠模式？

這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。
在工廠模式中，我們在建立物件時不會對客戶端暴露建立邏輯，並且是通過使用一個共同的介面來指向新建立的物件。

簡單來說，使用了C++多型的特性，將存在繼承關係的類，通過一個工廠類建立對應的子類（派生類）物件。在專案複雜的情況下，可以便於子類物件的建立。

工廠模式的實現方式可分別簡單工廠模式、工廠方法模式、抽象工廠模式，每個實現方式都存在優和劣。

最近炒鞋炒的非常的火，那麼以鞋廠的形式，一一分析針對每個實現方式進行分析。

簡單工廠模式

具體的情形：
  • 鞋廠可以指定生產耐克、阿迪達斯和李寧牌子的鞋子。哪個鞋炒的火爆，老闆就生產哪個，看形勢生產。
UML圖：
簡單工廠模式的結構組成：
  1. 工廠類(ShoesFactory)：工廠模式的核心類，會定義一個用於建立指定的具體例項物件的介面。
  2. 抽象產品類(Shoes)：是具體產品類的繼承的父類或實現的介面。
  3. 具體產品類(NiKeShoes\AdidasShoes\LiNingShoes)：工廠類所建立的物件就是此具體產品例項。
簡單工廠模式的特點：
  • 工廠類封裝了建立具體產品物件的函數。
簡單工廠模式的缺陷：
  • 擴充套件性非常差，新增產品的時候，需要去修改工廠類
    。
簡單工廠模式的程式碼：
  • Shoes為鞋子的抽象類（基類），介面函式為Show()，用於顯示鞋子廣告。
  • NiKeShoes、AdidasShoes、LiNingShoes為具體鞋子的類，分別是耐克、阿迪達斯和李寧鞋牌的鞋，它們都繼承於Shoes抽象類。#include <iostream>
#include <iostream>
#include <algorithm>
#include <cstdio>
// 鞋子抽象類
class Shoes
{
public:
    virtual ~Shoes() {}
    virtual void
 
 Show() = 0;
};

// 耐克鞋子
class NiKeShoes : public Shoes
{
public:
    void Show()
    {
        std::cout << "我是耐克球鞋，我的廣告語：Just do it" << std::endl;
    }
};

// 阿迪達斯鞋子
class AdidasShoes : public Shoes
{
public:
    void Show()
    {
        std::cout << "我是阿迪達斯球鞋，我的廣告語:Impossible is nothing" << std::endl;
    }
};

// 李寧鞋子
class LiNingShoes : public Shoes
{
public:
    void Show()
    {
        std::cout << "我是李寧球鞋，我的廣告語：Everything is possible" << std::endl;
    }
};

enum SHOES_TYPE
{
    NIKE,
    LINING,
    ADIDAS
};

// 總鞋廠
class ShoesFactory
{
public:
    // 根據鞋子型別建立對應的鞋子物件
    Shoes* CreateShoes(SHOES_TYPE type)
    {
        switch (type)
        {
        case NIKE:
            return new NiKeShoes();
            break;
        case LINING:
            return new LiNingShoes();
            break;
        case ADIDAS:
            return new AdidasShoes();
            break;
        default:
            return NULL;
            break;
        }
    }
};


int main()
{
    // 構造工廠物件
    ShoesFactory shoesFactory;

    // 從鞋工廠物件建立阿迪達斯鞋物件
    Shoes* pNikeShoes = shoesFactory.CreateShoes(NIKE);
    if (pNikeShoes != nullptr)
    {
        // 耐克球鞋廣告喊起
        pNikeShoes->Show();

        // 釋放資源
        delete pNikeShoes;
        pNikeShoes = nullptr;
    }

    // 從鞋工廠物件建立阿迪達斯鞋物件
    Shoes* pLiNingShoes = shoesFactory.CreateShoes(LINING);
    if (pLiNingShoes != nullptr)
    {
        // 李寧球鞋廣告喊起
        pLiNingShoes->Show();

        // 釋放資源
        delete pLiNingShoes;
        pLiNingShoes = nullptr;
    }

    // 從鞋工廠物件建立阿迪達斯鞋物件
    Shoes* pAdidasShoes = shoesFactory.CreateShoes(ADIDAS);
    if (pAdidasShoes != nullptr)
    {
        // 阿迪達斯球鞋廣告喊起
        pAdidasShoes->Show();

        // 釋放資源
        delete pAdidasShoes;
        pAdidasShoes = nullptr;
    }

    return 0;
}
  • main函式，先是構造了工廠物件，後建立指定型別的具體鞋子產品物件，建立了具體鞋子產品的物件便可直接列印廣告。因為採用的是new的方式建立了物件，用完了要通過delete釋放資源資源哦！

工廠方法模式

具體情形：
  • 現各類鞋子炒的非常火熱，於是為了大量生產每種型別的鞋子，則要針對不同品牌的鞋子開設獨立的生產線，那麼每個生產線就只能生產同類型品牌的鞋。
UML圖：
工廠方法模式的結構組成：
  1. 抽象工廠類廠（ShoesFactory）：工廠方法模式的核心類，提供建立具體產品的介面，由具體工廠類實現。
  2. 具體工廠類（NiKeProducer\AdidasProducer\LiNingProducer）：繼承於抽象工廠，實現建立對應具體產品物件的方式。
  3. 抽象產品類（Shoes）：它是具體產品繼承的父類（基類）。
  4. 具體產品類（NiKeShoes\AdidasShoes\LiNingShoes）：具體工廠所建立的物件，就是此類。
工廠方法模式的特點：
  • 工廠方法模式抽象出了工廠類，提供建立具體產品的介面，交由子類去實現。
  • 工廠方法模式的應用並不只是為了封裝具體產品物件的建立，而是要把具體產品物件的建立放到具體工廠類實現。
工廠方法模式的缺陷：
  • 每新增一個產品，就需要增加一個對應的產品的具體工廠類。相比簡單工廠模式而言，工廠方法模式需要更多的類定義。
  • 一條生產線只能一個產品。
工廠方法模式的程式碼：
  • ShoesFactory抽象工廠類，提供了建立具體鞋子產品的純虛擬函式。
  • NiKeProducer、AdidasProducer、LiNingProducer具體工廠類，繼承持續工廠類，實現對應具體鞋子產品物件的建立。
#include <iostream>
#include <algorithm>
#include <cstdio>
enum SHOES_TYPE
{
    NIKE,
    LINING,
    ADIDAS
};
// 鞋子抽象類
class Shoes
{
public:
    virtual ~Shoes() {}
    virtual void Show() = 0;
};

// 耐克鞋子
class NiKeShoes : public Shoes
{
public:
    void Show()
    {
        std::cout << "我是耐克球鞋，我的廣告語：Just do it" << std::endl;
    }
};

// 阿迪達斯鞋子
class AdidasShoes : public Shoes
{
public:
    void Show()
    {
        std::cout << "我是阿迪達斯球鞋，我的廣告語:Impossible is nothing" << std::endl;
    }
};

// 李寧鞋子
class LiNingShoes : public Shoes
{
public:
    void Show()
    {
        std::cout << "我是李寧球鞋，我的廣告語：Everything is possible" << std::endl;
    }
};


// 總鞋廠
class ShoesFactory
{
public:
    virtual Shoes* CreateShoes() = 0;
    virtual ~ShoesFactory() {}
};


// 耐克生產者/生產鏈
class NiKeProducer : public ShoesFactory
{
public:
    Shoes* CreateShoes()
    {
        return new NiKeShoes();
    }
};

// 阿迪達斯生產者/生產鏈
class AdidasProducer : public ShoesFactory
{
public:
    Shoes* CreateShoes()
    {
        return new AdidasShoes();
    }
};

// 李寧生產者/生產鏈
class LiNingProducer : public ShoesFactory
{
public:
    Shoes* CreateShoes()
    {
        return new LiNingShoes();
    }
};

int main()
{
    // ================ 生產耐克流程 ==================== //
    // 鞋廠開設耐克生產線
    ShoesFactory* niKeProducer = new NiKeProducer();
    // 耐克生產線產出球鞋
    Shoes* nikeShoes = niKeProducer->CreateShoes();
    // 耐克球鞋廣告喊起
    nikeShoes->Show();
    // 釋放資源
    delete nikeShoes;
    delete niKeProducer;

    // ================ 生產阿迪達斯流程 ==================== //
    // 鞋廠開設阿迪達斯生產者
    ShoesFactory* adidasProducer = new AdidasProducer();
    // 阿迪達斯生產線產出球鞋
    Shoes* adidasShoes = adidasProducer->CreateShoes();
    // 阿迪達斯球鞋廣喊起
    adidasShoes->Show();
    // 釋放資源
    delete adidasShoes;
    delete adidasProducer;

    return 0;
}

結果：

抽象工廠模式

具體情形：
  • 鞋廠為了擴大了業務，不僅只生產鞋子，把運動品牌的衣服也一起生產了。
UML圖：
抽象工廠模式的結構組成（和工廠方法模式一樣）：
  1. 抽象工廠類廠（ShoesFactory）：工廠方法模式的核心類，提供建立具體產品的介面，由具體工廠類實現。
  2. 具體工廠類（NiKeProducer）：繼承於抽象工廠，實現建立對應具體產品物件的方式。
  3. 抽象產品類（Shoes\Clothe）：它是具體產品繼承的父類（基類）。
  4. 具體產品類（NiKeShoes\NiKeClothe）：具體工廠所建立的物件，就是此類。
抽象工廠模式的特點：
  • 提供一個介面，可以建立多個產品族中的產品物件。如建立耐克工廠，則可以建立耐克鞋子產品、衣服產品、褲子產品等。
抽象工廠模式的缺陷：
  • 同工廠方法模式一樣，新增產品時，都需要增加一個對應的產品的具體工廠類。
抽象工廠摸是的程式碼：
  • Clothe和Shoes，分別為衣服和鞋子的抽象產品類。
  • NiKeClothe和NiKeShoes，分別是耐克衣服和耐克衣服的具體產品類。
#include <iostream>
#include <algorithm>
#include <cstdio>
enum SHOES_TYPE
{
    NIKE,
    LINING,
    ADIDAS
};
// 鞋子抽象類
class Shoes
{
public:
    virtual ~Shoes() {}
    virtual void Show() = 0;
};

// 耐克鞋子
class NiKeShoes : public Shoes
{
public:
    void Show()
    {
        std::cout << "我是耐克球鞋，我的廣告語：Just do it" << std::endl;
    }
};

// 阿迪達斯鞋子
class AdidasShoes : public Shoes
{
public:
    void Show()
    {
        std::cout << "我是阿迪達斯球鞋，我的廣告語:Impossible is nothing" << std::endl;
    }
};

// 李寧鞋子
class LiNingShoes : public Shoes
{
public:
    void Show()
    {
        std::cout << "我是李寧球鞋，我的廣告語：Everything is possible" << std::endl;
    }
};


// 基類 衣服
class Clothe
{
public:
    virtual void Show() = 0;
    virtual ~Clothe() {}
};

// 耐克衣服
class NiKeClothe : public Clothe
{
public:
    void Show()
    {
        std::cout << "我是耐克衣服，時尚我最在行！" << std::endl;
    }
};


// 總廠
class Factory
{
public:
    virtual Shoes* CreateShoes() = 0;
    virtual Clothe* CreateClothe() = 0;
    virtual ~Factory() {}
};


// 耐克生產者/生產鏈
class NiKeProducer : public Factory
{
public:
    Shoes* CreateShoes()
    {
        return new NiKeShoes();
    }
    Clothe* CreateClothe()
    {
        return new NiKeClothe();
    }
};

// 阿迪達斯生產者/生產鏈
class AdidasProducer : public Factory
{
public:
    Shoes* CreateShoes()
    {
        return new AdidasShoes();
    }
};

// 李寧生產者/生產鏈
class LiNingProducer : public Factory
{
public:
    Shoes* CreateShoes()
    {
        return new LiNingShoes();
    }
};

int main()
{
    // ================ 生產耐克流程 ==================== //
    // 鞋廠開設耐克生產線
    Factory* niKeProducer = new NiKeProducer();

    // 耐克生產線產出球鞋
    Shoes* nikeShoes = niKeProducer->CreateShoes();
    // 耐克生產線產出衣服
    Clothe* nikeClothe = niKeProducer->CreateClothe();

    // 耐克球鞋廣告喊起
    nikeShoes->Show();
    // 耐克衣服廣告喊起
    nikeClothe->Show();

    // 釋放資源
    delete nikeShoes;
    delete nikeClothe;
    delete niKeProducer;
    return 0;
}

相關推薦

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

轉載來自：https://www.cnblogs.com/xiaolincoding/p/11524376.html 什麼是工廠模式？ 這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。

javascript設計模式 – 工廠模式原理與應用例項分析

本文例項講述了javascript設計模式 – 工廠模式原理與應用。分享給大家供大家參考，具體如下：

23種設計模式——工廠模式

23種設計模式——工廠模式 作用 實現了建立者和呼叫者分離 詳細分類 簡單工廠模式

設計模式 工廠模式 從賣肉夾饃說起

今天繼續設計模式之旅，給大家帶來工廠模式，簡單列一下這個模式的家族：

JAVA專案實戰-設計模式-工廠模式的專案使用

今天學習的是創造型設計模式之一 \'工廠模式\',我們經常講的可分為三類 1.簡單工廠

JavaScript設計模式 -- 工廠模式

案例一： const BicycleShop = function () {} BicycleShop.prototype = { sellBicycle: function (model) {

設計模式中建立型模式——工廠模式

　　工廠模式亦稱：虛擬建構函式、Virtual Constructor、Factory Method 意圖：工廠模式是一種建立型設計模式，其在父類中提供一個建立物件的方法，允許子類決定例項化物件的型別。

javascript 設計模式 - 工廠模式實現及應用

1.工廠模式解釋 工廠模式定義一個用於建立物件的介面，這個介面整合多個子類的介面，可以選擇性的構建對應的子類例項

淺談設計模式——工廠模式

基本概念 　　工廠顧名思義就是建立產品，根據產品是具體產品還是具體工廠可分為簡單工廠模式和工廠方法模式，根據工廠的抽象程度可分為工廠方法模式和抽象工廠模式。

設計模式——工廠模式

工廠模式（Factory Pattern）是 Java 中最常用的設計模式之一。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。在工廠模式中，我們在建立物件時不會對客戶端暴露建立邏輯，並且是通過使用一個

Java封神之路-設計模式-工廠模式

工廠顧名思義就是建立產品，根據產品是具體產品還是具體工廠可分為簡單工廠模式和工廠方法模式，根據工廠的抽象程度可分為工廠方法模式和抽象工廠模式。該模式用於封裝和管理物件的建立，是一種建立型模式。本文從一

設計模式(五) 簡單工廠模式+工廠模式

簡單工廠模式 建立一個工廠類，對實現了同一個介面的多個類進行例項的建立。

設計模式-工廠模式

工廠模式是一個大的家族 包括以下三種 　　　　　　　　　簡單工廠模式 　　　　　　　　　工廠方法模式

程式設計模式(C#程式碼)----抽象工廠模式

using System; namespace 抽象工廠模式 { class Program { static void Main(string[] args) { CreateFactory createFactory = new CreateFactory();

設計模式: 工廠模式

技術標籤：設計模式 設計模式: 工廠模式 工廠是每一個開發人員應該知道的關鍵創造模式之一。它們是許多高階模式的主要組成部分。很長一段時間，我對不同型別的工廠模式感到困擾。此外，在同一篇文章中很難找到關

js 設計模式——工廠模式

定義 工廠模式定義建立物件的介面，但是讓子類決定例項化哪個類。根據不同的輸入返回不同類的例項，一般用來建立同一類物件。工廠方式的主要思想是將物件的建立與物件的實現分離，將類的例項化延遲到子類。

C++_簡單工廠模式_程式碼案例

#include <iostream> using namespace std; // 水果抽象類 class CAbstractFruit { public: virtual void ShowName() = 0;

乾貨分享：什麼是Java設計三大工廠模式？

本文主要會介紹三種工廠模式：簡單工廠，工廠方法，抽象工廠。其中簡單工廠並不屬於 GoF 23 種設計模式，工廠方法和抽象工廠模式則是屬於 GoF 23 種設計模式之中的 2 種。工廠模式作為一種非常常用的設計模式，在日

Spring中常見的設計模式—工廠模式

前言 今天來和小夥伴們分享下設計模式中的工廠模式啦 順便帶來了下面三個問題，一起來看看吧

設計模式の工廠模式

簡單工廠模式 簡單工廠模式是屬於建立型模式，是工廠模式的一種。簡單工廠模式是由一個工廠物件決定創建出哪一種產品類的例項。