C++设计模式-AbstractFactory抽象工厂模式

AbstractFactory

要创建一组相关或者相互依赖的对象

作用：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

UML结构图：

抽象基类：

1）AbstractProductA、AbstractProductB：分别代表两种不同类型的产品，由具体的产品派生类对其实现

2）AbstractFactory：抽象工厂类，提供创建两种产品的接口CreateProductA和CreateProductB，由派生的各个具体工厂类对其实现

说明：

AbstractFactory模式关键就是将这一组对象的创建封装到一个用于创建对象的类（ConcreteFactory）中

Abstract Factory模式和Factory最大的差别就是抽象工厂创建的是一系列相关的对象,其中创建的实现其实采用的就是Factory模式的方法,对于某个实现的有一个派生出来的抽象工厂,另一个实现有另一个派生出来的工厂

抽象工厂需要特别注意的地方就是区分不同类型的产品和这些产品的不同实现.显而易见的,如果有n种产品同时有m中不同的实现,那么根据乘法原理可知有n*m个Factory模式的使用

AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而Factory模式是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，AbstractFactory模式通常都是使用Factory模式实现（ConcreteFactory1）。

代码如下：

Product.h

 1 #ifndef _PRODUCT_H_
 2 #define _PRODUCT_H_
 3
 4 //抽象基类AbstractProductA，代表A类产品的抽象
 5 class AbstractProductA
 6 {
 7 public:
 8     virtual ~AbstractProductA()=0;
 9     virtual void operation()=0;
10 protected:
11     AbstractProductA();//屏蔽构造函数
12 };
13
14 //派生类ProductA1，继承自AbstractProductA，A类产品的一种实现
15 class ProductA1 : public AbstractProductA
16 {
17 public:
18     ProductA1();
19     virtual void operation();
20     virtual ~ProductA1();
21 };
22
23 //派生类ProductA2，继承自AbstractProductA，A类产品的另一种实现
24 class ProductA2:public AbstractProductA
25 {
26 public:
27     ProductA2();
28     virtual void operation();
29     virtual ~ProductA2();
30 };
31
32 //抽象基类AbstractProductB，代表B类产品的抽象
33 class AbstractProductB
34 {
35 public:
36     virtual ~AbstractProductB()=0;
37     virtual void operation()=0;
38 protected:
39     AbstractProductB();//屏蔽构造函数
40 };
41
42 //派生类ProductB1，继承自AbstractProductB，B类产品的一种实现
43 class ProductB1:public AbstractProductB
44 {
45 public:
46     ProductB1();
47     virtual void operation();
48     virtual ~ProductB1();
49 };
50
51 //派生类ProductB2，继承自AbstractProductB，B类产品的另一种实现
52 class ProductB2:public AbstractProductB
53 {
54 public:
55     ProductB2();
56     virtual void operation();
57     virtual ~ProductB2();
58 };
59
60
61 #endif

Factory.h

 1 #ifndef _FACTORY_H_
 2 #define _FACTORY_H_
 3
 4 //AbstractFactory，工厂抽象基类，定义生产A类与B类产品的接口
 5 class AbstractProductA;
 6 class AbstractProductB;
 7 class AbstractFactory
 8 {
 9 public:
10     virtual ~AbstractFactory()=0;
11     virtual AbstractProductA* CreateProductA()=0;
12     virtual AbstractProductB* CreateProductB()=0;
13 protected:
14     AbstractFactory();
15 };
16
17 //ConcreteFactory1，派生类，继承自AbstractFactory
18 //实现继承的接口，生产产品A和B的一种实现
19 class ConcreteFactory1:public AbstractFactory
20 {
21 public:
22     ConcreteFactory1();
23     ~ConcreteFactory1();
24     virtual AbstractProductA* CreateProductA();
25     virtual AbstractProductB* CreateProductB();
26 };
27
28 //ConcreteFactory2，派生类，继承自AbstractFactory
29 //实现继承的接口，生产产品A和B的另一种实现
30 class ConcreteFactory2:public AbstractFactory
31 {
32 public:
33     ConcreteFactory2();
34     ~ConcreteFactory2();
35     virtual AbstractProductA* CreateProductA();
36     virtual AbstractProductB* CreateProductB();
37 };
38
39 #endif

Product.cpp

 1 #include "Product.h"
 2 #include <iostream>
 3
 4 using namespace std;
 5
 6 //AbstractProductA
 7 AbstractProductA::AbstractProductA()
 8 {
 9     cout << "AbstractProductA..." << endl;
10 }
11
12 AbstractProductA::~AbstractProductA()
13 {
14     cout << "~AbstractProductA..." << endl;
15 }
16
17 //ProductA1
18 ProductA1::ProductA1()
19 {
20     cout << "ProductA1..." << endl;
21 }
22
23 ProductA1::~ProductA1()
24 {
25     cout << "~ProductA1..." << endl;
26 }
27
28 void ProductA1::operation()
29 {}
30
31 //ProductA2
32 ProductA2::ProductA2()
33 {
34     cout << "ProductA2..." << endl;
35 }
36
37 ProductA2::~ProductA2()
38 {
39     cout << "~ProductA2..." << endl;
40 }
41
42 void ProductA2::operation()
43 {}
44
45 //AbstractProductB
46 AbstractProductB::AbstractProductB()
47 {
48     cout << "AbstractProductB..." << endl;
49 }
50
51 AbstractProductB::~AbstractProductB()
52 {
53     cout << "~AbstractProductB..." << endl;
54 }
55
56 //ProductB1
57 ProductB1::ProductB1()
58 {
59     cout << "ProductB1..." << endl;
60 }
61
62 ProductB1::~ProductB1()
63 {
64     cout << "~ProductB1..." << endl;
65 }
66
67 void ProductB1::operation()
68 {}
69
70 //ProductB2
71 ProductB2::ProductB2()
72 {
73     cout << "ProductB2..." << endl;
74 }
75
76 ProductB2::~ProductB2()
77 {
78     cout << "~ProductB2..." << endl;
79 }
80
81 void ProductB2::operation()
82 {}

Factory.cpp

 1 #include "Factory.h"
 2 #include "Product.h"
 3 #include <iostream>
 4
 5 using namespace std;
 6
 7 AbstractFactory::AbstractFactory()
 8 {
 9     cout << "AbstractFactory..." << endl;
10 }
11
12 AbstractFactory::~AbstractFactory()
13 {
14     cout << "~AbstractFactory..." << endl;
15 }
16
17 ConcreteFactory1::ConcreteFactory1()
18 {
19     cout << "ConcreteFactory1..." << endl;
20 }
21
22 ConcreteFactory1::~ConcreteFactory1()
23 {
24     cout << "~ConcreteFactory1..." << endl;
25 }
26
27 AbstractProductA* ConcreteFactory1::CreateProductA()
28 {
29     return new ProductA1();
30 }
31
32 AbstractProductB* ConcreteFactory1::CreateProductB()
33 {
34     return new ProductB1();
35 }
36
37 ConcreteFactory2::ConcreteFactory2()
38 {
39     cout << "ConcreteFactory2..." << endl;
40 }
41
42 ConcreteFactory2::~ConcreteFactory2()
43 {
44     cout << "~ConcreteFactory2..." << endl;
45 }
46
47 AbstractProductA* ConcreteFactory2::CreateProductA()
48 {
49     return new ProductA2();
50 }
51
52 AbstractProductB* ConcreteFactory2::CreateProductB()
53 {
54     return new ProductB2();
55 }

main.cpp

 1 #include <iostream>
 2 #include "Factory.h"
 3 #include "Product.h"
 4
 5 using namespace std;
 6
 7 int main()
 8 {
 9     AbstractFactory* fa1 = new ConcreteFactory1();
10     AbstractProductA* a1 = fa1->CreateProductA();
11     AbstractProductB* b1 = fa1->CreateProductB();
12
13     cout << endl;
14     AbstractFactory* fa2 = new ConcreteFactory2();
15     AbstractProductA* a2 = fa2->CreateProductA();
16     AbstractProductB* b2 = fa2->CreateProductB();
17
18     cout << endl;
19     delete fa1;
20     delete a1;
21     delete b1;
22
23     cout << endl;
24     delete fa2;
25     delete a2;
26     delete b2;
27
28     return 0;
29 }

C++设计模式-AbstractFactory抽象工厂模式相关推荐

乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factory Pattern)
原文:乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factory Pattern) [索引页] [源码下载] 乐在其中设计模式(C#) - 抽象工厂模式(Abstract Facto ...
设计模式之四(抽象工厂模式第三回合)
原文:设计模式之四(抽象工厂模式第三回合) 前言抽象工厂模式:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 抽象工厂模式最大的好处便是易于交换产品系列,由于具体工厂类,例如I ...
设计模式-04抽象工厂模式
设计模式-04抽象工厂模式文章中涉及到的代码,请自行下载 https://gitee.com/pan_xiao_lei123/designmode.git 前面介绍的工厂方法模式中考虑的是一类产品的 ...
C#设计模式(4)——抽象工厂模式
C#设计模式(4)--抽象工厂模式一.引言在上一专题中介绍了工厂方法模式,工厂方法模式是为了克服简单工厂模式的缺点而设计出来的,简单工厂模式的工厂类随着产品类的增加需要增加额外的代码),而工厂方法 ...
设计模式系列·抽象工厂模式
前言以小说的笔法写的设计模式系列文章,你绝对看得懂![首发于公众号:"聊聊代码"] 设计模式系列·王小二需求历险记(一) 设计模式系列·王小二需求历险记(二) 设计模式系列·封装 ...
设计模式三—抽象工厂模式
设计模式三-抽象工厂模式一.定义抽象工厂模式是工厂方法模式的进一步抽象.如果产品簇中只有一种产品,则退化为工厂方法模式. 二.原理图三.代码实例 * 苹果和土豆是园丁1的杰作 * 葡萄和西红柿是 ...
设计模式复习-抽象工厂模式
设计模式复习-抽象工厂模式有两种硬件,PC和Phone,有两种系统,Windows和Linux,现在假设PC和Phone上全都能安装这两个系统,并且将来硬件不会在变化,但是系统可能需要扩展,比如扩展 ...
python抽象工厂模式_Python设计模式之抽象工厂模式
Python设计模式之抽象工厂模式这篇文章主要为大家详细介绍了Python设计模式之抽象工厂模式,感兴趣的小伙伴们可以参考一下 python面向对象编程入门,我们需要不断学习进步 "&qu ...
设计模式(4)--AbstractFactory(抽象工厂模式)--创建型
1.模式定义: 抽象工厂是应对产品族概念的,提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们的具体类 2.模式特点: 抽象工厂模式为创建一组对象提供了一种解决方案.与工厂方法模式相比,抽象工 ...

C++设计模式-AbstractFactory抽象工厂模式

C++设计模式-AbstractFactory抽象工厂模式相关推荐

最新文章

热门文章