在C++里，复合对象通常指一个类内部包含多个成员，尤其是涉及指针、动态内存或STL容器的类。当这样的对象被复制时，编译器生成的默认拷贝构造函数和拷贝赋值运算符只会逐个复制成员的值。如果成员是指针，复制的就是地址而不是地址指向的内容，这就埋下了共享内存的隐患。
浅拷贝和深拷贝的关键差异，就在于指针成员所指向的内存是否被重新分配。浅拷贝只复制指针本身，两个对象指向同一块堆内存；深拷贝则为新对象分配独立内存，并把原对象的数据完整复制过去。对于不包含指针或间接资源的简单对象，默认的浅拷贝不会出问题，但复合对象几乎都涉及动态资源，因此必须认真处理。
一、浅拷贝与深拷贝的本质区别
浅拷贝是编译器默认生成的拷贝行为。它按成员逐个复制，对于普通变量如int、double、bool等，直接复制其值；对于指针变量，复制的是指针中保存的地址。这意味着拷贝之后，原对象和新对象的指针成员都指向同一块内存区域。一旦其中一个对象释放了这块内存，另一个对象的指针就变成悬空指针，访问它会导致未定义行为。
深拷贝则要求为指针成员分配新的内存空间，并将原对象指向的内容完整复制到新内存中。这样两个对象各自独立管理自己的资源，互不干扰。释放时也各释放各的，不会出现重复释放问题。深拷贝通常需要开发者手动实现拷贝构造函数和拷贝赋值运算符，因为编译器不会自动理解你内存模型的语义。
下面这段代码展示了默认浅拷贝的典型问题：
#include <iostream>
#include <cstring>
class Person {
public:
Person(const char* name, int age) : age(age) {
this->name = new char[strlen(name) + 1];
strcpy(this->name, name);
}
~Person() {
delete[] name;
}
char* name;
int age;
};
int main() {
Person p1("Alice", 25);
Person p2 = p1; // 默认拷贝构造函数，浅拷贝
strcpy(p1.name, "Bob");
std::cout << p2.name << std::endl; // 输出 Bob，因为共享内存
return 0;
}
上面的代码中，p2是通过默认拷贝构造函数从p1构造的。由于p1和p2的name指针指向同一块堆内存，修改p1.name的内容会直接反映到p2.name上。更严重的是，当p1和p2离开作用域时，析构函数会对同一块内存执行两次delete[]，这通常会导致程序崩溃或堆损坏。
二、复合对象中的深拷贝实现
当类中包含指针成员、动态数组或其他需要独立管理的资源时，就需要手动实现深拷贝。通常要完成三个配套函数：深拷贝构造函数、深拷贝拷贝赋值运算符以及析构函数，这就是经典的Rule of Three原则。如果只实现其中一部分，很容易留下资源管理漏洞。
以下是一个复合对象Department的完整深拷贝实现，该类内部有一个char*动态字符串和一个int成员：
#include <iostream>
#include <cstring>
class Department {
public:
Department(const char* name, int count) : count(count) {
this->name = new char[strlen(name) + 1];
strcpy(this->name, name);
}
// 深拷贝构造函数
Department(const Department& other) : count(other.count) {
name = new char[strlen(other.name) + 1];
strcpy(name, other.name);
}
// 深拷贝赋值运算符
Department& operator=(const Department& other) {
if (this != &other) {
delete[] name;
name = new char[strlen(other.name) + 1];
strcpy(name, other.name);
count = other.count;
}
return *this;
}
~Department() {
delete[] name;
}
char* name;
int count;
};
深拷贝构造函数中，先按原对象的字符串长度为新对象分配新的char数组，然后用strcpy复制数据。深拷贝赋值运算符则多了一步释放旧内存的操作，并且必须先判断自赋值，否则对自身赋值时会先delete[]自己的name，再访问已经释放的内存，产生严重错误。这个自赋值检查是深拷贝赋值运算符中极其重要的一环。
另一个需要注意的点是异常安全性。如果new操作抛出异常，对象应保持原有状态不被破坏。更安全的做法是使用拷贝并交换（copy-and-swap）惯用法，将拷贝操作放在一个临时对象中完成，再通过交换指针或成员进行赋值，这样可以同时解决自赋值和异常安全问题。
三、浅拷贝的典型危害与现代C++的改进
浅拷贝的危害并不只是示例中那样的数据干扰，更常见的是双重释放、悬空指针和逻辑错误。当多个对象共享一块动态内存，任何一方的析构都会影响其他对象。比如在函数返回临时对象或容器扩容时，默认浅拷贝会把资源管理彻底搞乱。使用STL容器如std::vector时，如果元素类型是带指针的复合对象，拷贝操作频繁发生，浅拷贝的后果会被迅速放大。
现代C++的推荐做法是尽量避免手写裸指针来管理资源，而是使用值语义的成员类型，比如std::string、std::vector或智能指针std::shared_ptr、std::unique_ptr。这些标准库类型已经实现了正确的深拷贝或所有权转移，编译器默认生成的拷贝构造函数也会随之变安全。下面的类使用了std::string，不再需要自定义拷贝构造函数：
#include <iostream>
#include <string>
class Employee {
public:
Employee(const std::string& name, int id) : name(name), id(id) {}
std::string name;
int id;
};
int main() {
Employee e1("Alice", 1);
Employee e2 = e1;
e2.name = "Bob";
std::cout << e1.name << " " << e2.name << std::endl;
return 0;
}
这段代码中，e2的name修改不会影响e1的name，因为std::string的拷贝是深拷贝。也就是说，把资源管理交给标准库类型后，用户自定义类几乎可以依赖编译器默认生成的拷贝函数，从而大幅减少手动编写深拷贝的出错概率。对于需要共享同一份数据的场景，则可以使用std::shared_ptr明确表达共享所有权意图。
四、移动语义与深浅拷贝的关系
C++11引入的移动语义为深拷贝提供了更高效的替代方案。在某些场景下，对象并不需要真正复制资源，而是可以把源对象的内部资源所有权转移给目标对象，源对象进入可析构的空白状态。移动构造函数和移动赋值运算符就是在这种理念下诞生的，它们能够避免在大对象拷贝时进行不必要的深拷贝，从而提升性能。
移动语义与深拷贝并不冲突，而是互补。当源对象不再需要时，使用移动；当源对象必须保持原样时，使用深拷贝。下面是一个带移动语义的Buffer类：
#include <iostream>
#include <cstring>
class Buffer {
public:
Buffer(size_t size) : size(size), data(new char[size]) {}
// 深拷贝构造函数
Buffer(const Buffer& other) : size(other.size), data(new char[other.size]) {
memcpy(data, other.data, size);
}
// 移动构造函数
Buffer(Buffer&& other) noexcept : size(other.size), data(other.data) {
other.size = 0;
other.data = nullptr;
}
// 移动赋值运算符
Buffer& operator=(Buffer&& other) noexcept {
if (this != &other) {
delete[] data;
size = other.size;
data = other.data;
other.size = 0;
other.data = nullptr;
}
return *this;
}
~Buffer() {
delete[] data;
}
private:
size_t size;
char* data;
};
移动构造函数直接把源对象的data指针和size复制过来，然后把源对象的data置为nullptr、size置为0。这样源对象析构时不会释放已经转移走的内存，目标对象则获得了完整的所有权。由于移动操作不会分配新内存，执行成本通常远低于深拷贝。在容器扩容、函数返回局部对象等场景中，编译器会自动选择移动操作，大大减少不必要的资源复制。
需要注意的是，移动构造函数和移动赋值运算符最好标记为noexcept，这样标准库容器在重新分配内存时才敢使用移动操作，否则为了保证异常安全会退回使用深拷贝，降低性能。理解深拷贝、浅拷贝、移动语义三者的边界，是掌握C++复合对象资源管理的重要一步。合理的做法是优先使用标准库资源和智能指针，只有在确实需要自定义资源管理时才手动实现深拷贝和移动操作，并确保整套特殊成员函数逻辑一致。