设计模式学习笔记（３）——原型模式、模板方法模式

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

模板方法模式，在一个方法中定义一个算法的骨架，将一些步骤延伸子类中，子类在不改变算法结构的基础上，重新定义算法中的某些步骤。

嗯，一如既往的看不懂定义，上代码。

//父类
class Resume
{
protected:
	char *name;
public:
	Resume() {}
	virtual ~Resume() {}
	virtual Resume* Clone() { return NULL; }
	virtual void Set(char *n) {}
	virtual void Show() {}
};

class ResumeA : public Resume
{
public:
	ResumeA(const char *str);  //构造函数
	ResumeA(const ResumeA &r); //拷贝构造函数
	~ResumeA();                //析构函数
	ResumeA* Clone();          //克隆，关键所在
	void Show();               //显示内容
};
ResumeA::ResumeA(const char *str) 
{
	if(str == NULL) {
		name = new char[1]; 
		name[0] = '\0'; 
	}
	else {
		name = new char[strlen(str)+1];
		strcpy(name, str);
	}
}
ResumeA::~ResumeA() { delete [] name;}
ResumeA::ResumeA(const ResumeA &r) {
	name = new char[strlen(r.name)+1];
	strcpy(name, r.name);
}
ResumeA* ResumeA::Clone() {
	return new ResumeA(*this);
}
void ResumeA::Show() {
	cout<<"ResumeA name : "<<name<<endl; 
}

class ResumeB : public Resume
{
public:
	ResumeB(const char *str);  //构造函数
	ResumeB(const ResumeB &r); //拷贝构造函数
	~ResumeB();                //析构函数
	ResumeB* Clone();          //克隆，关键所在
	void Show();               //显示内容
};
ResumeB::ResumeB(const char *str) 
{
	if(str == NULL) {
		name = new char[1]; 
		name[0] = '\0'; 
	}
	else {
		name = new char[strlen(str)+1];
		strcpy(name, str);
	}
}
ResumeB::~ResumeB() { delete [] name;}
ResumeB::ResumeB(const ResumeB &r) {
	name = new char[strlen(r.name)+1];
	strcpy(name, r.name);
}
ResumeB* ResumeB::Clone() {
	return new ResumeB(*this);
}
void ResumeB::Show() {
	cout<<"ResumeB name : "<<name<<endl; 
}

嗯，似懂非懂，看下调用

int main()
{
	Resume *r1 = new ResumeA("A");
	Resume *r2 = new ResumeB("B");
	Resume *r3 = r1->Clone();
	Resume *r4 = r2->Clone();
	r1->Show(); r2->Show();
	//删除r1,r2
	delete r1; delete r2;	
	r1 = r2 = NULL;
	//深拷贝所以对r3,r4无影响
	r3->Show(); r4->Show();
	delete r3; delete r4;
	r3 = r4 = NULL;
}

哦，核心就是虚基类有个虚拷贝接口函数，子类对应定义实现深拷贝就完了，结果就是不同对象调用拷贝接口，生产的对象不同，ｏｖｅｒ。

再看看模板方法模式，为啥和原型模式放在一起

看定义是看不出名堂了，直接撸代码

// TemplateModel.h文件
#pragma once
#include <iostream>

class AbstractClass
{
public:
	// 定义了一个算法模板
	void templateMethod()
	{
		std::cout << "Operation 0" << std::endl;
		primitiveOperation_0();
		std::cout << "Operation 1" << std::endl;
		primitiveOperation_1();
	}
protected:
	virtual void primitiveOperation_0() = 0;
	virtual void primitiveOperation_1() = 0;
};

class ConcreteClass_0 : public AbstractClass
{
protected:
	virtual void primitiveOperation_0()
	{
		std::cout << "ConcreteClass_0 Operation_0" << std::endl;
	}
	virtual void primitiveOperation_1()
	{
		std::cout << "ConcreteClass_0 Operation_1" << std::endl;
	}
};

class ConcreteClass_1 : public AbstractClass
{
protected:
	virtual void primitiveOperation_0()
	{
		std::cout << "ConcreteClass_1 Operation_0" << std::endl;
	}
	virtual void primitiveOperation_1()
	{
		std::cout << "ConcreteClass_1 Operation_1" << std::endl;
	}
};

结合定义还是很容易理解的，方法templateMethod，整体不变的情况下，想差异化定义其中的一些步骤primitiveOperation_0、primitiveOperation_１，实现就不说了，都一样。

看下调用，嗯，就这回事，没啥好说的。回过头来思考下，把templateMethod实现纯虚化为拷贝构造接口不就是原型模式了？

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

int main()
{
	using namespace std;
	// 模板方法模式
	AbstractClass *p = new ConcreteClass_0();
	p->templateMethod();
	delete p;

	p = new ConcreteClass_1();
	p->templateMethod();
	delete p;

	getchar();
	return 0;
}