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

介紹前文初始篇 "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++ 線程安全的單例模式總結文章閱讀。