原型(Prototype)模式是用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。
思想:克 隆一个已有的类的实例(大家相比都用过甚至写过类的Clone实现,应该很容易理解了)。
场景:应 用Clone的场景应该说非常多,理想情况下我当然希望任何类都能Clone, 需要的时候就能Clone一份一模一样的出来。
实现:这 里将的实现主要之实现的表现形式,而不是如何用具体的语言来实现。因此,只要为需要Clone能力 的类定义一个Clone方法就行。当然,一般,主流的程序语言框架都已经定义了通用的Clone接 口(当然也可以自己定义),继承并实现该接口和方法就好。
实例:Prototype模式提供了一个通过已存在对象进行新对象创建的接口(Clone), Clone()实现和具体的语言相关,在C++中通过拷贝构造函数实现。
UML图如下:
代码如下:
Prototype.h
1 #ifndef _PROTOTYPE_H_
2 #define _PROTOTYPE_H_
3
4 /*Prototype模式提供了一个通过已存在对象进行新对象创建的接口(Clone)
5 Clone()实现和具体的语言相关,在C++中通过拷贝构造函数实现
6
7 作用:
8 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。
9
10 */
11
12 /*Prototype原型基类,定义Clone接口函数
13 */
14 class Prototype
15 {
16 protected:
17 Prototype();
18 public:
19 virtual Prototype* Clone() const=0;//定义Clone接口,根据不同的派生类来实例化对象
20 virtual ~Prototype();
21 };
22
23 //派生自Prototype,实现其接口函数
24 class ConcretePrototype1:public Prototype
25 {
26 public:
27 ConcretePrototype1();//构造函数
28 ~ConcretePrototype1();//析构函数
29 ConcretePrototype1(const ConcretePrototype1&);//拷贝构造函数
30 virtual Prototype* Clone() const;//实现基类定义的Clone接口,内部调用拷贝构造函数实现复制功能
31 };
32
33 //派生自Prototype,实现其接口函数
34 class ConcretePrototype2:public Prototype
35 {
36 public:
37 ConcretePrototype2();//构造函数
38 ~ConcretePrototype2();//析构函数
39 ConcretePrototype2(const ConcretePrototype2&);//拷贝构造函数
40 virtual Prototype* Clone() const;//实现基类定义的Clone接口,内部调用拷贝构造函数实现复制功能
41 };
42
43 #endif
Prototype.cpp
1 #include "Prototype.h"
2 #include "iostream"
3
4 using namespace std;
5
6 ////Prototype
7 Prototype::Prototype()
8 {
9 cout<<"Prototype"<<endl;
10 }
11
12 Prototype::~Prototype()
13 {
14 cout<<"~Prototype"<<endl;
15 }
16
17 //ConcretePrototype1
18 ConcretePrototype1::ConcretePrototype1()
19 {
20 cout<<"ConcretePrototype1"<<endl;
21 }
22
23 ConcretePrototype1::~ConcretePrototype1()
24 {
25 cout<<"~ConcretePrototype1"<<endl;
26 }
27
28 ConcretePrototype1::ConcretePrototype1(const ConcretePrototype1& cp)
29 {
30 cout<<"ConcretePrototype1 copy"<<endl;
31 }
32
33 Prototype* ConcretePrototype1::Clone() const
34 {
35 return new ConcretePrototype1(*this);
36 }
37
38 //ConcretePrototype2
39 ConcretePrototype2::ConcretePrototype2()
40 {
41 cout<<"ConcretePrototype2"<<endl;
42 }
43
44 ConcretePrototype2::~ConcretePrototype2()
45 {
46 cout<<"~ConcretePrototype2"<<endl;
47 }
48
49 ConcretePrototype2::ConcretePrototype2(const ConcretePrototype2& cp)
50 {
51 cout<<"ConcretePrototype2 copy"<<endl;
52 }
53
54 Prototype* ConcretePrototype2::Clone() const
55 {
56 return new ConcretePrototype2(*this);
57 }
main.cpp
1 #include "Prototype.h"
2 #include <iostream>
3 using namespace std;
4
5 int main()
6 {
7 /*原型模式作用:用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。
8 Prototype模式重在从自身复制自己创建新类,隐藏(不需知道)对象创建的细节
9 */
10
11 /*1、用原型实例p1指定创建对象的种类ConcretePrototype1 */
12 Prototype* p1 = new ConcretePrototype1();
13
14 /*2、通过拷贝这些原型创建新的对象 */
15 Prototype* p2 = p1->Clone();
16
17 cout<< "------------------------" << endl;
18
19 Prototype* p3 = new ConcretePrototype2();
20 Prototype* p4 = p3->Clone();
21
22 cout<< "------------------------" << endl;
23
24 delete p1;
25 delete p2;
26 cout<< "------------------------" << endl;
27
28 delete p3;
29 delete p4;
30
31 return 0;
32 }
Prototype模式和Builder模式、AbstractFactory模式都是通过一个类(对象实例)来专门负责对象的创建工作(工厂对象),它们之间的区别是:Builder模式重在复杂对象的一步步创建(并不直接返回对象),AbstractFactory模式重在产生多个相互依赖类的对象,而Prototype模式重在从自身复制自己创建新类。
重构成本:极低。不多解释了吧。