设计模式：原型模式（Prototype）

最新推荐文章于 2024-07-08 17:18:34 发布
最新推荐文章于 2024-07-08 17:18:34 发布
阅读量730 收藏 31
点赞数 16
分类专栏： 设计模式 文章标签： 原型模式 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ProgramNovice/article/details/139110036
版权

设计模式：原型模式（Prototype）

设计模式：原型模式（Prototype）

原型模式（Prototype）属于创建型模式（Creational Pattern）的一种。

创建型模式（Creational Pattern）对类的实例化过程进行了抽象，能够将软件模块中对象的创建和对象的使用分离。为了使软件的结构更加清晰，外界对于这些对象只需要知道它们共同的接口，而不清楚其具体的实现细节，使整个系统的设计更加符合单一职责原则。

创建型模式在创建什么（What），由谁创建（Who），何时创建（When）等方面都为软件设计者提供了尽可能大的灵活性。创建型模式隐藏了类的实例的创建细节，通过隐藏对象如何被创建和组合在一起达到使整个系统独立的目的。

模式动机

如果你有一个对象， 并希望生成与其完全相同的一个复制品， 你该如何实现呢？ 首先， 你必须新建一个属于相同类的对象。 然后， 你必须遍历原始对象的所有成员变量， 并将成员变量值复制到新对象中。

然而，并非所有对象都能通过这种方式进行复制， 因为有些对象可能拥有私有成员变量， 它们在对象本身以外是不可见的。

直接复制还有另外一个问题。 因为你必须知道对象所属的类才能创建复制品， 所以代码必须依赖该类。 即使你可以接受额外的依赖性， 那还有另外一个问题： 有时你只知道对象所实现的接口， 而不知道其所属的具体类， 比如可向方法的某个参数传入实现了某个接口的任何对象。

通过复制现有的实例来创建新的实例，无需知道相应类的信息。这就是原型模式（Prototype）的模式动机。

模式定义

原型模式（Prototype）属于创建型模式。

原型模式将克隆过程委派给被克隆的实际对象。 模式为所有支持克隆的对象声明了一个通用接口， 该接口让你能够克隆对象， 同时又无需将代码和对象所属类耦合。

模式结构

原型模式（Prototype）包含如下角色：

  • 抽象原型类（Prototype）：接口定义了一个抽象的克隆方法。
  • 具体原型类（Concrete Prototype）：实现抽象原型类（接口）定义的克隆方法，提供一个具体的克隆方法来复制自己。
  • 客户端（Client）：使用原型类的对象来实现具体的操作，即通过复制原型对象来创建新的对象。

在这里插入图片描述

时序图

略。

模式实现

抽象原型类 Prototype.h：

#ifndef _PROTOTYPE_H_
#define _PROTOTYPE_H_

class Prototype
{
public:
	virtual Prototype* clone() = 0;
};

#endif // !_PROTOTYPE_H_

具体原型类 ConcretePrototype1.h：

#ifndef _CONCRETE_PROTOTYPE_1_H_
#define _CONCRETE_PROTOTYPE_1_H_

#include "Prototype.h"

#include <string>

class ConcretePrototype1 : public Prototype
{
private:
	std::string m_strTypeName;

public:
	ConcretePrototype1(std::string name) : m_strTypeName(name) {};
	// 拷贝构造函数
	ConcretePrototype1(const ConcretePrototype1& rhs)
	{
		m_strTypeName = rhs.m_strTypeName;
	}

	Prototype* clone() override
	{
		return new ConcretePrototype1(*this);
	}
	std::string getTypeName() const
	{
		return m_strTypeName;
	}
};

#endif // !_CONCRETE_PROTOTYPE_1_H_

具体原型类 ConcretePrototype2.h：

#ifndef _CONCRETE_PROTOTYPE_2_H_
#define _CONCRETE_PROTOTYPE_2_H_

#include "Prototype.h"

#include <string>

class ConcretePrototype2 : public Prototype
{
private:
	std::string m_strTypeName;

public:
	ConcretePrototype2(std::string name) : m_strTypeName(name) {};
	// 拷贝构造函数
	ConcretePrototype2(const ConcretePrototype2& rhs)
	{
		m_strTypeName = rhs.m_strTypeName;
	}

	Prototype* clone() override
	{
		return new ConcretePrototype2(*this);
	}
	std::string getTypeName() const
	{
		return m_strTypeName;
	}
};

#endif // !_CONCRETE_PROTOTYPE_2_H_

在单线程环境下的测试

测试代码：

#include <iostream>
#include <stdlib.h>

#include "ConcretePrototype1.h"
#include "ConcretePrototype2.h"

using namespace std;

int main()
{
	ConcretePrototype1* p1 = new ConcretePrototype1("A");
	ConcretePrototype2* p2 = (ConcretePrototype2*)p1->clone();

	cout << p1->getTypeName() << endl;
	cout << p2->getTypeName() << endl;

	delete p1;
	delete p2;

	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

在多线程环境下的测试

略。

模式分析

  • 原型模式将克隆过程委派给被克隆的实际对象。 模式为所有支持克隆的对象声明了一个通用接口， 该接口让你能够克隆对象， 同时又无需将代码和对象所属类耦合。 通常情况下， 这样的接口中仅包含一个克隆方法。
  • 所有的类对克隆方法的实现都非常相似。该方法会创建一个当前类的对象， 然后将原始对象所有的成员变量值复制到新建的类中。 你甚至可以复制私有成员变量， 因为绝大部分编程语言都允许对象访问其同类对象的私有成员变量。
  • 支持克隆的对象即为原型。 当你的对象有几十个成员变量和几百种类型时， 对其进行克隆甚至可以代替子类的构造。

优缺点

优点：

  1. 可以克隆对象，而无需与它们所属的具体类相耦合。
  2. 可以克隆预生成原型，避免反复运行初始化代码，在创建大量对象时可以节省时间和资源，提高了对象创建的效率。
  3. 可以隐藏对象创建和初始化的复杂性，可以更方便地生成复杂对象，并且更容易管理和维护。
  4. 可以用继承以外的方式来处理复杂对象的不同配置。
  5. 可以在运行时动态添加和删除对象。
  6. 可以保护原始对象，防止意外修改对原对象产生影响。

缺点：

  1. 必须保证原始对象和克隆对象之间的区别，否则可能会产生副作用。
  2. 克隆包含循环引用的复杂对象可能会非常麻烦。
  3. 原型模式需要给对象添加一个克隆方法。但是，该方法可能不适用于所有对象类型，例如具有命令行参数的程序。

适用场景

在以下情况下可以使用原型模式：

  • 如果你需要复制一些对象，同时又希望代码独立于这些对象所属的具体类，可以使用原型模式。
  • 如果子类的区别仅在于其对象的初始化方式，那么你可以使用该模式来减少子类的数量。 别人创建这些子类的目的可能是为了创建特定类型的对象。

在原型模式中，你可以使用一系列预生成的、 各种类型的对象作为原型。客户端不必根据需求对子类进行实例化， 只需找到合适的原型并对其进行克隆即可。

应用场景

  1. 细胞有丝分裂：原始细胞就是一个原型，它在复制体的生成过程中起到了推动作用。
  2. 孙悟空的七十二变。
  3. Object类：Java中的所有类都直接或间接继承自Object类，它提供了一个clone()方法，允许对象在克隆时使用它们的原型对象。
  4. Spring框架：在Spring框架中，原型范围bean使用原型模式。例如，在Spring中，可以将作用域设置为prototype，来创建一个bean的多个独立实例，这样每次在容器中注入bean时，将创建新的实例。

模式扩展

原型注册表 （Prototype Registry）提供了一种访问常用原型的简单方法，其中存储了一系列可供随时复制的预生成对象。 最简单的注册表原型是一个 名称 → 原型 的哈希表。 但如果需要使用名称以外的条件进行搜索，你可以创建更加完善的注册表版本。

在这里插入图片描述

应用实例

实例 1：矩形对象克隆

公司正在开发一个图形设计软件，其中有一个常用的图形元素是矩形。设计师在工作时可能需要频繁地创建相似的矩形，而这些矩形的基本属性（如颜色、宽度、高度）相同，但具体的位置可能不同。为了提高设计师的工作效率，请你使用原型模式设计一个矩形对象的原型。该原型可以根据用户的需求进行克隆，生成新的矩形对象。

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

// 抽象原型类
class Prototype
{
public:
	virtual Prototype *clone() = 0;
};

// 具体的矩阵类
class RectanglePrototype : public Prototype
{
	// 成员属性
private:
	string m_color;
	int m_height;
	int m_width;
	int x_pos;
	int y_pos;

	// 成员函数
public:
	RectanglePrototype(string color, int height, int width) : m_color(color), m_height(height), m_width(width)
	{
		x_pos = 0;
		y_pos = 0;
	};

	// 重载克隆函数接口
	Prototype *clone() override
	{
		return new RectanglePrototype(*this);
	}
	// 信息打印
	void PrintInfo()
	{
		cout << "Color: " << m_color << ", Height: " << m_height << ", Width: " << m_width
			 << ", X pos: " << x_pos << ", Y pos: " << y_pos << endl;
	}
	void setPosition(int x, int y)
	{
		x_pos = x;
		y_pos = y;
	}
};

int main()
{
	string color = "Red";
	int height = 300, width = 100;
	// 创建原型对象
	RectanglePrototype *prototypeRectangle = new RectanglePrototype(color, height, width);
	prototypeRectangle->PrintInfo();
	// 克隆对象
	RectanglePrototype *clonedRectangle = (RectanglePrototype *)prototypeRectangle->clone();
	clonedRectangle->setPosition(50, 50);
	clonedRectangle->PrintInfo();

	delete clonedRectangle;
	clonedRectangle = nullptr;
	delete prototypeRectangle;
	prototypeRectangle = nullptr;

	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

实例 2：图形原型注册表

#include <iostream>
#include <string>
#include <unordered_map>
#include <stdlib.h>
using namespace std;

// 抽象原型类
class Prototype
{
public:
	virtual Prototype *clone() = 0;
	virtual void draw() = 0;
};

// 具体的矩阵类
class RectanglePrototype : public Prototype
{
	// 成员属性
private:
	string m_strTypeName;

	// 成员函数
public:
	RectanglePrototype(string name) : m_strTypeName(name){};

	// 重载克隆函数接口
	Prototype *clone() override
	{
		return new RectanglePrototype(*this);
	}
	void draw() override
	{
		cout << "Inside Rectangle::draw() method." << endl;
	}
	void setName(const string &name)
	{
		m_strTypeName = name;
	}
	string getName() const
	{
		return m_strTypeName;
	}
};

// 具体的正方形类
class SquarePrototype : public Prototype
{
	// 成员属性
private:
	string m_strTypeName;

	// 成员函数
public:
	SquarePrototype(string name) : m_strTypeName(name){};

	// 重载克隆函数接口
	Prototype *clone() override
	{
		return new SquarePrototype(*this);
	}
	void draw() override
	{
		cout << "Inside Square::draw() method." << endl;
	}
	void setName(const string &name)
	{
		m_strTypeName = name;
	}
	string getName() const
	{
		return m_strTypeName;
	}
};

// 具体的圆形类
class CirclePrototype : public Prototype
{
	// 成员属性
private:
	string m_strTypeName;

	// 成员函数
public:
	CirclePrototype(string name) : m_strTypeName(name){};

	// 重载克隆函数接口
	Prototype *clone() override
	{
		return new CirclePrototype(*this);
	}
	void draw() override
	{
		cout << "Inside Circle::draw() method." << endl;
	}
	void setName(const string &name)
	{
		m_strTypeName = name;
	}
	string getName() const
	{
		return m_strTypeName;
	}
};

class PrototypeRegistry
{
private:
	unordered_map<string, Prototype *> items;

public:
	void addItem(string id, Prototype *p)
	{
		items[id] = p;
	}
	Prototype *getById(string id)
	{
		return items[id]->clone();
	}
};

int main()
{
	RectanglePrototype *rect = new RectanglePrototype("Rectangle");
	SquarePrototype *square = new SquarePrototype("Square");
	CirclePrototype *circle = new CirclePrototype("Circle");
	PrototypeRegistry *prototypeRegistry = new PrototypeRegistry();

	prototypeRegistry->addItem("1", rect);
	prototypeRegistry->addItem("2", square);
	prototypeRegistry->addItem("3", circle);

	RectanglePrototype *clonedRect = (RectanglePrototype *)prototypeRegistry->getById("1");
	clonedRect->setName("my rectangle");
	cout << clonedRect->getName() << endl;
	clonedRect->draw();

	delete prototypeRegistry;
	delete rect;
	delete square;
	delete circle;
	delete clonedRect;

	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

参考

  1. https://design-patterns.readthedocs.io/zh-cn/latest/creational_patterns/creational.html
  2. https://www.runoob.com/design-pattern/prototype-pattern.html
  3. https://blog.csdn.net/weixin_45433817/article/details/131037102
  4. https://blog.csdn.net/weixin_45433817/article/details/131095164
  5. https://refactoringguru.cn/design-patterns/prototype
  6. https://www.cnblogs.com/ybqjymy/p/17534839.html
  7. https://www.jb51.net/article/55870.htm
UestcXiye
关注
  • 16
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java设计模式之Prototype原型模式
08-27
Java设计模式之Prototype原型模式 Prototype原型模式是Java设计模式中的一种创建型模式，它主要用于对象的克隆和创建。该模式的主要思想是将一个对象作为原型，然后通过克隆该对象来创建新的对象，从而实现对象的...
C语言：原型模式及举例
03-07
原型模式（Prototype Pattern）是一种创建型设计模式，它允许通过复制已有对象来创建新对象，而无需知道具体创建过程。在C语言中，由于没有内置的克隆机制，我们需要自定义函数来实现对象的复制。这一模式常用于减少...
【设计模式专题之原型模式】5. 矩形原型
会变好的 慢一点也没关系
03-12 505
时间限制：1.000S 空间限制：256MB。
C++设计模式：原型模式
ajbb093的博客
04-07 924
在本案例中，如果对史莱姆的原型进行克隆，也就是分裂成不同的对象，而不同的史莱姆型号会对应着不同的技能，假设大型史莱姆是撞击，普通史莱姆是喷射，小型史莱姆是自爆，则简单地进行深克隆以及浅克隆可能会引起异常。因此，对此的解决办法便是原型模式结合状态模式使用，状态模式是指在软件构建过程中，某些对象的状态如果发生改变，其行为也会随之发生变化，使用状态模式将能允许一个对象在其内部状态发生改变时改变它的行为，从而使对象看起来似乎修改了其行为。，普通史莱姆转换成小型史莱姆，其中四只转换后的小型史莱姆共享血量（
详解设计模式：原型模式
栗筝i的博客
11-28 2144
原型模式（Prototype Pattern） ，是 GoF 的 23 种设计模式的一种，是用于创建重复的对象，同时又能保证性能。属于创建型模式，提供创建对象的最佳方式。 原型（Prototype），在制造业中通常是指大批量生产开始之前研发出的概念模型，并基于各种参数指标对其进行检验，如果达到了质量要求，即可参照这个原型进行批量生产。 本篇内容包括：关于原型模式、原型模式-浅拷贝实现、原型模式-深拷贝实现
设计模式六：原型模式（Prototype Pattern）
qq_40537587的博客
07-31 658
原型模式是一种创建对象的设计模式。它允许我们通过复制一个现有对象来创建新的对象，而无需知道其具体实现细节。在使用原型模式时，我们首先创建一个原始对象，然后根据需要复制该对象，以获得新创建的对象。原型模式的主要思想是基于对象的复制。通过使用原型模式，我们可以避免直接实例化对象，从而提高性能和代码灵活性。此外，原型模式还可以用于创建复杂的对象结构，因为它允许我们在创建对象时使用已经存在的对象作为蓝图。
设计模式：原型模式
a1969212650的专栏
05-30 280
是一种创建型设计模式，它允许一个对象通过复制现有的对象来创建新的实例。原型模式的主要目的是通过克隆来创建对象，而不是通过构造函数。这对于创建代价较高或复杂的对象时特别有用。
探索Java设计模式：原型模式
放码过来
04-25 809
*原型模式（Prototype Pattern）**是一种创建型设计模式，它通过复制已有对象来创建新对象，而不是通过new关键字实例化。这种模式适用于需要快速创建大量相似对象，或者对象创建过程较复杂、耗时，且存在大量重复初始化逻辑的情况。原型接口（Prototype Interface）：声明克隆自身的方法，通常为clone()或copy()。具体原型（Concrete Prototype）：实现原型接口，提供复制自身的具体实现。
创意设计模式：原型设计模式
新华编程特战队
01-09 1164
原型设计模式是创建性设计模式之一。它允许我们指定作为原始对象原型的对象。换句话说，它允许我们复制现有对象而不是创建新实例。在这里，我们将详细了解原型设计模式及其用法。
设计模式-Prototype模式（原型模式）
weixin_44030848的博客
07-24 1146
图解设计模式中的原型模式
Java 设计模式 Prototype 原型 模式
热门推荐
05-17 5万+
Java 设计模式 Prototype 原型 模式 Prototype 模式用于不能根据类来来生产实例时，而根据现有的实例来生成新的实例。 原型：负责定义用于复制现有实例来生成新实例的方法。 具体的原型：负责实现复制现有实例并生成新实例的方法。 使用者：负责使用复制实例方法生成的实例。 /** * 原型 * @author 托马斯小火车喷雾又喷烟 * */ public interface Product extends Cloneable { public abstract v
Java原型设计模式(Prototype)
01-20
　原型模式(Prototype)是通过复制一个已经存在的实例来返回新的实例，而不是新建实例，被复制的实例是我们所称的原型对象，这个原型是可定制的。 　2、原理 　有两部分组成，抽象原型和具体原型。意图：用原型...
.NET设计模式（6）：原型模式（PrototypePattern）
01-30
.NET设计模式（6）：原型模式（PrototypePattern）
Python 程序语言设计模式思路-创建型模式：原型模式：通过复制现有对象来创建新对象，面向对象编程
05-21
原型模式（Prototype Pattern）作为创建型模式的一种，通过复制现有对象来创建新对象，从而避免了使用构造函数直接实例化对象的过程。
java LogUtil输出日志打日志的class文件内具体方法和行号
u010764629的博客
07-08 512
最近琢磨怎么/ 调用者位于LogUtil类元素之后的第三个元素（考虑到findCaller自身和getStackTrace的调用）* 本方法用于生成调用者方法的详细路径，包括类名、方法名和行号。* 通过分析当前线程的堆栈跟踪，找到第一个不是LogUtil类的方法作为调用者。// 如果是最后一个元素，直接添加到缓冲区，以保留类名的完整性。* 将带有包名的类名转换为首字母大写的形式，去除包名并连接类名。看效果，直接上代码。// 拼接类名、方法名和行号，生成详细的路径。// 格式化类名，去除包名，只保留类名部分。
java Pair怎么使用
最新发布
qq_42320804的博客
07-08 512
java Pair怎么使用
JS数据类型检测的方式有哪些 (常用)
karlaofsky的博客
07-08 194
Object.prototype.toString.call() ：这是一种比较准确的检测数据类型的方法。它通过获取 Object.prototype 上的 toString 方法，并使用 call 方法改变其 this 指向要检测的数据，从而返回数据类型的字符串。
C语言设计模式 PDF《C Design Pattern》
04-17
书中还提及了迭代器模式（Iterator）、责任链模式（Chain of Responsibility）和模板模式（Template Method），以及组合模式（Composite）和原型模式（Prototype），这些都是面向对象设计的核心技巧，能够帮助开发者...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

UestcXiye

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值