深拷贝与浅拷贝的实现差异
面试考点
这道题考察的是你对对象拷贝机制的理解,特别是当类中包含动态分配的资源(如堆内存、文件句柄)时,默认的浅拷贝会带来什么问题,以及怎么正确实现深拷贝。
核心区别
浅拷贝(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)做成员,让编译器自动生成正确的拷贝操作。