一，原型模式的定义
原型模式是一种创建型设计模式，它允许通过克隆已有对象来创建新对象，从而无需调用显式的实例化过程。
原型模式的设计，使得它可以创建一个与原型对象相同或类似的新对象，同时又可以减少对象实例化操作产生的性能开销，使得创建对象的操作更加便捷，它减少了大量不必要的重复工作，并提高了系统性能。
当创建对象的操作比较复杂和耗时的时候，原型模式则提供了一个更加高效和简单的创建对象的模式，它可以更加快速的创建对象的副本，且不需要依赖对象的某些实例化步骤，它避免了使用传统的new关键字创建对象实例时的复杂构造过程。
原型模式的主要缺点则是原型对象必须预先存在于系统中，并且需要预先进行注册。此时，如果有大量的原型对象需要被创建，并且每个原型对象都需要进行自定义，维护和管理这些原型对象可能会变得很复杂。

原型模式在现实生活中的抽象实例：
图形绘制：假设我们需要绘制不同形状的图形，可以定义一个图形类作为原型，然后通过克隆该原型对象来创建具体的图形对象。
陶艺制作：先制作一个陶艺原型作为参考，然后通过复制或克隆原型来制作出多个相似的陶艺品。
服装设计：设计师预先设计一套成衣样板，然后通过复制或克隆样板来制作出多件相似或不同款式的服装。

二，原型模式的结构

原型模式主要包含以下组件：
1.抽象原型(Prototype)：
定义克隆方法的接口，具体原型类通过实现这些方法来提供其自身的副本。

2.具体原型(ConcretePrototype)：
包含抽象原型类的具体实现，它会提供一个复制自身的方法，该方法将创建并返回一个对象副本。

3.客户端(Client)：
客户端使用原型类来创建新对象的副本，它会先获取原型对象，并使用原型对象的克隆方法来创建新的对象实例。

组件之间的工作步骤如下：
1.客户端通过实例化具体原型类，并调用其克隆方法来创建一个原型对象。
2.原型对象调用自身的克隆方法，将自身复制一份，返回一个克隆的对象。
3.客户端获取到克隆对象后，可以根据自身的业务需求对其进行进一步的修改和使用。

对应UML类图：

三，原型模式代码样例
Demo1：

include

include

//定义原型基类
class Prototype {
public:
virtual ~Prototype() {}
virtual Prototype* clone() const = 0;
virtual void print() const = 0;
};

//定义具体原型类
class ConcretePrototype : public Prototype{
private:
std::string name;
public:
ConcretePrototype(const std::string& name) : name(name) {}
Prototype* clone() const override {
return new ConcretePrototype(*this);
}
void print() const override {
std::cout << “Prototype: ” << name << std::endl;
}
};

int main() {
//创建原型对象
ConcretePrototype prototype(“Original”);
//使用原型对象创建新对象
Prototype* clone = prototype.clone();
clone->print();
//释放内存
delete clone;
return 0;
}
运行结果：
Prototype: Original

Demo2：

include

include

class Prototype {
public:
virtual ~Prototype() {}
virtual Prototype* clone() const = 0;
virtual void info() const = 0;
};

class ConcretePrototypeA: public Prototype {
public:
ConcretePrototypeA(int id, std::string name)
: m_id(id), m_name(name) {}
Prototype* clone() const override {
return new ConcretePrototypeA(*this);
}
void info() const override {
std::cout << “ConcretePrototypeA: id = “
<< m_id << “, name = “
<< m_name << std::endl;
}
private:
int m_id;
std::string m_name;
};

class ConcretePrototypeB: public Prototype {
public:
ConcretePrototypeB(std::string description)
: m_description(description) {}
Prototype* clone() const override {
return new ConcretePrototypeB(*this);
}
void info() const override {
std::cout << “ConcretePrototypeB: description = “
<< m_description << std::endl;
}
private:
std::string m_description;
};

int main() {
ConcretePrototypeA* prototypeA = new ConcretePrototypeA(1, “First”);
Prototype* cloneA = prototypeA->clone();
cloneA->info();
ConcretePrototypeB* prototypeB = new ConcretePrototypeB(“This is a prototype”);
Prototype* cloneB = prototypeB->clone();
cloneB->info();
delete prototypeA;
delete cloneA;
delete prototypeB;
delete cloneB;
return 0;
}
运行结果：
ConcretePrototypeA: id = 1, name = First
ConcretePrototypeB: description = This is a prototype

四，原型模式的应用场景

图形用户界面：创建可定制的控件，如Windows的对话框，设计一个原型控件，让用户根据需求选择属性进行定制。
文本编辑器开发：支持“剪切”、“复制”、“粘贴”的功能，使用已存在的文档作为复制和创建新文档的原型。
数据库开发：将数据库的某个状态视为原型，当需要创建新的数据库版本时，可以直接从这个原型复制。
配置工具开发：基于原型模式帮助快速生成配置对象，而无需每次都新建一个空的配置。
Web应用程序：让用户可以在原型基础上添加、修改字段，动态生成表单元素。

五，原型模式的优缺点

原型模式的优点：
简化了对象的创建过程，使得代码更加简洁且易于维护。
提高了动态创建对象和销毁对象的效率。
封装和隐藏了创建对象的细节。
减少了对构造函数的直接调用，提高了代码的性能。
支持灵活的定制具体对象的属性和方法。

原型模式的缺点：
需要实现克隆对象的接口。
需要配合深拷贝或浅拷贝来使用，可能会导致引用对象的复制。
有的原型模式基于递归的方式来克隆对象，可能会引起堆栈溢出的问题。
针对大型对象的复制，会占用特别多的内存。

六，代码实战

Demo1：基于智能指针封装的原型模式：

include

include

class Prototype {
public:
virtual std::unique_ptr clone() const = 0;
void printValue() const {
std::cout << “Origin Value.” << std::endl;
}
};

class ConcretePrototype : public Prototype {
private:
int value;
public:
ConcretePrototype(int v) : value(v) {}
std::unique_ptr clone() const override {
return std::make_unique(value);
}
void printValue() const {
std::cout << “Value: ” << value << std::endl;
}
};

int main() {
auto prototype = std::make_unique(5);
auto clonedPrototype = prototype->clone();
prototype->printValue();
clonedPrototype->printValue();
return 0;
}
运行结果：
Value: 5
Origin Value.
Demo2：基于工厂的方式管理各种原型

include

include

include

class Prototype {
public:
int data;
std::string name;
Prototype(int data, const std::string& name) : data(data), name(name) {}
virtual Prototype* clone() {
return new Prototype(*this);
}
};

class PrototypeFactory {
private:
std::map> prototypes; public: PrototypeFactory() { prototypes[“original”] = new Prototype(40, “Original”); prototypes[“copy”] = new Prototype(100, “Copy”); } Prototype create(const std::string& type) { return prototypes[type]->clone();
}
};

int main() {
PrototypeFactory factory;
Prototype* original = factory.create(“original”);
Prototype* copy = factory.create(“copy”);

std::cout << "Original: data="
          << original->data
          << ", name="
          << original->name << std::endl;
std::cout << "Copy: data="
          << copy->data
          << ", name="
          << copy->name << std::endl;

delete original;
delete copy;
return 0;

}
运行结果：
Original: data=40, name=Original
Copy: data=100, name=Copy
七，参考阅读
https://softwarepatterns.com/cpp/prototype-software-pattern-cpp-example
https://www.geeksforgeeks.org/prototype-design-pattern/
https://www.tutorialspoint.com/design_pattern/prototype_pattern.html
https://sourcemaking.com/design_patterns/prototype
https://softwareparticles.com/design-patterns-prototype/