介紹

前文初始篇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++ 執行緒安全的單例模式總結文章閱讀。