軟體領域中的設計模式為開發人員提供了一種使用專家設計經驗的有效途徑。設計模式中運用了面向物件程式語言的重要特性：封裝、繼承、多型，真正領悟設計模式的精髓是可能一個漫長的過程，需要大量實踐經驗的積累。最近看設計模式的書，對於每個模式，用C++寫了個小例子，加深一下理解。主要參考《大話設計模式》和《設計模式:可複用面向物件軟體的基礎》兩本書。本文介紹工廠模式的實現。

       工廠模式屬於建立型模式，大致可以分為三類，簡單工廠模式、工廠方法模式、抽象工廠模式。聽上去差不多，都是工廠模式。下面一個個介紹，首先介紹簡單工廠模式，它的主要特點是需要在工廠類中做判斷，從而創造相應的產品。當增加新的產品時，就需要修改工廠類。有點抽象，舉個例子就明白了。有一家生產處理器核的廠家，它只有一個工廠，能夠生產兩種型號的處理器核。客戶需要什麼樣的處理器核，一定要顯示地告訴生產工廠。下面給出一種實現方案。

1. enum CTYPE {COREA, COREB};     
2. class SingleCore    
3. {    
4. public:    
5.     virtualvoid Show() = 0;  
6. };    
7. //單核A  
8. class SingleCoreA: public SingleCore    
9. {    
10. public:    
11.     void Show() { cout<<"SingleCore A"<<endl; }    
12. };    
13. //單核B  
14. class SingleCoreB: 
    public SingleCore    
15. {    
16. public:    
17.     void Show() { cout<<"SingleCore B"<<endl; }    
18. };    
19. //唯一的工廠，可以生產兩種型號的處理器核，在內部判斷  
20. class Factory    
21. {    
22. public:     
23.     SingleCore* CreateSingleCore(enum CTYPE ctype)    
24.     {    
25.         if(ctype == COREA) //工廠內部判斷  
26.             returnnew SingleCoreA(); 
    //生產核A  
27.         elseif(ctype == COREB)    
28.             returnnew SingleCoreB(); //生產核B  
29.         else
30.             return NULL;    
31.     }    
32. };    

       這樣設計的主要缺點之前也提到過，就是要增加新的核型別時，就需要修改工廠類。這就違反了開放封閉原則：軟體實體（類、模組、函式）可以擴充套件，但是不可修改。於是，工廠方法模式出現了。所謂工廠方法模式，是指定義一個用於建立物件的介面，讓子類決定例項化哪一個類。Factory Method使一個類的例項化延遲到其子類。

       聽起來很抽象，還是以剛才的例子解釋。這家生產處理器核的產家賺了不少錢，於是決定再開設一個工廠專門用來生產B型號的單核，而原來的工廠專門用來生產A型號的單核。這時，客戶要做的是找好工廠，比如要A型號的核，就找A工廠要；否則找B工廠要，不再需要告訴工廠具體要什麼型號的處理器核了。下面給出一個實現方案。

1. class SingleCore    
2. {    
3. public:    
4.     virtualvoid Show() = 0;  
5. };    
6. //單核A  
7. class SingleCoreA: public SingleCore    
8. {    
9. public:    
10.     void Show() { cout<<"SingleCore A"<<endl; }    
11. };    
12. //單核B  
13. class SingleCoreB: public SingleCore    
14. {    
15. public:    
16.     void Show() { cout<<"SingleCore B"<<endl; }    
17. };    
18. class Factory    
19. {    
20. public:    
21.     virtual SingleCore* CreateSingleCore() = 0;  
22. };    
23. //生產A核的工廠  
24. class FactoryA: public Factory    
25. {    
26. public:    
27.     SingleCoreA* CreateSingleCore() { returnnew SingleCoreA; }    
28. };    
29. //生產B核的工廠  
30. class FactoryB: public Factory    
31. {    
32. public:    
33.     SingleCoreB* CreateSingleCore() { returnnew SingleCoreB; }    
34. };    

       工廠方法模式也有缺點，每增加一種產品，就需要增加一個物件的工廠。如果這家公司發展迅速，推出了很多新的處理器核，那麼就要開設相應的新工廠。在C++實現中，就是要定義一個個的工廠類。顯然，相比簡單工廠模式，工廠方法模式需要更多的類定義。

       既然有了簡單工廠模式和工廠方法模式，為什麼還要有抽象工廠模式呢？它到底有什麼作用呢？還是舉這個例子，這家公司的技術不斷進步，不僅可以生產單核處理器，也能生產多核處理器。現在簡單工廠模式和工廠方法模式都鞭長莫及。抽象工廠模式登場了。它的定義為提供一個建立一系列相關或相互依賴物件的介面，而無需指定它們具體的類。具體這樣應用，這家公司還是開設兩個工廠，一個專門用來生產A型號的單核多核處理器，而另一個工廠專門用來生產B型號的單核多核處理器，下面給出實現的程式碼。

1. //單核  
2. class SingleCore     
3. {    
4. public:    
5.     virtualvoid Show() = 0;  
6. };    
7. class SingleCoreA: public SingleCore      
8. {    
9. public:    
10.     void Show() { cout<<"Single Core A"<<endl; }    
11. };    
12. class SingleCoreB :public SingleCore    
13. {    
14. public:    
15.     void Show() { cout<<"Single Core B"<<endl; }    
16. };    
17. //多核  
18. class MultiCore      
19. {    
20. public:    
21.     virtualvoid Show() = 0;  
22. };    
23. class MultiCoreA : public MultiCore      
24. {    
25. public:    
26.     void Show() { cout<<"Multi Core A"<<endl; }    
27. };    
28. class MultiCoreB : public MultiCore      
29. {    
30. public:    
31.     void Show() { cout<<"Multi Core B"<<endl; }    
32. };    
33. //工廠  
34. class CoreFactory      
35. {    
36. public:    
37.     virtual SingleCore* CreateSingleCore() = 0;  
38.     virtual MultiCore* CreateMultiCore() = 0;  
39. };    
40. //工廠A，專門用來生產A型號的處理器  
41. class FactoryA :public CoreFactory    
42. {    
43. public:    
44.     SingleCore* CreateSingleCore() { returnnew SingleCoreA(); }    
45.     MultiCore* CreateMultiCore() { returnnew MultiCoreA(); }    
46. };    
47. //工廠B，專門用來生產B型號的處理器  
48. class FactoryB : public CoreFactory    
49. {    
50. public:    
51.     SingleCore* CreateSingleCore() { returnnew SingleCoreB(); }    
52.     MultiCore* CreateMultiCore() { returnnew MultiCoreB(); }    
53. };   

        至此，工廠模式介紹完了。利用Rational Rose 2003軟體，給出三種工廠模式的UML圖，加深印象。

         簡單工廠模式的UML圖：

         工廠方法的UML圖：

         抽象工廠模式的UML圖：