C++設計模式之九--Prototype原型模式

轉自：http://www.cnblogs.com/jiese/archive/2013/07/01/3164428.html

 作用：

用原型實例指定創建對象的種類，並且通過拷貝這些原型創建新的對象。

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模式重在從自身複製自己創建新類。