C++原型模式克隆对象 深拷贝浅拷贝对比

原型模式通过复制对象创建新实例，需区分深拷贝与浅拷贝：浅拷贝仅复制指针值，导致内存共享和重复释放风险；深拷贝则分配独立内存，确保对象安全独立，推荐在clone()中实现深拷贝以避免资源冲突。

在C++中，原型模式（prototype Pattern）是一种创建型设计模式，它通过复制现有对象来创建新对象，而不是通过 new 关键字重新构造。实现原型模式的关键是拷贝机制——而拷贝又分为深拷贝和浅拷贝。理解它们的区别对正确实现对象克隆至关重要。

浅拷贝：只复制基本数据，共享指针资源

默认的拷贝构造函数和赋值操作符执行的是浅拷贝。这意味着对象的成员变量被逐个复制，但如果成员是指针，那么复制的是指针的值（即地址），而不是它指向的数据。

这会导致多个对象共享同一块动态内存，一旦其中一个对象释放了该内存，其他对象的指针就变成了悬空指针，容易引发崩溃或未定义行为。

示例：

立即学习“C++免费学习笔记（深入）”；

假设有一个类包含一个指向字符串的指针：

class Person {
private:
    char* name;
public:
    Person(const char* n) {
        name = new char[strlen(n) + 1];
        strcpy(name, n);
    }
    // 默认拷贝构造函数是浅拷贝
    ~Person() { delete[] name; }
};

如果使用默认拷贝：

Person p1(“Alice”);
Person p2 = p1; // 浅拷贝，p1 和 p2 的 name 指向同一块内存

当 p1 和 p2 析构时，同一块内存被 delete 两次，程序崩溃。

深拷贝：复制指针指向的数据，独立内存

深拷贝会为新对象分配新的内存，并将原对象的数据复制过去，确保两个对象完全独立。

要实现深拷贝，必须自定义拷贝构造函数和赋值操作符。

改进示例：

Person(const Person& other) {
    name = new char[strlen(other.name) + 1];
    strcpy(name, other.name);
}

Person& operator=(const Person& other) {
    if (this != &other) {
        delete[] name; // 释放原有资源
        name = new char[strlen(other.name) + 1];
        strcpy(name, other.name);
    }
    return *this;
}

这样，每个 Person 对象都有自己独立的 name 内存，互不影响。

原型模式中的克隆接口设计

在原型模式中，通常定义一个 clone() 接口，子类根据需要实现深拷贝或浅拷贝。

推荐始终使用深拷贝，除非明确知道共享资源是安全且有意的。

典型实现：

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

class ConcretePrototype : public Prototype {
private:
    char* data;
public:
    ConcretePrototype(const char* d) {
        data = new char[strlen(d) + 1];
        strcpy(data, d);
    }

    ConcretePrototype(const ConcretePrototype& other) {
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }

    ConcretePrototype& operator=(const ConcretePrototype& other) {
        if (this != &other) {
            delete[] data;
            data = new char[strlen(other.data) + 1];
            strcpy(data, other.data);
        }
        return *this;
    }

    Prototype* clone() const override {
        return new ConcretePrototype(*this); // 调用拷贝构造函数，深拷贝
    }

    ~ConcretePrototype() {
        delete[] data;
    }
};

使用 clone() 创建的对象是完全独立的副本，避免了资源冲突。

基本上就这些。深拷贝安全但开销大，浅拷贝高效但危险。在原型模式中，除非有特殊需求，否则应优先实现深拷贝，确保对象独立性和程序稳定性。