C++ 深入淺出工廠模式（進階篇）

介紹

前文初始篇C++ 深入淺出工廠模式（初始篇），主要闡述了簡單工廠模式、工廠方法模式和抽象工廠模式的結構、特點和缺陷等。以上三種方式，在新增產品時，要么修改工廠類，要么需新增具體的工廠類，說明工廠類的封裝性還不夠好。

本文進階篇，主要是將工廠類的封裝性提高，達到新增產品時，也不需要修改工廠類，不需要新增具體的工廠類。封裝性高的工廠類特點是擴展性高、復用性也高。

模板工廠

針對工廠方法模式封裝成模板工廠類，那么這樣在新增產品時，是不需要新增具體的工廠類，減少了代碼的編寫量。

UML圖：

模板工廠代碼：

• Shoes和Clothe，分別為鞋子和衣服的抽象類（基類）
• NiKeShoes和UniqloClothe，分別為耐克鞋子和優衣庫衣服具體產品類。

// 基類 鞋子
class Shoes
{
public:
    virtual void Show() = 0;
    virtual ~Shoes() {}
};

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

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

// 優衣庫衣服
class UniqloClothe : public Clothe
{
public:
    void Show()
    {
        std::cout << "我是優衣庫衣服，我的廣告語：I am Uniqlo" << std::endl;
    }
};

• AbstractFactory為抽象模板工廠類，其中模板參數：AbstractProduct_t 產品抽象類，如Shoes、Clothe
• ConcreteFactory為具體模板工廠類，其中模板參數：AbstractProduct_t 產品抽象類（如Shoes、Clothe），ConcreteProduct_t 產品具體類（如NiKeShoes、UniqloClothe）

// 抽象模板工廠類
// 模板參數：AbstractProduct_t 產品抽象類
template <class AbstractProduct_t>
class AbstractFactory
{
public:
    virtual AbstractProduct_t *CreateProduct() = 0;
    virtual ~AbstractFactory() {}
};

// 具體模板工廠類
// 模板參數：AbstractProduct_t 產品抽象類，ConcreteProduct_t 產品具體類
template <class AbstractProduct_t, class ConcreteProduct_t>
class ConcreteFactory : public AbstractFactory<AbstractProduct_t>
{
public:
    AbstractProduct_t *CreateProduct()
    {
        return new ConcreteProduct_t();
    }
};

• main函數，根據不同類型的產品，構造對應的產品的工廠對象，便可通過對應產品的工廠對象創建具體的產品對象。

int main()
{
    // 構造耐克鞋的工廠對象
    ConcreteFactory<Shoes, NiKeShoes> nikeFactory;
    // 創建耐克鞋對象
    Shoes *pNiKeShoes = nikeFactory.CreateProduct();
    // 打印耐克鞋廣告語
    pNiKeShoes->Show();

    // 構造優衣庫衣服的工廠對象
    ConcreteFactory<Clothe, UniqloClothe> uniqloFactory;
    // 創建優衣庫衣服對象
    Clothe *pUniqloClothe = uniqloFactory.CreateProduct();
    // 打印優衣庫廣告語
    pUniqloClothe->Show();

    // 釋放資源
    delete pNiKeShoes;
    pNiKeShoes = NULL;

    delete pUniqloClothe;
    pUniqloClothe = NULL;

    return 0;
}

• 輸出結果：

[root@lincoding factory]# ./templateFactory 
我是耐克球鞋，我的廣告語：Just do it
我是優衣庫衣服，我的廣告語：I am Uniqlo

---

產品注冊模板類+單例工廠模板類

前面的模板工廠雖然在新增產品的時候，不需要新增具體的工廠類，但是缺少一個可以統一隨時隨地獲取指定的產品對象的類。

還有改進的空間，我們可以把產品注冊的對象用std::map的方式保存，通過key-valve的方式可以輕松簡單的獲取對應的產品對象實例。

實現大致思路：

• 把產品注冊的功能封裝成產品注冊模板類。注冊的產品對象保存在工廠模板類的std::map，便於產品對象的獲取。

• 把獲取產品對象的功能封裝成工廠模板類。為了能隨時隨地獲取指定產品對象，則把工廠設計成單例模式。

UML圖：

產品注冊模板類+單例工廠模板類：

• IProductRegistrar為產品注冊抽象類，模板參數 ProductType_t 表示的類是產品抽象類（如Shoes、Clothe）。提供了產品對象創建的純虛函數CreateProduct。
• ProductFactory為工廠模板類，模板參數 ProductType_t 表示的類是產品抽象類（如Shoes、Clothe）。用於保存注冊產品對象到std::map中和獲取對應的產品對象。
• ProductRegistrar為產品注冊模板類，模板參數 ProductType_t 表示的類是產品抽象類（如Shoes、Clothe），ProductImpl_t 表示的類是具體產品（如NikeShoes、UniqloClothe）。用於注冊產品到工廠類和創建產品實例對象。

// 基類，產品注冊模板接口類
// 模板參數 ProductType_t 表示的類是產品抽象類
template <class ProductType_t>
class IProductRegistrar
{
public:
   // 獲取產品對象抽象接口
   virtual ProductType_t *CreateProduct() = 0;

protected:
   // 禁止外部構造和虛構, 子類的"內部"的其他函數可以調用
   IProductRegistrar() {}
   virtual ~IProductRegistrar() {}

private:
   // 禁止外部拷貝和賦值操作
   IProductRegistrar(const IProductRegistrar &);
   const IProductRegistrar &operator=(const IProductRegistrar &);
};

// 工廠模板類，用於獲取和注冊產品對象
// 模板參數 ProductType_t 表示的類是產品抽象類
template <class ProductType_t>
class ProductFactory
{
public:
   // 獲取工廠單例，工廠的實例是唯一的
   static ProductFactory<ProductType_t> &Instance()
   {
      static ProductFactory<ProductType_t> instance;
      return instance;
   }

   // 產品注冊
   void RegisterProduct(IProductRegistrar<ProductType_t> *registrar, std::string name)
   {
      m_ProductRegistry[name] = registrar;
   }

   // 根據名字name，獲取對應具體的產品對象
   ProductType_t *GetProduct(std::string name)
   {
      // 從map找到已經注冊過的產品，並返回產品對象
      if (m_ProductRegistry.find(name) != m_ProductRegistry.end())
      {
         return m_ProductRegistry[name]->CreateProduct();
      }

      // 未注冊的產品，則報錯未找到
      std::cout << "No product found for " << name << std::endl;

      return NULL;
   }

private:
   // 禁止外部構造和虛構
   ProductFactory() {}
   ~ProductFactory() {}

   // 禁止外部拷貝和賦值操作
   ProductFactory(const ProductFactory &);
   const ProductFactory &operator=(const ProductFactory &);

   // 保存注冊過的產品，key:產品名字 , value:產品類型
   std::map<std::string, IProductRegistrar<ProductType_t> *> m_ProductRegistry;
};

// 產品注冊模板類，用於創建具體產品和從工廠里注冊產品
// 模板參數 ProductType_t 表示的類是產品抽象類（基類），ProductImpl_t 表示的類是具體產品（產品種類的子類）
template <class ProductType_t, class ProductImpl_t>
class ProductRegistrar : public IProductRegistrar<ProductType_t>
{
public:
   // 構造函數，用於注冊產品到工廠，只能顯示調用
   explicit ProductRegistrar(std::string name)
   {
      // 通過工廠單例把產品注冊到工廠
      ProductFactory<ProductType_t>::Instance().RegisterProduct(this, name);
   }

   // 創建具體產品對象指針
   ProductType_t *CreateProduct()
   {
      return new ProductImpl_t();
   }
};

• main函數，通過ProductRegistrar注冊各種不同類型產品，在統一由ProductFactory單例工廠獲取指定的產品對象。

int main()
{
   // ========================== 生產耐克球鞋過程 ===========================//
   // 注冊產品種類為Shoes（基類），產品為NiKe（子類）到工廠，產品名為nike
   ProductRegistrar<Shoes, NiKeShoes> nikeShoes("nike");
   // 從工廠獲取產品種類為Shoes，名稱為nike的產品對象
   Shoes *pNiKeShoes = ProductFactory<Shoes>::Instance().GetProduct("nike");
   // 顯示產品的廣告語
   pNiKeShoes->Show();
   // 釋放資源
   if (pNiKeShoes)
   {
      delete pNiKeShoes;
   }

   // ========================== 生產優衣庫衣服過程 ===========================//
   // 注冊產品種類為Clothe（基類），產品為UniqloClothe（子類）到工廠，產品名為uniqlo
   ProductRegistrar<Clothe, UniqloClothe> adidasShoes("uniqlo");
   // 從工廠獲取產品種類為Shoes，名稱為adidas的產品對象
   Clothe *pUniqloClothe = ProductFactory<Clothe>::Instance().GetProduct("uniqlo");
   // 顯示產品的廣告語
   pUniqloClothe->Show();
   // 釋放資源
   if (pUniqloClothe)
   {
      delete pUniqloClothe;
   }

   return 0;
}

• 輸出結果：

[root@lincoding factory]# ./singleFactory 
我是耐克球鞋，我的廣告語：Just do it
我是優衣庫衣服，我的廣告語：I am Uniqlo

---

總結

將工廠方法模式改良成模板工廠，雖然可以解決產品新增時，不需要新增具體工廠類，但是缺少一個可以隨時隨地獲取產品對象的方式，說明還有改進的空間。

將模板工廠改良成產品注冊模板類+單例工廠模板類，產品注冊模板類用於注冊不同類型的產品，單例工廠模板類用於獲取指定已注冊的產品對象。這種方式，可以把工廠模式中產品的注冊和獲取的主要功能很好的抽象成兩個類，並且使用單例模式使得工廠類可以隨時隨地獲取已注冊的產品對象。

所以產品注冊模板類+單例工廠模板類的工廠模式，達到了開閉法則，並且擴展性高和封裝度高。

PS：想學習更多單例模式，可以參考C++ 線程安全的單例模式總結文章閱讀。

---