原型模式需要深拷贝是因为浅拷贝会导致新旧对象共享内部资源，修改一个对象的数据可能影响另一个对象，破坏对象独立性。1. 深拷贝确保每个对象拥有独立的资源副本，避免数据干扰；2. 使用智能指针如 std::unique_ptr 可自动管理内存，防止内存泄漏；3. 对于多态成员，需递归调用 clone() 方法，确保整个对象图正确复制。这三方面共同保障了原型模式中克隆对象的完整性和独立性。
在C++里实现原型模式（Prototype Pattern），说白了就是通过复制现有对象来创建新对象，而不需要知道具体是哪个类。这里头最核心、也最容易让人头疼的，就是怎么确保“深拷贝”，以及你的克隆接口该怎么设计才能既安全又好用。它不是简单的内存复制，而是要确保复制出来的新对象和原对象之间，即便内部有指针或者复杂结构，也能保持完全的独立性。
解决方案
原型模式的核心在于一个抽象的基类，它声明了一个用于克隆自身的纯虚函数。然后，每个具体的派生类负责实现这个克隆方法，通过调用自身的拷贝构造函数来创建一个全新的、独立的副本。这里，我们倾向于使用智能指针，比如
std::unique_ptr，来管理克隆出来的对象的生命周期，这样能大大减少内存泄漏的风险和手动管理指针的负担。
#include <iostream>
#include <string>
#include <memory> // For std::unique_ptr
// 抽象原型基类
class Shape {
public:
virtual ~Shape() = default; // 虚析构函数，确保正确释放内存
// 纯虚克隆函数，返回一个指向新创建对象的智能指针
virtual std::unique_ptr<Shape> clone() const = 0;
virtual void draw() const = 0;
};
// 具体原型类：圆形
class Circle : public Shape {
private:
int radius;
// 假设圆形内部有一个复杂的动态分配数据，需要深拷贝
std::unique_ptr<std::string> color;
public:
Circle(int r = 0, const std::string& c = "red") : radius(r), color(std::make_unique<std::string>(c)) {
// std::cout << "Circle constructor: " << r << ", " << *color << std::endl;
}
// 拷贝构造函数：执行深拷贝
Circle(const Circle& other) : radius(other.radius) {
if (other.color) {
color = std::make_unique<std::string>(*other.color); // 深拷贝color指向的数据
} else {
color = nullptr;
}
// std::cout << "Circle deep copy constructor called." << std::endl;
}
// 拷贝赋值运算符（虽然原型模式主要依赖拷贝构造，但为了完整性）
Circle& operator=(const Circle& other) {
if (this != &other) {
radius = other.radius;
if (other.color) {
color = std::make_unique<std::string>(*other.color);
} else {
color = nullptr;
}
}
return *this;
}
// 实现克隆方法
std::unique_ptr<Shape> clone() const override {
return std::make_unique<Circle>(*this); // 调用自身的拷贝构造函数
}
void draw() const override {
std::cout << "Drawing Circle with radius " << radius << " and color " << (color ? *color : "N/A") << std::endl;
}
void setRadius(int r) { radius = r; }
void setColor(const std::string& c) { *color = c; }
};
// 具体原型类：矩形
class Rectangle : public Shape {
private:
int width;
int height;
// 假设矩形内部有一个简单的指针，需要深拷贝
int* id;
public:
Rectangle(int w = 0, int h = 0, int i = 0) : width(w), height(h), id(new int(i)) {
// std::cout << "Rectangle constructor: " << w << ", " << h << ", " << *id << std::endl;
}
// 拷贝构造函数：执行深拷贝
Rectangle(const Rectangle& other) : width(other.width), height(other.height) {
if (other.id) {
id = new int(*other.id); // 深拷贝id指向的数据
} else {
id = nullptr;
}
// std::cout << "Rectangle deep copy constructor called." << std::endl;
}
// 拷贝赋值运算符
Rectangle& operator=(const Rectangle& other) {
if (this != &other) {
width = other.width;
height = other.height;
delete id; // 释放旧资源
if (other.id) {
id = new int(*other.id); // 分配新资源并深拷贝
} else {
id = nullptr;
}
}
return *this;
}
~Rectangle() override {
delete id; // 释放动态分配的内存
// std::cout << "Rectangle destructor called." << std::endl;
}
// 实现克隆方法
std::unique_ptr<Shape> clone() const override {
return std::make_unique<Rectangle>(*this); // 调用自身的拷贝构造函数
}
void draw() const override {
std::cout << "Drawing Rectangle with width " << width << ", height " << height << " and ID " << (id ? *id : 0) << std::endl;
}
void setDimensions(int w, int h) { width = w; height = h; }
void setId(int i) { *id = i; }
};
// 客户端代码示例
// int main() {
// // 创建原型对象
// std::unique_ptr<Circle> originalCircle = std::make_unique<Circle>(10, "blue");
// std::unique_ptr<Rectangle> originalRectangle = std::make_unique<Rectangle>(20, 30, 101);
// originalCircle->draw();
// originalRectangle->draw();
// std::cout << "\nCloning objects...\n";
// // 克隆对象
// std::unique_ptr<Shape> clonedCircle = originalCircle->clone();
// std::unique_ptr<Shape> clonedRectangle = originalRectangle->clone();
// clonedCircle->draw();
// clonedRectangle->draw();
// std::cout << "\nModifying cloned objects (should not affect originals)...\n";
// // 修改克隆对象，验证深拷贝
// // 注意：clonedCircle和clonedRectangle是Shape类型，如果需要调用Circle/Rectangle特有的方法，需要dynamic_cast
// if (auto c = dynamic_cast<Circle*>(clonedCircle.get())) {
// c->setRadius(15);
// c->setColor("green");
// }
// if (auto r = dynamic_cast<Rectangle*>(clonedRectangle.get())) {
// r->setDimensions(25, 35);
// r->setId(102);
// }
// clonedCircle->draw();
// clonedRectangle->draw();
// std::cout << "\nOriginal objects after modification of clones (should remain unchanged):\n";
// originalCircle->draw();
// originalRectangle->draw();
// // 智能指针会自动管理内存，无需手动delete
// return 0;
// }为什么原型模式需要深拷贝，而不是简单的浅拷贝？
这是个老生常谈的问题，但对于原型模式来说，它的重要性再怎么强调都不为过。浅拷贝（shallow copy）只是复制了对象本身的成员变量值，如果这些成员变量是指针，那么新旧对象会共享同一块内存区域。这听起来可能没什么，但一旦你修改了其中一个对象通过指针指向的数据，另一个对象的数据也会跟着变，这完全违背了我们克隆一个“独立”新对象的初衷。
立即学习“C++免费学习笔记（深入）”；
想象一下，你克隆了一个复杂的文档对象，如果只是浅拷贝，那么文档内部的图片、文本段落这些动态分配的内容，新旧文档可能都指向同一份数据。当你修改新文档里的某个图片，原文档里的图片也变了，这简直是灾难。深拷贝（deep copy）则不同，它会为所有动态分配的资源创建全新的副本。这意味着新对象拥有自己独立的数据，对新对象的任何修改都不会影响到原对象。原型模式的核心价值就在于提供一个“全新且独立”的副本，深拷贝是实现这一目标不可或缺的基石。没有深拷贝，原型模式就失去了它最吸引人的魔力，变成了一个潜在的bug制造机。
如何设计安全的 clone()
接口，是返回裸指针还是智能指针？
设计
clone()接口时，最常见的选择是返回一个指向新创建对象的指针。过去，这通常意味着返回一个裸指针，比如
virtual Shape* clone() const = 0;。这种做法简单直接，但问题在于内存管理：谁来负责
delete这个新创建的对象？如果调用者忘记释放内存，就会导致内存泄漏。这就像你拿到一把钥匙，却不知道锁在哪里，或者把钥匙弄丢了。
所以，我个人更倾向于使用智能指针，特别是
std::unique_ptr<Shape>。将
clone()方法的返回类型设计为
std::unique_ptr<Shape>，如
virtual std::unique_ptr<Shape> clone() const = 0;，这是一种更现代、更安全的做法。
std::unique_ptr明确表示了所有权的转移：一旦
clone()返回，它所指向的对象的生命周期就由接收它的
unique_ptr实例负责了。当
unique_ptr超出作用域时，它会自动调用
delete，避免了内存泄漏的风险。这大大简化了客户端代码的内存管理逻辑，让开发者可以更专注于业务逻辑而非底层资源管理。当然，如果你的项目环境不允许使用C++11及以上特性，或者有特定的性能敏感场景，裸指针或许还能考虑，但那也意味着你需要非常严格的内存管理规范和更多的注意力。
面对复杂对象和多态成员，如何确保克隆的完整性？
当你的原型对象内部包含其他复杂对象，特别是那些本身也具有多态性的成员时，确保克隆的完整性会变得有点棘手。如果一个
Shape对象内部包含了一个
Material对象，而
Material又有
PlasticMaterial和
MetalMaterial等多种派生类，仅仅在
Shape的拷贝构造函数里对
Material成员进行简单的按值复制（即使
Material有自己的拷贝构造函数），可能无法正确处理多态性。
正确的做法是，如果
Shape的成员本身也是一个多态类型（比如一个
std::unique_ptr<Material>），那么这个成员自身也需要实现一个
clone()方法。这样，在
Shape的拷贝构造函数中，你就需要递归地调用其成员的
clone()方法，来确保这些内部的多态对象也能被正确地深拷贝。这被称为“虚拟拷贝构造函数”模式的扩展应用。
例如，如果
Shape有一个
std::unique_ptr<Material> material;成员，那么
Shape的拷贝构造函数可能看起来像这样：
// Shape的拷贝构造函数片段
MyShape(const MyShape& other) : /* ...其他成员... */ {
if (other.material) {
material = other.material->clone(); // 递归调用material的clone()方法
} else {
material = nullptr;
}
}这意味着，你的
Material基类也需要有一个
virtual std::unique_ptr<Material> clone() const = 0;方法，并且所有
Material的派生类（如
PlasticMaterial,
MetalMaterial）都要实现它。这样，无论
Material成员在运行时具体是哪种
Material派生类，
clone()调用都能正确地创建出相应类型的深拷贝副本。这种链式克隆确保了整个对象图的完整复制，避免了在复杂结构中出现共享引用或类型不匹配的问题。它确实增加了实现的复杂性，但对于构建健壮、可扩展的系统来说，这是值得付出的代价。
