设计模式学习笔记--原型模式

一.简介

原型模式是指使用 原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。简单来说，就是通过一个对象，拷贝出一个新的对象，这个对象保持和被拷贝对象相同的状态，我们可以直接在这个基础上进行修改，而不必重新初始化一个对象，再进行相关更改。

原型模式UML图如下：

二.原型模式的使用时机

原型模式是建造模式的一种，换句话说就是我们创建对象的时候使用的一种模式，提供一种克隆的方法，从现有的对象直接复制出一个新的对象，并保留对象的状态。那么，这样创建对象和从头开始初始化有什么区别呢？

看一个例子：

// C++Test.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;


class Prototype
{
private:
	int m_id;
	string m_name;
public:
	Prototype(int id, string name);
	virtual ~Prototype();

	//自己给出一个拷贝构造函数
	Prototype(const Prototype& prototype);

	virtual void Show();

	void SetId(int id){m_id = id;}
	void SetName(string name){m_name = name;}
};

Prototype::Prototype(int id, string name)
	: m_id(id), m_name(name)
{

}

Prototype::~Prototype()
{

}

Prototype::Prototype(const Prototype& prototype)
{
	this->m_id = prototype.m_id;
	this->m_name = prototype.m_name;
}

void Prototype::Show()
{
	cout<<"id: "<<m_id<<"name: "<<m_name<<endl;
}


class ConcretePrototype : public Prototype
{
private:
	string m_concrete;
public:
	ConcretePrototype(int id, string name, string concrete);

	//子类的拷贝构造函数
	ConcretePrototype(const ConcretePrototype& contype);

	//覆写show方法
	void Show();

};

ConcretePrototype::ConcretePrototype(int id, string name, string concrete)
	: Prototype(id, name), m_concrete(concrete)
{

}

ConcretePrototype::ConcretePrototype(const ConcretePrototype& contype)
	: Prototype(contype)
{
	this->m_concrete = contype.m_concrete; 
}

void ConcretePrototype::Show()
{
	Prototype::Show();
	cout<<"concrete: "<<m_concrete<<endl;
}



int _tmain(int argc, _TCHAR* argv[])
{
	ConcretePrototype* test1 = new ConcretePrototype(1, "test1", "conc1");
	test1->Show();

	ConcretePrototype* test2 = new ConcretePrototype(2, "test2", "conc1");
	test2->Show();

	system("pause");
	return 0;
}

结果：

id: 1name: test1
concrete: conc1
id: 2name: test2
concrete: conc1
请按任意键继续. . .

其实没有什么特别的，创建两个对象，两个对象仅仅有名字和id不同（复杂的对象肯定会有其他很多相同的东东），我们直接创建还是比较麻烦的，需要给出各种参数，如果这个初始化有数十个参数，那么创建一个对象貌似更是麻烦。而且，比如有一个对象已经是某种属性了，我们需要它现在的属性，而不是它初始化的属性。举个例子，打怪的时候，怪物有个分裂的技能，我们打到一半的时候，怪物突然分裂了，那么这个分身应该是慢些满状态还是怪物现在的属性呢？当然是怪物现在的属性了！！

三.原型模式的使用方法

既然从头赋值那样麻烦，能简化对象创建过程的原型模式就要登场啦！看一下原型模式的实现方法：

// C++Test.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;


class Prototype
{
private:
	int m_id;
	string m_name;
public:
	Prototype(int id, string name);
	virtual ~Prototype();
	
	//自己给出一个拷贝构造函数
	Prototype(const Prototype& prototype);

	//给出复制的虚函数接口，子类必须对其进行覆写
	virtual Prototype* Clone() = 0;

	virtual void Show();

	void SetId(int id){m_id = id;}
	void SetName(string name){m_name = name;}
};

Prototype::Prototype(int id, string name)
	: m_id(id), m_name(name)
{

}

Prototype::~Prototype()
{

}

Prototype::Prototype(const Prototype& prototype)
{
	this->m_id = prototype.m_id;
	this->m_name = prototype.m_name;
}

void Prototype::Show()
{
	cout<<"id: "<<m_id<<"name: "<<m_name<<endl;
}


class ConcretePrototype : public Prototype
{
private:
	string m_concrete;
public:
	ConcretePrototype(int id, string name, string concrete);

	//子类的拷贝构造函数
	ConcretePrototype(const ConcretePrototype& contype);
	//覆写Clone方法
	ConcretePrototype* Clone();
	//覆写show方法
	void Show();

};

ConcretePrototype::ConcretePrototype(int id, string name, string concrete)
	: Prototype(id, name), m_concrete(concrete)
{
	
}

ConcretePrototype::ConcretePrototype(const ConcretePrototype& contype)
	: Prototype(contype)
{
	this->m_concrete = contype.m_concrete; 
}

ConcretePrototype* ConcretePrototype::Clone()
{
	 return new ConcretePrototype(*this);
}

void ConcretePrototype::Show()
{
	Prototype::Show();
	cout<<"concrete: "<<m_concrete<<endl;
}



int _tmain(int argc, _TCHAR* argv[])
{
	ConcretePrototype* test1 = new ConcretePrototype(1, "test1", "conc1");
	test1->Show();

	ConcretePrototype* test2 = test1->Clone();
	test2->SetId(2);
	test2->SetName("test2");
	test2->Show();
	
	system("pause");
	return 0;
}

结果：

id: 1name: test1
concrete: conc1
id: 2name: test2
concrete: conc1
请按任意键继续. . .

我们看到，当创建了第一个对象之后，我们如果想要创建第二个对象，并不需要从头再掉用构造函数，而是使用了Clone方法，根据对象1克隆出了一个对象2，这个对象2仅有id和name和对象1不一样，我们只需要改一下这个就可以了。（例子中其他属性比较少，不能体现出原型模式的优势，如果其他属性很多，那么就能大大体现出原型模式创建对象的优越之处）。

四.原型模式中深拷贝浅拷贝的问题

原型模式涉及到了拷贝的问题，关于拷贝和赋值，肯定会涉及到深拷贝和浅拷贝的问题。对于原生数据类型，浅拷贝没有问题，但是对于指针或者引用的字段，浅拷贝和深拷贝就有很大区别了。

比如我们在游戏中创建一个人物对象，这个人物对象的属性字段是用一个指针指向的，而人物图像资源也是用指针指向的。那么这两种就有很大的区别。对于人物属性，浅拷贝仅仅拷贝指针，拷贝完两个对象的指针指向的是同一个内容，那么如果A怪被揍了，B怪也会掉血，这显然不是我们想要的，所以这种就需要深拷贝，复制一个对象之后，需要为其复制一份属于他的属性。但是对于图片资源的问题，比如我有100个怪，每个怪的图片都是一样的，那么我们如果使用深拷贝，每个怪物都保存一份资源，这肯定也是不现实的，所以对于这种就应该使用浅拷贝。

PS：关于拷贝构造函数等的具体问题，详细见 C++那些细节--拷贝构造函数这篇文章。

我们对于不同的内容应该实施不同的拷贝机制。C++为我们默认提供的拷贝构造函数是浅拷贝的，即逐字段拷贝，遇到指针或引用仅仅拷贝其本身，不会拷贝指向的内容。所以，要实现深拷贝，我们就需要自己动手写拷贝构造函数。

看一个例子：

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;

struct ObjInfo
{
	string name;
	int id;
};


class Prototype
{
private:
	//将属性改为一个单独的结构体，这里仅仅保存一个指针
	ObjInfo* m_info;
public:
	Prototype(ObjInfo* info);
	virtual ~Prototype();
	
	//我们没有给出一个拷贝构造函数，编译器自动生成的拷贝构造函数只能实现浅复制
	//Prototype(const Prototype& prototype);

	//给出复制的虚函数接口，子类必须对其进行覆写
	virtual Prototype* Clone() = 0;

	virtual void Show();

	void SetId(int id){m_info->id = id;}
	void SetName(string name){m_info->name = name;}
};

Prototype::Prototype(ObjInfo* info)
	: m_info(info)
{

}

Prototype::~Prototype()
{
	if (m_info)
		delete m_info;
}

void Prototype::Show()
{
	cout<<"id: "<<m_info->id<<"name: "<<m_info->name<<endl;
}


class ConcretePrototype : public Prototype
{
private:
	string m_concrete;
public:
	ConcretePrototype(ObjInfo* info, string concrete);

	//子类的拷贝构造函数
	ConcretePrototype(const ConcretePrototype& contype);
	//覆写Clone方法
	ConcretePrototype* Clone();
	//覆写show方法
	void Show();

};

ConcretePrototype::ConcretePrototype(ObjInfo* info, string concrete)
	: Prototype(info), m_concrete(concrete)
{
	
}

ConcretePrototype::ConcretePrototype(const ConcretePrototype& contype)
	: Prototype(contype)
{
	this->m_concrete = contype.m_concrete; 
}

ConcretePrototype* ConcretePrototype::Clone()
{
	 return new ConcretePrototype(*this);
}

void ConcretePrototype::Show()
{
	Prototype::Show();
	cout<<"concrete: "<<m_concrete<<endl;
}



int _tmain(int argc, _TCHAR* argv[])
{
	ObjInfo* info = new ObjInfo();
	info->id = 1;
	info->name = "test1";

	ConcretePrototype* test1 = new ConcretePrototype(info, "conc1");
	

	ConcretePrototype* test2 = test1->Clone();
	test2->SetId(2);
	test2->SetName("test2");

	test1->Show();
	test2->Show();
	
	system("pause");
	return 0;
}

结果：

id: 2name: test2
concrete: conc1
id: 2name: test2
concrete: conc1
请按任意键继续. . .

这个例子中，我们修改了一部分内容，将原来的id和name换成了一个struct，用一个指针保存。并且，我们没有给出拷贝构造函数，而是让编译器为我们自动生成一个拷贝构造函数，这个拷贝构造函数只能实现浅复制。那么，这个结果就是，我么从obj1复制出了obj2，想要修改obj2属性是时候，却把obj1的属性也修改了。这显然不是我们想要的结果，我们在进行一下修改，给出一个拷贝构造函数，并且实现深拷贝：

Prototype::Prototype(const Prototype& prototype)
{
	this->m_info = new ObjInfo();
	this->m_info->id = prototype.m_info->id;
	this->m_info->name = prototype.m_info->name;
}

这个函数在实行拷贝的时候，并不是简单的把指针复制一遍，而是重新创建了一个结构体，保存给新的对象，然后从老对象中将值复制给新对象。这样就不会出现改了一个对象，另一个对象的值也改变的情况。

结果：

id: 1name: test1
concrete: conc1
id: 2name: test2
concrete: conc1
请按任意键继续. . .