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

分手后的思念是犯贱 2022-08-09 03:25 188阅读 0赞

# 一.简介 #

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

原型模式UML图如下：

![Center][]

# 二.原型模式的使用时机 #

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

看一个例子：

// 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_--]这篇文章。

我们对于不同的内容应该实施不同的拷贝机制。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  
请按任意键继续. . .

[Center]: /images/20220731/0560f23140894a71825e869326401e70.png
[C_--]: http://blog.csdn.net/puppet_master/article/details/46955965