深拷贝与浅拷贝的实现差异 ​

面试考点 ​

这道题考察的是你对对象拷贝机制的理解,特别是当类中包含动态分配的资源(如堆内存、文件句柄)时,默认的浅拷贝会带来什么问题,以及怎么正确实现深拷贝。

核心区别 ​

浅拷贝(Shallow Copy):逐成员复制,指针只复制地址值,两个对象的指针指向同一块内存。

深拷贝(Deep Copy):为指针成员重新分配内存,复制指针指向的实际数据,两个对象各自拥有独立的内存。

基本示例 ​

cpp
#include <iostream>
#include <cstring>
#include <algorithm>

// ============================
// 浅拷贝的问题
// ============================

class ShallowString {
    char* data_;
    int length_;
public:
    // 构造函数:在堆上分配内存
    ShallowString(const char* str) {
        length_ = std::strlen(str);
        data_ = new char[length_ + 1];
        std::strcpy(data_, str);
        std::cout << "构造: \"" << data_ << "\" 地址: " << (void*)data_ << std::endl;
    }

    // 没有自定义拷贝构造函数——编译器生成默认的浅拷贝
    // ShallowString(const ShallowString& other)
    //     : data_(other.data_), length_(other.length_) {}
    // 两个对象的 data_ 指向同一块内存!

    ~ShallowString() {
        std::cout << "析构: 释放地址 " << (void*)data_ << std::endl;
        delete[] data_;  // 第二次 delete 同一块内存 -> 未定义行为!
    }

    void print() const {
        std::cout << "值: \"" << data_ << "\" 地址: " << (void*)data_ << std::endl;
    }
};

// ============================
// 深拷贝的正确实现
// ============================

class DeepString {
    char* data_;
    int length_;

    // 辅助函数:执行深拷贝
    void deep_copy(const char* src, int len) {
        length_ = len;
        data_ = new char[length_ + 1];      // 分配新内存
        std::memcpy(data_, src, length_ + 1); // 复制实际数据
    }

public:
    // 构造函数
    DeepString(const char* str) {
        deep_copy(str, std::strlen(str));
        std::cout << "构造: \"" << data_ << "\" 地址: " << (void*)data_ << std::endl;
    }

    // 拷贝构造函数:深拷贝
    DeepString(const DeepString& other) {
        deep_copy(other.data_, other.length_);
        std::cout << "拷贝构造: \"" << data_ << "\" 新地址: " << (void*)data_ << std::endl;
    }

    // 拷贝赋值运算符:深拷贝
    DeepString& operator=(const DeepString& other) {
        if (this == &other) return *this;  // 自赋值检查

        delete[] data_;                     // 释放旧内存
        deep_copy(other.data_, other.length_);
        std::cout << "赋值: \"" << data_ << "\" 新地址: " << (void*)data_ << std::endl;
        return *this;
    }

    // 析构函数
    ~DeepString() {
        std::cout << "析构: 释放地址 " << (void*)data_ << std::endl;
        delete[] data_;
    }

    void print() const {
        std::cout << "值: \"" << data_ << "\" 地址: " << (void*)data_ << std::endl;
    }

    void set(const char* str) {
        delete[] data_;
        deep_copy(str, std::strlen(str));
    }
};

// ============================
// 演示深拷贝的独立性
// ============================

void deep_copy_demo() {
    DeepString s1("Hello");
    DeepString s2 = s1;  // 拷贝构造:深拷贝

    s1.print();  // 各自有独立的内存
    s2.print();

    s1.set("World");  // 修改 s1 不影响 s2
    std::cout << "修改 s1 后:" << std::endl;
    s1.print();
    s2.print();  // s2 仍然是 "Hello"
}

// ============================
// 三/五法则
// ============================

// 如果类需要自定义析构函数,通常也需要自定义拷贝构造和拷贝赋值
// C++11 起扩展为五法则:还需要移动构造和移动赋值

class Resource {
    int* data_;
    int size_;

public:
    // 构造函数
    Resource(int size) : size_(size), data_(new int[size]{}) {
        std::cout << "Resource 构造, size=" << size << std::endl;
    }

    // 析构函数
    ~Resource() {
        delete[] data_;
        std::cout << "Resource 析构" << std::endl;
    }

    // 拷贝构造函数(深拷贝)
    Resource(const Resource& other) : size_(other.size_), data_(new int[other.size_]) {
        std::copy(other.data_, other.data_ + size_, data_);
        std::cout << "Resource 拷贝构造" << std::endl;
    }

    // 拷贝赋值运算符(深拷贝)
    Resource& operator=(const Resource& other) {
        if (this != &other) {
            delete[] data_;
            size_ = other.size_;
            data_ = new int[size_];
            std::copy(other.data_, other.data_ + size_, data_);
            std::cout << "Resource 拷贝赋值" << std::endl;
        }
        return *this;
    }

    // 移动构造函数(C++11)
    Resource(Resource&& other) noexcept : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;  // 转移所有权
        other.size_ = 0;
        std::cout << "Resource 移动构造" << std::endl;
    }

    // 移动赋值运算符(C++11)
    Resource& operator=(Resource&& other) noexcept {
        if (this != &other) {
            delete[] data_;
            data_ = other.data_;
            size_ = other.size_;
            other.data_ = nullptr;
            other.size_ = 0;
            std::cout << "Resource 移动赋值" << std::endl;
        }
        return *this;
    }
};

int main() {
    std::cout << "=== 深拷贝演示 ===" << std::endl;
    deep_copy_demo();

    return 0;
}

浅拷贝 vs 深拷贝 ​

特性浅拷贝深拷贝
指针成员复制地址值分配新内存并复制数据
内存独立性共享同一块内存各自独立
修改影响修改一个影响另一个互不影响
析构问题双重释放(崩溃)各自正常释放
性能快(只复制地址)慢(需要分配+复制)
默认行为编译器默认生成需要手动实现

常见问题 ​

什么时候需要深拷贝?

当类拥有动态分配的资源(new 出来的内存、文件句柄、网络连接等)时,默认的浅拷贝会导致多个对象共享同一份资源,析构时会重复释放。这时必须实现深拷贝。

三法则和五法则是什么?

三法则:如果类需要自定义析构函数、拷贝构造函数、拷贝赋值运算符中的任何一个,通常三个都需要。五法则(C++11):在三法则基础上加上移动构造函数和移动赋值运算符。

怎么避免手动管理深拷贝?

用标准库容器(std::string、std::vector)替代裸指针。它们内部已经正确实现了深拷贝,你的类用它们做成员就不需要手动写拷贝函数。

适用场景 ​

  • 管理动态数组的类
  • 自定义字符串类
  • 资源管理类(文件、连接、锁)
  • 包含堆分配成员的任何类

注意事项 ​

  • 拷贝赋值运算符要检查自赋值
  • 拷贝赋值运算符要先释放旧资源再分配新资源
  • 优先使用标准库容器避免手动管理内存
  • C++11 的移动语义可以避免不必要的深拷贝
  • copy-and-swap 惯用法可以简化拷贝赋值的实现

总结 ​

浅拷贝只复制指针的地址值,两个对象共享同一块内存,会导致双重释放和数据被意外修改。深拷贝为指针成员重新分配内存并复制实际数据,保证对象的独立性。当类管理动态资源时必须实现深拷贝。遵循三/五法则确保拷贝和移动操作的正确性。最好的做法是用标准库容器(如 std::string、std::vector)做成员,让编译器自动生成正确的拷贝操作。