面试题：C++重写拷贝构造函数时的深拷贝与浅拷贝陷阱

Question

已知类`ComplexClass`，它包含一个指向另一个类`SubClass`对象的指针成员`SubClass* subPtr`，`SubClass`类也有自己的动态资源。请为重写`ComplexClass`的拷贝构造函数，详细说明如何处理深拷贝以避免浅拷贝带来的内存错误，并且解释在这种场景下浅拷贝可能导致的具体问题有哪些？

Answer 1

深拷贝实现

#include <iostream>
#include <cstring>

class SubClass {
private:
    int* data;
public:
    SubClass() {
        data = new int(0);
    }
    SubClass(const SubClass& other) {
        data = new int(*other.data);
    }
    SubClass& operator=(const SubClass& other) {
        if (this != &other) {
            delete data;
            data = new int(*other.data);
        }
        return *this;
    }
    ~SubClass() {
        delete data;
    }
};

class ComplexClass {
private:
    SubClass* subPtr;
public:
    ComplexClass() {
        subPtr = new SubClass();
    }
    ComplexClass(const ComplexClass& other) {
        subPtr = new SubClass(*other.subPtr);
    }
    ComplexClass& operator=(const ComplexClass& other) {
        if (this != &other) {
            delete subPtr;
            subPtr = new SubClass(*other.subPtr);
        }
        return *this;
    }
    ~ComplexClass() {
        delete subPtr;
    }
};

浅拷贝问题

1. 双重释放：浅拷贝时，ComplexClass对象的subPtr指针会直接复制被拷贝对象的subPtr指针的值，这意味着两个ComplexClass对象中的subPtr指针指向同一块内存。当这两个对象先后析构时，同一块SubClass对象的内存会被释放两次，导致未定义行为。
2. 悬挂指针：如果一个ComplexClass对象析构后，另一个ComplexClass对象的subPtr指针仍然指向已经释放的内存，这就产生了悬挂指针。当使用这个悬挂指针访问内存时，会导致程序崩溃或未定义行为。