C++复合对象深拷贝和浅拷贝区别详解-C++-PHP中文网

深拷贝会为对象及其动态资源创建独立副本，确保内存独立；浅拷贝仅复制成员值，导致指针共享同一内存。默认拷贝是浅拷贝，当类含有指向堆内存的指针时，会造成双重释放、悬空指针和数据不一致。例如，MyString类中两个对象通过浅拷贝共享data指针，析构时会重复释放同一内存而崩溃。实现深拷贝需遵循“三大法则”，手动编写拷贝构造函数和拷贝赋值运算符，在构造时分配新内存并复制内容，赋值前释放旧资源并处理自赋值。使用智能指针（如std::shared_ptr）可避免手动管理，符合“Rule of Zero”。对象含动态资源且需独立生命周期时应选深拷贝；仅含值类型成员或使用智能指针时，浅拷贝安全高效。

c++复合对象深拷贝和浅拷贝区别详解

在C++中，复合对象的深拷贝与浅拷贝是两个核心概念，它们决定了对象复制时内存资源的处理方式。简单来说，浅拷贝只是复制了对象本身的成员变量值，如果成员变量是指针，那么新旧对象会共享同一块底层内存；而深拷贝则会为被复制对象所指向的资源也创建一份独立的副本，确保新旧对象在内存层面完全独立，互不影响。这对于管理动态内存的复合对象而言，是避免一系列运行时错误的关键。

解决方案

理解C++复合对象深拷贝和浅拷贝的区别，并正确应用，是避免内存泄漏、双重释放（double free）以及数据不一致等问题的基石。默认的拷贝行为（由编译器自动生成）通常执行的是浅拷贝。当你的类成员变量中包含指向动态分配内存的指针时，这种浅拷贝就会带来麻烦。要实现深拷贝，你通常需要手动编写拷贝构造函数（copy constructor）和拷贝赋值运算符（copy assignment operator），以确保所有动态分配的资源都被独立复制。

为什么默认的拷贝行为（浅拷贝）在复合对象中会引发问题？

我个人觉得，C++里深拷贝和浅拷贝这事儿，初学者常常栽跟头，我自己当年也没少吃亏。问题的核心在于，当一个类内部包含了指向堆内存的指针时，默认的浅拷贝机制就显得力不从心了。

想象一下，你有一个

MyString

登录后复制

类，里面有个

char* data

登录后复制

成员，指向一块动态分配的内存，存储着字符串。当你这样写：

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

MyString s1("Hello");
MyString s2 = s1; // 默认拷贝构造函数被调用

登录后复制

在浅拷贝下，

s2.data

登录后复制

会直接复制

s1.data

登录后复制

的值，这意味着

s1.data

登录后复制

和

s2.data

登录后复制

现在都指向了堆上的同一块内存。表面上看，

s1

登录后复制

和

s2

登录后复制

都拥有"Hello"这个字符串，但实际上它们是共用资源。

问题就出在这里：

双重释放（Double Free）：当
```
s1
```
登录后复制
或
```
s2
```
登录后复制
中的任何一个对象生命周期结束时，它的析构函数会被调用，试图释放
```
data
```
登录后复制
指向的内存。如果
```
s1
```
登录后复制
先被销毁，内存被释放了。接着
```
s2
```
登录后复制
被销毁时，它的析构函数又会尝试去释放同一块已经被释放的内存。这通常会导致程序崩溃。
悬空指针（Dangling Pointer）：在
```
s1
```
登录后复制
释放内存后，
```
s2.data
```
登录后复制
就成了一个悬空指针，指向一块无效的内存区域。任何通过
```
s2.data
```
登录后复制
进行的访问或修改，都可能导致未定义行为。
数据不一致：如果
```
s1
```
登录后复制
在某个时刻修改了
```
data
```
登录后复制
指向的内容，那么
```
s2
```
登录后复制
也会“看到”这些修改，反之亦然。这往往不是我们想要的对象独立性。

所以，默认的浅拷贝对于管理动态内存的复合对象来说，几乎总是错误的，它违背了对象独立性和资源所有权的原则。

如何在C++中实现复合对象的深拷贝？

要实现深拷贝，我们必须手动接管拷贝过程，确保当一个对象被复制时，它所拥有的所有动态资源也被独立地复制一份。这通常涉及到“三大法则”（Rule of Three）或“五大法则”（Rule of Five）：如果你定义了析构函数、拷贝构造函数或拷贝赋值运算符中的任何一个，那么很可能需要定义所有这三个（或五个，加上移动构造函数和移动赋值运算符）。

Lumen5

一个在线视频创建平台，AI将博客文章转换成视频

105

查看详情

我们以之前的

MyString

登录后复制

类为例：

#include <cstring> // For strlen, strcpy
#include <iostream>

class MyString {
private:
    char* data;
    size_t length;

public:
    // 构造函数
    MyString(const char* str = nullptr) : data(nullptr), length(0) {
        if (str) {
            length = std::strlen(str);
            data = new char[length + 1];
            std::strcpy(data, str);
        }
    }

    // 析构函数：释放动态分配的内存
    ~MyString() {
        delete[] data;
        data = nullptr; // 良好的实践
    }

    // 拷贝构造函数：实现深拷贝
    MyString(const MyString& other) : data(nullptr), length(other.length) {
        if (other.data) {
            data = new char[length + 1];
            std::strcpy(data, other.data);
        }
    }

    // 拷贝赋值运算符：实现深拷贝
    MyString& operator=(const MyString& other) {
        if (this == &other) { // 处理自我赋值
            return *this;
        }

        // 释放旧资源
        delete[] data;
        data = nullptr;
        length = 0;

        // 复制新资源
        if (other.data) {
            length = other.length;
            data = new char[length + 1];
            std::strcpy(data, other.data);
        }
        return *this;
    }

    // 访问器
    const char* c_str() const { return data ? data : ""; }
    size_t size() const { return length; }

    // 简单示例：修改内容
    void append(const char* suffix) {
        if (!suffix) return;
        size_t suffix_len = std::strlen(suffix);
        char* new_data = new char[length + suffix_len + 1];
        if (data) std::strcpy(new_data, data);
        std::strcpy(new_data + length, suffix);
        delete[] data;
        data = new_data;
        length += suffix_len;
    }
};

int main() {
    MyString s1("Hello");
    MyString s2 = s1; // 调用深拷贝构造函数
    MyString s3;
    s3 = s1;          // 调用深拷贝赋值运算符

    std::cout << "s1: " << s1.c_str() << ", addr: " << (void*)s1.c_str() << std::endl;
    std::cout << "s2: " << s2.c_str() << ", addr: " << (void*)s2.c_str() << std::endl;
    std::cout << "s3: " << s3.c_str() << ", addr: " << (void*)s3.c_str() << std::endl;

    s1.append(" World"); // 修改s1，不会影响s2和s3

    std::cout << "After s1.append(\" World\"):" << std::endl;
    std::cout << "s1: " << s1.c_str() << ", addr: " << (void*)s1.c_str() << std::endl;
    std::cout << "s2: " << s2.c_str() << ", addr: " << (void*)s2.c_str() << std::endl;
    std::cout << "s3: " << s3.c_str() << ", addr: " << (void*)s3.c_str() << std::endl;

    return 0;
}

登录后复制

在上面的代码中：

拷贝构造函数：它接收一个常量引用
```
const MyString& other
```
登录后复制
，在新对象构造时被调用。我们为
```
data
```
登录后复制
成员分配了新的内存，并将
```
other.data
```
登录后复制
的内容复制到这块新内存中。
拷贝赋值运算符：它被用于已存在的对象之间的赋值操作。这里需要特别注意“自我赋值”检查（
```
if (this == &other)
```
登录后复制
），以防止在对象赋值给自己时意外释放内存。在复制新数据之前，我们必须先释放当前对象持有的旧内存资源，然后才分配新内存并复制数据。

通过这种方式，

s1

登录后复制

、

s2

登录后复制

和

s3

登录后复制

都拥有各自独立的字符串数据，互不干扰。

什么时候应该选择深拷贝，什么时候浅拷贝是合适的？

这是一个非常实用的问题，因为它直接关系到代码的正确性和效率。

选择深拷贝的场景：

当对象拥有动态分配的资源时：这是最常见也最重要的场景。如果你的类成员包含原始指针（
```
char*
```
登录后复制
,
```
int*
```
登录后复制
等）或资源句柄（如文件句柄、网络套接字等），并且这些资源的所有权属于该对象，那么几乎总是需要深拷贝。深拷贝确保每个对象都有其独立的资源副本，从而避免了前面提到的双重释放、悬空指针等问题。
当对象管理着外部资源且需要独立生命周期时：例如，一个
```
Image
```
登录后复制
类可能包含一个指向像素数据的指针。复制
```
Image
```
登录后复制
对象时，我们通常希望新对象拥有自己的像素数据副本，而不是共享原始图像的数据。
需要严格的对象独立性时：如果对一个对象的修改绝不应该影响其副本，那么深拷贝是唯一的选择。

选择浅拷贝（或默认行为）合适的场景：

当对象只包含值类型成员时：如果类中所有成员都是
```
int
```
登录后复制
,
```
double
```
登录后复制
,
```
bool
```
登录后复制
, 或者其他没有动态资源管理的简单对象（比如
```
std::string
```
登录后复制
，它自己内部已经处理了深拷贝），那么默认的浅拷贝就足够了，因为它直接复制值，没有指针共享的问题。
当使用智能指针时：这是现代C++中非常推荐的做法。“Rule of Zero”原则指出，如果你使用了像
```
std::unique_ptr
```
登录后复制
或
```
std::shared_ptr
```
登录后复制
这样的智能指针来管理动态资源，那么通常就不需要手动编写析构函数、拷贝构造函数和拷贝赋值运算符了。
- ```
std::unique_ptr
```
  登录后复制
  实现了移动语义（不可拷贝，但可移动），确保资源的唯一所有权。
- ```
std::shared_ptr
```
  登录后复制
  实现了引用计数，多个
```
shared_ptr
```
  登录后复制
  可以共享同一资源，但资源只在最后一个
```
shared_ptr
```
  登录后复制
  被销毁时才释放。在这种情况下，
```
shared_ptr
```
  登录后复制
  本身的拷贝是浅拷贝，但它管理的底层资源是通过引用计数来共享的，这是一种受控的共享，避免了原始指针的危险。
当多个对象有意图地共享同一资源时：在某些特定设计模式中，你可能希望多个对象引用同一个共享的底层数据，而不是复制它。例如，一个“视图”对象可能只包含指向一个大型“模型”对象的指针，而视图本身不拥有模型。但即便如此，也强烈建议使用
```
std::shared_ptr
```
登录后复制
或
```
std::weak_ptr
```
登录后复制
来安全地管理这种共享，而不是裸指针。