原型模式中必须实现深拷贝以确保克隆安全，浅拷贝会导致内存共享和重复释放问题；通过自定义拷贝构造函数、赋值操作符及clone方法实现独立复制，避免未定义行为。
在C++中，原型模式（Prototype Pattern）是一种创建型设计模式，它通过复制现有对象来创建新对象，而不是通过 new 关键字重新构造。实现这一模式的关键在于对象的克隆（clone）机制，而克隆的核心问题就是深拷贝与浅拷贝的选择。两者的行为差异直接影响程序的正确性和内存安全。
浅拷贝：默认行为，共享指针数据
当类中包含指针成员时，如果未显式定义拷贝构造函数或赋值操作符，编译器会生成默认的拷贝行为——浅拷贝。
浅拷贝只是复制对象的成员变量值，对于指针，仅复制其地址，而不复制它指向的内存。这意味着原对象和副本共享同一块动态数据。
问题：一旦其中一个对象释放了该内存，另一个对象的指针就变成悬空指针，再次访问将导致未定义行为。示例：
立即学习“C++免费学习笔记（深入）”；
class BadPrototype {
public:
int* data;
int size;
<pre class='brush:php;toolbar:false;'>BadPrototype(int s) : size(s) {
data = new int[s];
for (int i = 0; i < s; ++i) data[i] = i;
}
// 编译器生成的拷贝构造函数是浅拷贝
// BadPrototype(const BadPrototype& other) { ... }
// 仅复制 data 指针，不复制内容
~BadPrototype() {
delete[] data;
}
};
// 使用 BadPrototype a(5); BadPrototype b = a; // 浅拷贝，data 指向同一块内存 // 析构时，同一块内存被 delete 两次 → 崩溃
深拷贝：真正复制所有数据
深拷贝要求为指针成员重新分配内存，并将原对象的数据逐字复制过去，确保副本拥有独立的数据资源。
在原型模式中，实现深拷贝是安全克隆的前提。
修正上面的例子：
class GoodPrototype {
public:
int* data;
int size;
<pre class='brush:php;toolbar:false;'>GoodPrototype(int s) : size(s) {
data = new int[s];
for (int i = 0; i < s; ++i) data[i] = i;
}
// 深拷贝构造函数
GoodPrototype(const GoodPrototype& other) : size(other.size) {
data = new int[size];
for (int i = 0; i < size; ++i) {
data[i] = other.data[i];
}
}
// 拷贝赋值操作符（略，需检查自赋值）
GoodPrototype& operator=(const GoodPrototype& other) {
if (this != &other) {
delete[] data;
size = other.size;
data = new int[size];
for (int i = 0; i < size; ++i) {
data[i] = other.data[i];
}
}
return *this;
}
~GoodPrototype() {
delete[] data;
}
};
现在，每个对象都拥有独立的 data 内存，析构时互不影响。
原型模式中的 clone() 接口设计
为了支持多态克隆，通常在基类中声明一个纯虚 clone 函数，由派生类实现自己的深拷贝逻辑。
示例：
立即学习“C++免费学习笔记（深入）”；
class Prototype {
public:
virtual Prototype* clone() const = 0;
virtual ~Prototype() = default;
};
<p>class ConcretePrototype : public Prototype {
int* data;
int size;
public:
ConcretePrototype(int s) : size(s), data(new int[s]) {
for (int i = 0; i < s; ++i) data[i] = i;
}</p><pre class='brush:php;toolbar:false;'>// 深拷贝实现
ConcretePrototype* clone() const override {
return new ConcretePrototype(*this); // 调用拷贝构造函数
}
~ConcretePrototype() {
delete[] data;
}
// 必须也实现拷贝构造函数为深拷贝
ConcretePrototype(const ConcretePrototype& other) : size(other.size) {
data = new int[size];
for (int i = 0; i < size; ++i) {
data[i] = other.data[i];
}
}
};
使用：
Prototype* obj1 = new ConcretePrototype(5); Prototype* obj2 = obj1->clone(); // 安全克隆，独立内存 delete obj1; delete obj2; // 不会冲突
总结：深拷贝 vs 浅拷贝 关键点
- 浅拷贝：只复制成员值，指针成员共享内存，适用于无动态资源的类。
- 深拷贝：为指针成员分配新内存并复制内容，是原型模式中安全克隆的基础。
- 实现原型模式时，必须重写拷贝构造函数、赋值操作符，并在 clone() 中调用它们。
- 使用智能指针（如 shared_ptr）可简化资源管理，但 clone 仍需明确语义：是共享还是复制？
基本上就这些。原型模式的克隆是否安全，取决于你是否正确实现了深拷贝逻辑。不复杂但容易忽略。
