1：簡單工廠模式

　　簡單工廠模式是屬於建立型模式，又叫做靜態工廠方法(static Factory Method)模式，簡單工廠模式是由一個工廠物件決定創建出來哪一種產品類的例項.

　　簡單工廠模式的實質是由一個工廠類根據傳入的引數，動態決定應該建立哪一類產品類(這些產品類繼承自一個父類或介面)的例項。打個比方

　　假設有一個工廠，他能生產出A、B兩種產品。當客戶需要產品的時候一定要告訴共產是哪種產品，是A還是B。當新增加一種新產品的時候，那麼就要去修改工廠的類。　

 1 // Factory.cpp : 定義控制檯應用程式的入口點。
 2 //
 3 
 4 #include "stdafx.h
 
"
 5 #include<iostream>
 6 
 7 using namespace std;
 8 
 9 class Product
10 {
11 public:
12     virtual void show() = 0;  
13 };
14 
15 class Product_A : public Product
16 {
17 public:
18     void show()
19     {
20         cout << "Product_A" << endl;
21     }
22 };
23 
24 class Product_B : public
 
 Product
25 {
26 public:
27     void show()
28     {
29         cout << "Product_B" << endl;
30     }
31 };
32 
33 class Factory
34 {
35 public:
36     Product* Create(int i)
37     {
38         switch (i)
39         {
40         case 1:
41             return new Product_A;
42             break
 
;
43         case 2:
44             return new Product_B;
45             break;
46         default:
47             break;
48         }
49     }
50 };
51 
52 int main()
53 {
54     Factory *factory = new Factory();
55     factory->Create(1)->show();
56     factory->Create(2)->show();
57     system("pause");
58     return 0;
59 }

二：工廠方法模式：

　　上面的簡單工廠模式的缺點是當新增產品的時候就要去修改工廠的類，這就違反了開放封閉原則，(類、模組、函式)可以擴充套件，但是不可以修改，於是，就出現了工廠方法模式。所謂工廠方法模式，是指定義一個用於建立物件的介面，讓子類決定例項化哪一個類。打個比方

現在有A、B兩種產品，那麼久開兩個工廠。工廠A負責生產A產品，工廠B負責生產B種產品。這時候客戶不需要告訴共產生產哪種產品了，只需要告訴共產生產就可以了。

 1 #include "stdafx.h"
 2 #include<iostream>
 3 
 4 using namespace std;
 5 
 6 class Product
 7 {
 8 public:
 9     virtual void show() = 0;  
10 };
11 
12 class Product_A : public Product
13 {
14 public:
15     void show()
16     {
17         cout << "Product_A" << endl;
18     }
19 };
20 
21 class Product_B : public Product
22 {
23 public:
24     void show()
25     {
26         cout << "Product_B" << endl;
27     }
28 };
29 
30 class Factory
31 {
32 public:
33     virtual Product* create() = 0;
34 };
35 
36 class Factory_A : public Factory
37 {
38 public:
39     Product* create()
40     {
41         return new Product_A;
42     }
43 };
44 
45 class Factory_B : public Factory
46 {
47 public:
48     Product* create()
49     {
50         return new Product_B;
51     }
52 };
53 
54 int main()
55 {
56     Factory_A* productA = new Factory_A();
57     Factory_B* productB = new Factory_B();
58 
59     productA->create()->show();
60     productB->create()->show();
61     system("pause");
62     return 0;
63 }

抽象工廠模式

　　為什麼要有抽象工廠模式，假如我們A產品中有A1和A2兩種型號的廠品，B產品中有B1和B2兩種型號的廠品，那怎麼辦，上面兩種工廠模式就不能解決了。這個時候抽象工廠模式就登場了。還是開設兩家工廠，工廠A負責生產A1 、A2型號產品，B工廠負責生產B1、B2型號的產品。

提供一個建立一系列相關或相互依賴物件的介面，而無需指定它們具體的類。  適用性：一個系統要獨立於它的產品的建立、組合和表示時。一個系統要由多個產品系列中的一個來配置時。當你要強調一系列相關的產品物件的設計以便進行聯合使用時。當你提供一個產品類庫，而只想顯示它們的介面而不是實現時。

 1 #include <iostream>    
 2 using namespace std;  
 3   
 4 //定義抽象類  
 5 class product1  
 6 {  
 7 public:  
 8     virtual void show() = 0;  
 9 };  
10   
11 //定義具體類  
12 class product_A1 :public product1  
13 {  
14 public:  
15     void show(){ cout << "product A1" << endl; }  
16 };  
17   
18 class product_B1 :public product1  
19 {  
20 public:  
21     void show(){ cout << "product B1" << endl; }  
22 };  
23   
24 //定義抽象類  
25 class product2  
26 {  
27 public:  
28     virtual void show() = 0;  
29 };  
30   
31 //定義具體類  
32 class product_A2 :public product2  
33 {  
34 public:  
35     void show(){ cout << "product A2" << endl; }  
36 };  
37   
38 class product_B2 :public product2  
39 {  
40 public:  
41     void show(){ cout << "product B2" << endl; }  
42 };  
43   
44   
45 class Factory  
46 {  
47 public:  
48     virtual product1 *creat1() = 0;  
49     virtual product2 *creat2() = 0;  
50 };  
51   
52 class FactoryA  
53 {  
54 public:  
55     product1 *creat1(){ return new product_A1(); }  
56     product2 *creat2(){ return new product_A2(); }  
57 };  
58   
59 class FactoryB  
60 {  
61 public:  
62     product1 *creat1(){ return new product_B1(); }  
63     product2 *creat2(){ return new product_B2(); }  
64 };  
65   
66 int main()  
67 {  
68     FactoryA *factoryA = new FactoryA();  
69     factoryA->creat1()->show();  
70     factoryA->creat2()->show();  
71   
72     FactoryB *factoryB = new FactoryB();  
73     factoryB->creat1()->show();  
74     factoryB->creat2()->show();  
75   
76     return 0;  
77 }