设计模式： 9 原型模式

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

本质：从一个对象再创建另一个可定制的对象，而不需要知道创建细节。

总结：对客户隐藏对象创建工作，原型模式是通过拷贝一个现有对象生成新对象的，达到了隔离类对象的使用者和具体类型(易变类)之间的耦合关系的迷路。

优点：快速构建相同类型对象，不需关心克隆对象本身类型。



浅复制：被复制对象的所有变量都含有与原来的对象相同的值，而所有其他对象的引用仍然指向原来的对象。

深复制：把引用对象的变量指向复制过的新对象，而不是原有的被引用的对象。



main.cpp

#include <iostream>
#include <stdlib.h>
#include "Resume.h"
#include "ResumeA.h"
#include "ResumeB.h"

using namespace std;

void process()
{
	Resume* r1 = new ResumeA("A");
	Resume* r2 = new ResumeB("B");
	Resume* r3 = r1->clone();
	Resume* r4 = r2->clone();
	r1->show();
	r1->fillResume();
	r2->show();
	r2->fillResume();
	delete r1;
	delete r2;
	r1 = r2 = NULL;
	r3->show();
	r3->fillResume();
	r4->show();
	r4->fillResume();
	delete r3;
	delete r4;
	r3 = r4 = NULL;
}

int main(int argc,char* argv[])
{
	process();
	system("pause");
	return 0;
}

Resume.h

#ifndef RESUME_H
#define RESUME_H
#include <string>
class Resume
{
public:
	Resume(void);
	virtual ~Resume(void);
	virtual Resume* clone();//克隆，关键所在
	virtual void set(const std::string& sName);
	virtual void show();
	//填写简历
	void fillResume();
protected:
	//保护成员
	virtual void setPersonalInfo();
	virtual void setEducation();
	virtual void setWorkExp();
protected:
	std::string _sName;
};
#endif

Resume.cpp

#include "Resume.h"
#include <iostream>

Resume::Resume(void)
{
}

Resume::~Resume(void)
{
}

Resume* Resume::clone()
{
	return NULL;
}

void Resume::set(const std::string& sName)
{
}

void Resume::show()
{
}

void Resume::fillResume()
{
	setPersonalInfo();
	setEducation();
	setWorkExp();
}

void Resume::setPersonalInfo()
{
}

void Resume::setEducation()
{
}

void Resume::setWorkExp()
{
}

ResumeA.h

#ifndef RESUMEA_H
#define RESUMEA_H
#include "resume.h"
#include <string>
class ResumeA :
	public Resume
{
public:
	ResumeA(const std::string& sName);
	ResumeA(const ResumeA& r);
	~ResumeA(void);
	ResumeA* clone();//克隆，关键所在
	void show();
protected:
	void setPersonalInfo();
	void setEducation();
	void setWorkExp();
};
#endif

ResumeA.cpp

#include "ResumeA.h"
#include <iostream>

using namespace std;

ResumeA::ResumeA(const std::string& sName)
{
	_sName = sName;
}

//拷贝构造函数
ResumeA::ResumeA(const ResumeA& r)
{
	_sName = r._sName;
}

ResumeA::~ResumeA(void)
{
	_sName = "";
}

//注意可能内存泄露
ResumeA* ResumeA::clone()
{
	return new ResumeA(*this);
}

void ResumeA::show()
{
	cout << "简历:" << _sName << endl;
}

void ResumeA::setPersonalInfo()
{
	cout << _sName << "的个人信息" << endl;
}

void ResumeA::setEducation()
{
	cout << _sName << "的教育" << endl;
}

void ResumeA::setWorkExp()
{
	cout << _sName << "的工作经验" << endl;
}

ResumeB.h

#ifndef RESUMEB_H
#define RESUMEB_H
#include "resume.h"
#include <string>
class ResumeB :
	public Resume
{
public:
	ResumeB(const std::string& sName);
	ResumeB(const ResumeB& r);
	~ResumeB(void);
	ResumeB* clone();
	void show();

protected:
	void setPersonalInfo();
	void setEducation();
	void setWorkExp();
};
#endif

ResumeB.cpp

#include "ResumeB.h"
#include <iostream>

using namespace std;

ResumeB::ResumeB(const std::string& sName)
{
	_sName = sName;
}

ResumeB::ResumeB(const ResumeB& r)
{
	_sName = r._sName;
}

ResumeB::~ResumeB(void)
{
	_sName = "";
}

ResumeB* ResumeB::clone()
{
	return new ResumeB(*this);
}

void ResumeB::show()
{
	cout << "简历:" << _sName << endl;
}

void ResumeB::setPersonalInfo()
{
	cout << _sName << "的个人信息" << endl;
}

void ResumeB::setEducation()
{
	cout << _sName << "的教育" << endl;
}

void ResumeB::setWorkExp()
{
	cout << _sName << "的工作经验" << endl;
}