原型模式概述

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

Prototype原型模式是一种创建型设计模式，Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。

组成模型

客户（Client）角色：客户类提出创建对象的请求。
抽象原型（Prototype）角色：这是一个抽象角色，通常由一个C#接口或抽象类实现。此角色给出所有的具体原型类所需的接口。在C#中，抽象原型角色通常实现了ICloneable接口。
具体原型（Concrete Prototype）角色：被复制的对象。此角色需要实现抽象原型角色所要求的接口。

应对问题

它主要面对的问题是：“某些结构复杂的对象”的创建工作；由于需求的变化，这些对象经常面临着剧烈的变化，但是他们却拥有比较稳定一致的接口。

[cpp] view plain copy print ?

1. #include <iostream>  
2. #include <cstring>  
3.   
4.   
5.   
6. /// 原型抽象类 -=> 对应于抽象原型（Prototype）角色  
7. class Prototype  
8. {  
9. public :  
10.     Prototype( ){  };  
11.   
12.     virtual ~Prototype( ){ };  
13.   
14.     virtual Prototype* Clone( ) const = 0;  // 拷贝函数，原型模式的精髓所在  
15.   
16.     virtual void Show( ) const = 0;                // 显示当前信息  
17. };  
18.   
19.   
20.   
21.   
22.   
23. /// 原型类A -=> 对应于具体原型（Concrete Prototype）角色：  
24. class PrototypeA : public Prototype  
25. {  
26. public :  
27.     PrototypeA(const char *name = NULL)           // 构造函数  
28.     {  
29.         if(name == NULL)  
30.         {  
31.             this->m_name = new char[1];  
32.             strcpy(this->m_name, "");  
33.         }  
34.         else  
35.         {  
36.             this->m_name = new char[strlen(name) + 1];  
37.             strcpy(this->m_name, name);  
38.         }  
39.     }  
40.   
41.     PrototypeA(const PrototypeA &Prototype)               // 实现深拷贝  
42.     {  
43.         this->m_name = new char[strlen(Prototype.m_name)];  
44.         strcpy(this->m_name, Prototype.m_name);  
45.     }  
46.   
47.     virtual ~PrototypeA( )                 // 虚析构函数  
48.     {  
49.         delete[] this->m_name;  
50.     }  
51.   
52.     Prototype* Clone( ) const  // 拷贝函数，原型模式的精髓所在  
53.     {  
54.         return new PrototypeA(*this);  
55.     }  
56.   
57.     void Show( ) const                // 显示当前函数信息  
58.     {  
59.     std::cout <<"PrototypeA's name is " <<this->m_name <<std::endl;  
60.     }  
61. protected :  
62.     char *m_name;  
63. };  
64.   
65.   
66. /// 原型类B -=> 对应于具体原型（Concrete Prototype）角色：  
67. class PrototypeB : public Prototype  
68. {  
69. public :  
70.     PrototypeB(int no)          // 构造函数  
71.     {  
72.         m_no = no;  
73.     }  
74.     PrototypeB(const PrototypeB &prototype)               //  
75.     {  
76.         this->m_no = prototype.m_no;  
77.     }  
78.   
79.     virtual ~PrototypeB( )                // 虚析构函数  
80.     {  
81.   
82.     }  
83.     Prototype* Clone( ) const  // 拷贝函数，原型模式的精髓所在  
84.     {  
85.         return new PrototypeB(*this);  
86.     }                      // 获取名字的函数  
87.     void Show( ) const                // 显示当前函数信息  
88.     {  
89.         std::cout <<"PrototypeB's no is " <<this->m_no <<std::endl;  
90.     }  
91. protected :  
92.     int     m_no;  
93. };  
94.   
95.   
96.   
97.   
98. int main()  
99. {  
100.     Prototype *r1 = new PrototypeA("A");  
101.     Prototype *r2 = r1->Clone( );  
102.   
103.     // r1和r2是相同内容的副本  
104.     r1->Show( );  
105.     r2->Show( );  
106.     delete r1;  
107.     delete r2;  
108.     r1 = r2 = NULL;  
109.   
110.     Prototype *r3 = new PrototypeB(10);  
111.     Prototype *r4 = r3->Clone( );  
112.     // r1和r2是用相同内容的拷贝  
113.     r3->Show( );  
114.     r4->Show( );  
115.     delete r3;  
116.     delete r4;  
117.     r3 = r4 = NULL;  
118.   
119.     return 0;  
120. }  

转载：http://blog.csdn.net/gatieme/article/details/18001813