c++浅拷贝和深拷贝

在 C++ 中，浅拷贝和深拷贝是两种不同的对象复制方式。

浅拷贝是指在复制对象时，只是简单地复制对象的成员变量的值，而不会为对象的成员变量分配新的内存空间。因此，新对象和原对象共享同一块内存空间。如果原对象被修改，那么新对象中对应的成员变量也会被修改。

深拷贝是指在复制对象时，为对象的成员变量分配新的内存空间，并将原对象的值复制到新分配的内存空间中。因此，新对象和原对象拥有自己的内存空间，互不干扰。如果原对象被修改，新对象不会受到影响。

为了实现深拷贝，必须手动编写复制对象的代码。通常，可以通过 copy 构造函数和赋值操作符重载函数来实现深拷贝。

下面是一个浅拷贝和深拷贝的示例代码：

#include <iostream>
#include <cstring>

using namespace std;

class Person {
public:
    Person() {
        name = nullptr;
    }

    Person(const char* n, int a) {
        name = new char[strlen(n) + 1];
        strcpy(name, n);
        age = a;
    }

    // copy constructor (深拷贝)
    Person(const Person& p) {
        name = new char[strlen(p.name) + 1];
        strcpy(name, p.name);
        age = p.age;
    }

    // assignment operator (深拷贝)
    Person& operator=(const Person& p) {
        if (this != &p) {
            delete[] name;
            name = new char[strlen(p.name) + 1];
            strcpy(name, p.name);
            age = p.age;
        }
        return *this;
    }

    // destructor
    ~Person() {
        delete[] name;
    }

    void print() const {
        cout << "name: " << name << ", age: " << age << endl;
    }

private:
    char* name;
    int age;
};

int main() {
    Person p1("Alice", 20);
    Person p2 = p1; // 浅拷贝
    Person p3("Bob", 30);
    p3 = p1; // 浅拷贝

    cout << "p1: ";
    p1.print(); // name: Alice, age: 20

    cout << "p2: ";
    p2.print(); // name: Alice, age: 20

    cout << "p3: ";
    p3.print(); // name: Alice, age: 20

    p1.~Person();
    p2.~Person();
    p3.~Person();

    return 0;
}

在上面的示例代码中，`Person` 类包含一个 `char*` 类型的指针 `name` 和一个 `int` 类型的变量 `age`。在默认情况下，`name` 被初始化为 `nullptr`。

在 `Person` 类的构造函数中，为 `name` 分配内存空间，并将传入的字符串复制到该内存空间中。在 `Person` 类的析构函数中，释放 `name` 所指向的内存空间。

在 `Person` 类的 copy constructor 和 assignment operator 中，使用 `new` 运算符为 `name` 分配新的内存空间，并将原对象的值复制到新分配的内存空间中。同时，需要注意在 assignment operator 中，如果对象自赋值，需要先进行判断，否则会出现错误。

在 `main` 函数中，首先创建一个 `Person` 对象 `p1`。然后，通过拷贝构造函数和赋值操作符分别将 `p1` 赋值给 `p2` 和 `p3`。由于 `Person` 类的拷贝构造函数和赋值操作符实现的是深拷贝，因此 `p2` 和 `p3` 对象与 `p1` 对象拥有独立的内存空间，互不干扰。最后，释放所有对象的内存空间。