實例講授C++編程中對設計形式中的原型形式的應用。本站提示廣大學習愛好者：（實例講授C++編程中對設計形式中的原型形式的應用）文章只能為提供參考，不一定能成為您想要的結果。以下是實例講授C++編程中對設計形式中的原型形式的應用正文
原型形式的完成完全代碼示例（code）：原型形式的完成很簡略，這裡為了便利初學者的進修和參考，將給出完全的完成代碼（一切代碼采取 C++完成，並在 VC 6.0 下測試運轉）。
代碼片段 1：Prototype.h
//Prototype.h
#ifndef _PROTOTYPE_H_
#define _PROTOTYPE_H_
class Prototype{
public:
virtual ~Prototype();
virtual Prototype* Clone() const = 0;
protected:
Prototype();
private:
};
class ConcretePrototype:public Prototype{
public:
ConcretePrototype();
ConcretePrototype(const ConcretePrototype& cp);
~ConcretePrototype();
Prototype* Clone() const;
protected:
private:
};
#endif //~_PROTOTYPE_H_
代碼片段 2：Prototype.cpp
//Prototype.cpp
#include "Prototype.h"
#include <iostream>
using namespace std;
Prototype::Prototype(){
}
Prototype::~Prototype(){
}
Prototype* Prototype::Clone() const{
return 0;
}
ConcretePrototype::ConcretePrototype(){
}
ConcretePrototype::~ConcretePrototype(){
}
ConcretePrototype::ConcretePrototype(const ConcretePrototype& cp){
cout<<"ConcretePrototype copy ..."<<endl;
}
Prototype* ConcretePrototype::Clone() const{
return new ConcretePrototype(*this);
}
代碼片段 3：main.cpp
//main.cpp
#include "Prototype.h"
#include <iostream>
using namespace std;
int main(int argc,char* argv[]){
Prototype* p = new ConcretePrototype();
Prototype* p1 = p->Clone();
return 0;
}
代碼解釋：原型形式的構造和完成都很簡略，其症結就是（C++中）拷貝結構函數的完成方法，這也是 C++完成技巧層面上的工作。因為在示例代碼中不觸及到深層拷貝（重要指有指針、復合對象的情形），是以我們經由過程編譯器供給的默許的拷貝結構函數（按位拷貝）的方法停止完成。解釋的是這一切只是為了完成簡略起見，也由於本文檔的重點不在拷貝結構函數的完成技巧，而在原型形式自己的思惟。
另外一個實例
我們再來看一個詳細項目標例子：
namespace Prototype_DesignPattern
{
using System;
// Objects which are to work as prototypes must be based on classes which
// are derived from the abstract prototype class
abstract class AbstractPrototype
{
abstract public AbstractPrototype CloneYourself();
}
// This is a sample object
class MyPrototype : AbstractPrototype
{
override public AbstractPrototype CloneYourself()
{
return ((AbstractPrototype)MemberwiseClone());
}
// lots of other functions go here!
}
// This is the client piece of code which instantiate objects
// based on a prototype.
class Demo
{
private AbstractPrototype internalPrototype;
public void SetPrototype(AbstractPrototype thePrototype)
{
internalPrototype = thePrototype;
}
public void SomeImportantOperation()
{
// During Some important operation, imagine we need
// to instantiate an object - but we do not know which. We use
// the predefined prototype object, and ask it to clone itself.
AbstractPrototype x;
x = internalPrototype.CloneYourself();
// now we have two instances of the class which as as a prototype
}
}
/// <summary>
/// Summary description for Client.
/// </summary>
public class Client
{
public static int Main(string[] args)
{
Demo demo = new Demo();
MyPrototype clientPrototype = new MyPrototype();
demo.SetPrototype(clientPrototype);
demo.SomeImportantOperation();
return 0;
}
}
}
C#對原型形式的支撐
在C#外面，我們可以很輕易的經由過程Clone()辦法完成原型形式。任何類，只需想支撐克隆，必需完成C#中的ICloneable接口。ICloneable接口中有一Clone辦法，可以在類中復寫完成自界說的克隆辦法。克隆的完成辦法有兩種：淺拷貝（shallow copy）與深拷貝（deep copy）。
淺拷貝與深拷貝
上面給出淺拷貝與深拷貝的兩個例子，例子應用了ICloneable接口。C#中的數組是援用型的變量，我們經由過程數組來停止演示：
淺拷貝：
using System;
class ShallowCopy : ICloneable
{
public int[] v = {1,2,3};
public Object Clone()
{
return this.MemberwiseClone();
}
public void Display()
{
foreach(int i in v)
Console.Write( i + ", ");
Console.WriteLine();
}
}
class Client
{
public static void Main()
{
ShallowCopy sc1 = new ShallowCopy();
ShallowCopy sc2 = (ShallowCopy)sc1.Clone();
sc1.v[0] = 9;
sc1.Display();
sc2.Display();
}
}
ShallowCopy對象完成了一個淺拷貝，是以當對sc1停止克隆時，其字段v並沒有克隆，這招致sc1與sc2的字段v都指向了統一個v，是以，當修正了sc1的v[0]後，sc2的v[0]也產生了變更。
深拷貝：
using System;
class DeepCopy : ICloneable
{
public int[] v = {1,2,3};
// 默許結構函數
public DeepCopy()
{
}
// 供Clone辦法挪用的公有結構函數
private DeepCopy(int[] v)
{
this.v = (int[])v.Clone();
}
public Object Clone()
{
// 結構一個新的DeepCopy對象，結構參數為
// 原有對象中應用的 v
return new DeepCopy(this.v);
}
public void Display()
{
foreach(int i in v)
Console.Write( i + ", ");
Console.WriteLine();
}
}
class Client
{
public static void Main()
{
DeepCopy dc1 = new DeepCopy();
DeepCopy dc2 = (DeepCopy)dc1.Clone();
dc1.v[0] = 9;
dc1.Display();
dc2.Display();
}
}
關於原型形式的評論辯論
原型形式經由過程復制原型（原型）而取得新對象創立的功效，這裡原型自己就是"對象工場"（由於可以或許臨盆對象），現實上原型形式和 Builder 形式、AbstractFactory 形式都是經由過程一個類（對象實例）來專門擔任對象的創立任務（工場對象），它們之間的差別是： Builder 形式重在龐雜對象的一步步創立（其實不直接前往對象），AbstractFactory 形式重在發生多個互相依附類的對象，而原型形式重在從本身復制本身創立新類。
