深拷贝会为对象及其动态资源创建独立副本，确保内存独立；浅拷贝仅复制成员值，导致指针共享同一内存。默认拷贝是浅拷贝，当类含有指向堆内存的指针时，会造成双重释放、悬空指针和数据不一致。例如，MyString类中两个对象通过浅拷贝共享data指针，析构时会重复释放同一内存而崩溃。实现深拷贝需遵循“三大法则”，手动编写拷贝构造函数和拷贝赋值运算符，在构造时分配新内存并复制内容，赋值前释放旧资源并处理自赋值。使用智能指针（如std::shared_ptr）可避免手动管理，符合“Rule of Zero”。对象含动态资源且需独立生命周期时应选深拷贝；仅含值类型成员或使用智能指针时，浅拷贝安全高效。
在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）：如果你定义了析构函数、拷贝构造函数或拷贝赋值运算符中的任何一个，那么很可能需要定义所有这三个（或五个，加上移动构造函数和移动赋值运算符）。
我们以之前的
MyString
类为例：
#include // For strlen, strcpy#include 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
来安全地管理这种共享，而不是裸指针。
总而言之，如果你在类中看到了原始指针并且它指向了你负责管理的堆内存，那么几乎可以肯定你需要深拷贝。如果不是，或者你已经用智能指针妥善管理了资源，那么默认行为或智能指针的语义通常就足够了。
以上就是C++复合对象深拷贝和浅拷贝区别详解的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1474928.html
微信扫一扫 
支付宝扫一扫 
