深入C++：深拷贝VS浅拷贝，编程高手必懂的技巧与陷阱

前面系列文章已经很多次讲过深拷贝与浅拷贝相关的主题。
就其中的基本概念和使用习惯，读者可自行看往期文章。再次不在赘述。
【传送门】👉👉👉

• [1] 一说 拷贝构造函数 && 拷贝赋值函数
• [2] 二说 拷贝构造函数 && 拷贝赋值函数
• [3] 三说 拷贝构造之禁用

本文着重讲下其使用上的区别，更注重于实战，而非泛泛而谈。

区别

在编写代码时，判断执行的是深拷贝还是浅拷贝，主要区别在于拷贝构造函数（copy constructor）和赋值运算符重载（assignment operator overload）的实现方式。

以下是判断深拷贝和浅拷贝的主要区别：

1. 深拷贝（Deep Copy）：

• 在拷贝构造函数和赋值运算符重载中，需要对类中的指针或资源进行复制操作，并创建新的资源。
• 复制的是对象的内容而不是地址，拷贝后的对象与原对象相互独立，各自管理自己的资源。

2. 浅拷贝（Shallow Copy）：

• 在拷贝构造函数和赋值运算符重载中，只是简单地复制对象的指针或地址，而不是复制对象的内容。
• 拷贝后的对象与原对象共享同一份资源，可能导致资源的重复释放或者悬空指针等问题。

在代码中，可以通过以下方式判断执行的是深拷贝还是浅拷贝：

1. 深拷贝的标志：

• 拷贝构造函数和赋值运算符重载中，对动态分配的内存进行了复制操作，并创建了新的资源。
• 类中包含有指针成员，拷贝操作会创建新的指针，并深度复制指针所指向的对象。

2. 浅拷贝的标志：

• 拷贝构造函数和赋值运算符重载中，只是简单地复制指针或地址，没有对指针指向的对象进行复制操作。
• 类中没有动态分配的内存，或者在拷贝操作中没有对动态分配的内存进行复制。

在编写代码时，需要特别注意对拷贝构造函数和赋值运算符重载的实现，确保按照需求执行深拷贝或浅拷贝操作，以避免资源管理问题和内存泄漏等情况。

一个栗子

#include <iostream>
#include <string>

class B {
private:
    std::string name;

public:
    B(const std::string& n) : name(n) {}
    std::string getName() const { return name; }
};

class A {
private:
    B* ptrB;
    int number;
    std::string text;

public:
    A() : ptrB(new B("default")), number(0), text("default") {} // 默认构造函数，分配动态内存
    ~A() { delete ptrB; }                                      // 析构函数，释放动态内存

    // 拷贝构造函数，执行深拷贝
    A(const A& other) : ptrB(new B(*(other.ptrB))), number(other.number), text(other.text) {}

    // 赋值运算符重载，执行深拷贝
    A& operator=(const A& other) {
        if (this != &other) {
            delete ptrB;
            ptrB = new B(*(other.ptrB));
            number = other.number;
            text = other.text;
        }
        return *this;
    }

    // 拷贝函数，执行深拷贝
    A* copy0() {
        return new A(*this);
    }
    
    // 拷贝函数，执行深拷贝
    A& copy1() {
        return *(new A(*this));
    }
    
    void setBName(const std::string& name) { ptrB->setName(name); }
    std::string getBName() const { return ptrB->getName(); }

    void setNumber(int num) { number = num; }
    int getNumber() const { return number; }

    void setText(const std::string& txt) { text = txt; }
    std::string getText() const { return text; }
};

int main() {
    A a1;
    a1.setBName("Object B1");
    a1.setNumber(100);
    a1.setText("Object Text1");

    // 使用拷贝构造函数进行拷贝
    A a2 = a1;

    std::cout << "a1 B name: " << a1.getBName() << ", Number: " << a1.getNumber() << ", Text: " << a1.getText() << std::endl;
    std::cout << "a2 B name: " << a2.getBName() << ", Number: " << a2.getNumber() << ", Text: " << a2.getText() << std::endl;

    // 修改a2的数据
    a2.setBName("Object B2");
    a2.setNumber(200);
    a2.setText("Object Text2");

    // 输出修改后的数据
    std::cout << "a1 B name: " << a1.getBName() << ", Number: " << a1.getNumber() << ", Text: " << a1.getText() << std::endl;
    std::cout << "a2 B name: " << a2.getBName() << ", Number: " << a2.getNumber() << ", Text: " << a2.getText() << std::endl;

    return 0;
}

在这个示例中，类 A 中的成员变量 ptrB 是指向类 B 对象的指针，同时还包含整型 number 和字符串 text 等基本数据类型的成员变量。在拷贝构造函数和赋值运算符重载中，对于指针成员变量 ptrB，执行了深拷贝；而对于整型和字符串等基本数据类型的成员变量，直接进行了值的复制，即浅拷贝。这样可以确保在拷贝对象时，对指向对象的指针进行了复制，避免了指针指向的资源重复释放的问题。