文章目錄

• • • • 1. 解決問題
      • 2. 應用場景
      • 3. 實現如下
      • • C++實現
        • C語言實現
      • 4. 缺點

1. 解決問題

在簡單工廠模式中，我們使用賣衣服進行舉例，同一種工廠可以賣很多不同種類的衣服，工廠只是將衣服的生產過程進行了封裝。

當我們增加衣服種類的時候，在簡單工廠模式中需要修改工廠的代碼，破壞了類的開閉原則（對擴展開發， 對修改關閉），同時增加測試成本。

此時為了避免這種問題的出現，我們推出工廠方法模式，為每個商品封裝指定的工廠方法，這樣商品種類增加時對于工廠只需要增加指定的工廠就可以了。

2. 應用場景

• 邏輯中會經常使用到該類對象（需要經常進行new、malloc操作）
• 邏輯后續會有一定規模，最好這個時候就將對象的創建和使用分離
• 后續會小范圍擴展產品類型
• 程序規模比較大，不希望每次增加產品后都對之前邏輯重新測試

3. 實現如下

C++實現

實現功能：還是賣衣服，針對每一種衣服創建指定的工廠，由工廠封裝對象的創建過程。

#include <iostream>using namespace std;/*工廠的可以制造的衣服種類*/
enum ClothType{hat,paths};class Cloth{public:virtual void createCloth(void) = 0;virtual ~Cloth(){} //定義為虛函數，對象空間回收時則會調用子類的析構函數
};/*帽子類*/
class Hat: public Cloth{public:Hat(){cout << "Hat::hat()" << endl;}virtual void createCloth(void) {cout << "Hat::createHat()" << endl;}~Hat(){cout << "Hat::delete()" << endl;}
};/*褲子類*/
class Paths: public Cloth{public:Paths(){cout << "Paths::paths()" << endl;}virtual void createCloth(void) {cout << "Paths::createPaths()" << endl;}~Paths(){cout << "Paths::delete()" << endl;}
};/*工廠方法類，用來創建工廠*/
class Factory{
public:virtual Cloth *CreateProduct() = 0;    
};/*帽子工廠，創建帽子*/
class FactoryHat : public Factory
{
public:Cloth *CreateProduct(){return new Hat ();}
};/*褲子工廠，創建褲子*/
class FactoryPaths : public Factory
{
public:Cloth *CreateProduct(){return new Paths ();}
};int main()
{Factory *factoryHat = new FactoryHat();Cloth *hat = factoryHat -> CreateProduct();hat -> createCloth();Factory *factoryPaths = new FactoryPaths();Cloth *paths = factoryPaths -> CreateProduct();paths -> createCloth();if(NULL != factoryHat) {delete factoryHat;factoryHat = NULL;}if(NULL != factoryPaths) {delete factoryPaths;factoryPaths = NULL;}if(NULL != hat) {delete hat;hat = NULL;}if(NULL != paths) {delete paths;paths = NULL;}return 0;
}

C語言實現

實現功能：生產橘子和蘋果兩種水果

/*用C語言實現工廠方法模式*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>enum {GRAPE,APPLE};typedef struct _Apple
{void (*print_apple)();
}Apple;typedef struct _Grape
{void (*print_grape)();
}Grape;void print_apple()
{printf("apple!\n");
}void print_grape()
{printf("grape!\n");
}Apple* sell_apple()
{Apple* pApple = (Apple*)malloc(sizeof(Apple));assert(NULL != pApple);pApple->print_apple = print_apple;return pApple;
}Grape* sell_grape()
{Grape* pGrape = (Grape*)malloc(sizeof(Grape));assert(NULL != pGrape);pGrape->print_grape = print_grape;return pGrape;
}typedef struct _FruitShop
{void* (*sell_fruit)();
}FruitShop;FruitShop* create_fruit_shop(int fruit)
{FruitShop* pFruitShop = (FruitShop*)malloc(sizeof(FruitShop));assert(NULL != pFruitShop);if (GRAPE == fruit){pFruitShop->sell_fruit = (void *(*)())sell_apple;}else if(APPLE == fruit){pFruitShop->sell_fruit = (void *(*)())sell_grape;}else{return NULL;}return pFruitShop;
}int main()
{FruitShop* apple = NULL;Apple* a = NULL;apple = create_fruit_shop(APPLE);a = (Apple *)apple->sell_fruit();a->print_apple();FruitShop* grape = NULL;Grape* g = NULL;grape = create_fruit_shop(GRAPE);g = (Grape*)grape->sell_fruit();g->print_grape();if(g != NULL){delete g;}if(grape != NULL){delete grape;}if(a != NULL){delete a;}if(apple != NULL){delete apple;}return 0;
}

4. 缺點

1、后續產品種類特別多的時候，需要建立很多工廠，導致程序熵值太大
2、對于有多個依賴關系的種類，如果仍然建立多個工廠，則會增加很多重復邏輯

總結

以上是生活随笔為你收集整理的设计模式 之美 -- 工厂方法模式的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。