c++ 创建型模式-抽象工厂(Abstract_Factory)

抽象工厂模式

1) 意图：

提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体的类。(这里强调一系列，这是抽象工厂和工厂模式的主要区别，工厂模式工厂类和产品种类是一一对应的，而抽象工厂则可以创建多种相关或相互依赖的一系列产品)

2) 结构:

　　其中：

　　　　AbstractFactory为创建抽象产品对象声明的工厂接口

　　　　ConcreteFactory实现创建具体产品对象的工厂

　　　　AbstractProduct为一类产品对象声明一个产品接口

　　　　Product定义一个具体的产品对象

　　　　Client只使用由AbstractFactory和AbstractProduct声明的接口

3) 适用性：

1. 一个系统要独立于它的产品的创建、组合和表示
2. 一个系统要由多个产品系列中的一个来配置
3. 当要强调一系列相关的产品对象的设计以便进行联合使用
4. 当提供一个产品类库，只想显示它们的接口而不是实现时

4) 举例：

 1 #include <iostream>
 2 class  AbstractProductA
 3 {
 4 };
 5 class ProductA1 : public AbstractProductA
 6 {
 7 public:
 8     ProductA1() 
 9     {
10         std::cout << "ProductA1" << std::endl;
11     }
12 };
13 class ProductA2 : public AbstractProductA
14 {
15 public:
16     ProductA2()
17     {
18         std::cout << "ProductA2" << std::endl;
19     }
20 };
21 class  AbstractProductB
22 {
23 };
24 class ProductB1 : public AbstractProductB
25 {
26 public:
27     ProductB1()
28     {
29         std::cout << "ProductB1" << std::endl;
30     }
31 };
32 class ProductB2 : public AbstractProductB
33 {
34 public:
35     ProductB2()
36     {
37         std::cout << "ProductB2" << std::endl;
38     }
39 };
40 
41 
42 class AbstractFactory
43 {
44 public:
45     AbstractFactory() {}
46     virtual ~AbstractFactory() {}
47     virtual AbstractProductA* CreateProductA() = 0;
48     virtual AbstractProductB* CreateProductB() = 0;
49 };
50 class ConcreateFactory1 : public AbstractFactory
51 {
52 public:
53     virtual AbstractProductA* CreateProductA()
54     {
55         return new ProductA1();
56     }
57     virtual AbstractProductB* CreateProductB()
58     {
59         return new ProductB1();
60     }
61 };
62 class ConcreateFactory2 : public AbstractFactory
63 {
64 public:
65     virtual AbstractProductA* CreateProductA()
66     {
67         return new ProductA2();
68     }
69     virtual AbstractProductB* CreateProductB()
70     {
71         return new ProductB2();
72     }
73 };
74 
75 int main()
76 {
77     // 生产第1种AB产品
78     AbstractFactory* factory1 = new ConcreateFactory1();
79     AbstractProductA* productA1 = factory1->CreateProductA();
80     AbstractProductB* productB1 = factory1->CreateProductB();
81 
82     // 生产第2种AB产品
83     AbstractFactory* factory2 = new ConcreateFactory2();
84     AbstractProductA* productA2 = factory1->CreateProductA();
85     AbstractProductB* productB2 = factory1->CreateProductB();
86 
87     delete factory1;
88     delete productA1;
89     delete productB1;
90     delete factory2;
91     delete productA2;
92     delete productB2;
93     system("pause");
94 }