C++设计模式之原型模式（二）

3.使用设计模式的实现

头文件的代码如下：

#ifndef _RECORDE_H_
#define _RECORDE_H_

#include <iostream>
#include <string>
using namespace std;

//抽象刻录类
class Recorde
{
private:
	string m_strContex;
public:
	//设置刻录内容
	void SetContex(string strContex);

	//获取刻录内容
	string GetContex();

	//克隆函数，创建一个自己的实例
	virtual Recorde * Clone() = 0;
};

//DVD类
class DVD : public Recorde
{
public:
	Recorde * Clone();
};

//VCD类
class VCD : public Recorde
{
public:
	Recorde * Clone();
};

#endif

Recorde抽象类中添加了一个纯虚函数Clone，用来克隆一个对象，具体由子类来完成克隆操作。

cpp实现代码如下:

#include "Recorde.h"

//设置刻录内容
void Recorde::SetContex(string strContex)
{
	m_strContex = strContex;
}

//获取刻录内容
string Recorde::GetContex()
{
	return m_strContex;
}

//DVD刻录，创建一个DVD对象
Recorde * DVD::Clone()
{
	Recorde * pDVD = new DVD();
	string strContex = GetContex();

	pDVD->SetContex(strContex);
	
	return pDVD;
}

//VCD刻录，创建一个VCD对象
Recorde * VCD::Clone()
{
	Recorde * pVCD = new VCD();
	string strContex = GetContex();

	pVCD->SetContex(strContex);

	return pVCD;
}

具体子类实现基类的Clone函数，创建一个具体类型的对象，并返回

测试程序实现如下：

#include <iostream>
#include "Manager.h"
#include "Recorde.h"
using namespace std;

int main()
{
	//Dvd操作
	Recorde * pDVD = new DVD();
	pDVD->SetContex("DVD");
	cout << "原始:" << pDVD->GetContex() << endl;

	Recorde * pNewDVD = pDVD->Clone();
	cout << "刻录:" << pNewDVD->GetContex() << endl;

	cout << "************" << endl;

	//VCD操作
	Recorde * pVCD = new VCD();
	pVCD->SetContex("VCD");
	cout << "原始:" << pVCD->GetContex() << endl;

	Recorde * pNewVCD = pVCD->Clone();
	cout << "刻录:" << pNewVCD->GetContex() << endl;

	//销毁工作
	delete pDVD;
	pDVD = NULL;

	delete pNewDVD;
	pNewDVD = NULL;

	delete pVCD;
	pVCD = NULL;

	delete pNewVCD;
	pNewVCD = NULL;

	return 0;
}

编译并运行程序，结果如下：



通过和没有使用模式的程序对比，我们发现使用了模式实现的程序，客户端只需要创建一个原型对象就可以了，如果还需要和原型一模一样的对象，不需要通过New操作实例化一个对象，而是通过调用原型对象的Clone方法。也就是说原型模式封装了对象创建的细节，客户端只需要调用Clone就可以创建一个一模一样的对象，对客户端隐藏了创建的细节。

由于针对Recorde抽象类进行编程，当需要刻录其他格式的光盘时，只需要定义一个子类，继承Recorde类就可以了，满足"开放---封闭"原则。

4.带有原型管理器的原型模式

原型管理器(Prototype Manager)是将多个原型对象存储在一个集合中供客户端使用，它是一个专门负责克隆对象的工厂，其中定义了一个集合用于存储原型对象，如果需要某个原型对象的一个克隆，可以通过复制集合中对应的原型对象来获得。在原型管理器中针对抽象原型类进行编程，以便扩展。

刻录类头文件如下：

#ifndef _RECORDE_H_
#define _RECORDE_H_
#include <iostream>
#include <string>
using namespace std;

//抽象刻录类
class Recorde
{
private:
	string m_strContex;
public:
	//设置刻录内容
	void SetContex(string strContex);

	//获取刻录内容
	string GetContex();

	//克隆函数，创建一个自己的实例
	virtual Recorde * Clone() = 0;
};

//DVD类
class DVD : public Recorde
{
public:
	Recorde * Clone();
};

//VCD类
class VCD : public Recorde
{
public:
	Recorde * Clone();
};

#endif

刻录类的cpp实现代码如下：

#include "Recorde.h"

//设置刻录内容
void Recorde::SetContex(string strContex)
{
	m_strContex = strContex;
}

//获取刻录内容
string Recorde::GetContex()
{
	return m_strContex;
}

//DVD刻录，创建一个DVD对象
Recorde * DVD::Clone()
{
	Recorde * pDVD = new DVD();
	string strContex = GetContex();

	pDVD->SetContex(strContex);
	
	return pDVD;
}

//VCD刻录，创建一个VCD对象
Recorde * VCD::Clone()
{
	Recorde * pVCD = new VCD();
	string strContex = GetContex();

	pVCD->SetContex(strContex);

	return pVCD;
}

添加一个原型管理器类Manager，用来保存和获取某个原型对象。当需要克隆某个原型对象的时候，直接从管理器中找出该原型对象，并克隆。

原型管理器头文件代码如下：

#ifndef _MANAGER_H_
#define _MANAGER_H_

#include <iostream>
#include <map>
#include <string>
#include "Recorde.h"

using namespace std;

//原型管理器
class Manager 
{
private:
	//存放各种刻录原型对象
	map< string ,  Recorde * > m_Map;
public:
	//往容器中添加原型对象
	void AddRecorde(string strRecordeType, Recorde * pRecorde);

	//获取原型对象
	Recorde * GetRecorde(string strRecordeType);
};

#endif

原型管理器cpp实现代码如下：

#include "Manager.h"

//往容器中添加原型对象
void Manager::AddRecorde(string strRecordeType, Recorde * pRecorde)
{
	m_Map.insert(map< string, Recorde* >::value_type(strRecordeType, pRecorde));
}

//获取原型对象
Recorde * Manager::GetRecorde(string strRecordeType)
{
	map< string, Recorde* >::iterator ite =  m_Map.find(strRecordeType);
	
	if( ite != m_Map.end() )
	{		
		return ite->second;
	}
}

测试程序代码如下：

#include <iostream>
#include "Manager.h"
#include "Recorde.h"
using namespace std;

int main()
{
	//创建DVD原型对象
	Recorde * pDVD = new DVD();
	pDVD->SetContex("DVD");

	//创建VCD原型对象
	Recorde * pVCD = new VCD();
	pVCD->SetContex("VCD");
	
	//创建原型管理器
	Manager * pManager = new Manager();
	Recorde * pRecorde = NULL;

	//往原型管理器中添加DVD,VCD原型对象
	pManager->AddRecorde("DVD", pDVD);
	pManager->AddRecorde("VCD", pVCD);

	//从原型管理取出DVD原型对象，并克隆DVD
	pRecorde = pManager->GetRecorde("DVD");
	Recorde * pNewDVD = pRecorde->Clone();
	cout << pNewDVD->GetContex() << endl;

	//从原型管理取出VCD原型对象，并克隆VCD
	pRecorde = pManager->GetRecorde("VCD");
	Recorde * pNewVCD = pRecorde->Clone();
	cout << pNewVCD->GetContex() << endl;

	//销毁操作
	delete pDVD;
	pDVD = NULL;

	delete pVCD;
	pVCD = NULL;

	delete pManager;
	pManager = NULL;

	delete pNewDVD;
	pNewDVD = NULL;

	delete pNewVCD;
	pNewVCD = NULL;

	return 0;
}

编译并运行，结果如下：



原型管理器针对抽象Recorde编程，刻录类Recorde和原型管理器Manager是一种依赖关系，使用组合的方式实现功能的复用。当需要拓展刻录格式时，只需要定义一个继承Recorde的子类，并把Recorde指针传给原型原理器，就可以实现刻录功能，不需要修改任何代码，符合“开发封闭原则”。