C++ 拷贝构造函数深度解析：从浅拷贝到深拷贝

引言

在 C++ 面向对象编程中，拷贝构造函数是一个既基础又容易出错的话题。很多初学者（包括曾经的我）在遇到指针成员时，常常因为默认的浅拷贝而导致程序崩溃或内存错误。我想通过自己的学习笔记和实践经验，系统地分享拷贝构造函数的方方面面。

第一部分：什么是拷贝构造函数

一、拷贝构造函数的定义

拷贝构造函数是一种特殊的构造函数，它使用同一个类的另一个对象来初始化新创建的对象。

class Person { private: int pid; char* name; public: // 拷贝构造函数的签名：类名(const 类名& other) Person(const Person& other) { // 拷贝逻辑 } };

二、拷贝构造函数的调用时机

拷贝构造函数在以下三种情况下会被调用:

class Person { public: Person() { cout << "默认构造" << endl; } Person(const Person& other) { cout << "拷贝构造" << endl; } ~Person() { cout << "析构" << endl; } }; // 1. 使用一个对象初始化另一个对象 Person p1; Person p2 = p1; // 拷贝构造 Person p3(p1); // 拷贝构造 // 2. 函数参数按值传递 void func(Person p) { } // 形参是实参的副本 func(p1); // 调用拷贝构造 // 3. 函数按值返回 Person createPerson() { Person p; return p; // 可能调用拷贝构造（可能被优化） }

第二部分：浅拷贝的问题

一、编译器默认的浅拷贝

编译器默认提供的拷贝构造函数执行的是浅拷贝（Shallow Copy），即逐字节复制成员变量:

class Person { private: int pid; char* name; // 指针成员 public: Person(int pid, const char* name) : pid(pid) { this->name = new char[32]{0}; memcpy(this->name, name, strlen(name)); cout << "构造: " << name << endl; } // 使用编译器默认的拷贝构造函数（浅拷贝） // Person(const Person& other) = default; void hi() const { cout << "hi, " << name << ", pid=" << pid << endl; } ~Person() { cout << "析构: " << name << endl; delete[] name; } }; int main() { Person p1(1001, "HELLO"); Person p2 = p1; // 浅拷贝！p2.name 和 p1.name 指向同一块内存 p1.hi(); // hi, HELLO, pid=1001 p2.hi(); // hi, HELLO, pid=1001 return 0; // 析构时：同一块内存被释放两次 → 程序崩溃！ }

二、浅拷贝导致的问题

内存布局（浅拷贝后）： p1: [pid=1001] [name] ──────┐ │ p2: [pid=1001] [name] ──────┘ │ ┌─────────┴─────────┐ │ "HELLO" 内存块 │ └───────────────────┘ 问题： 1. p1 和 p2 共享同一块内存 2. 析构时，同一块内存被释放两次 → double free 错误 3. 通过 p2 修改 name 会影响 p1

第三部分：深拷贝的实现

一、深拷贝的原理

深拷贝（Deep Copy）为每个指针成员分配独立的内存空间，并将内容复制过去：

class Person { private: int pid; char* name; public: // 构造函数 Person(int pid, const char* name) : pid(pid) { this->name = new char[32]{0}; memcpy(this->name, name, strlen(name)); cout << "构造: " << this->name << endl; } // 深拷贝构造函数 Person(const Person& other) { cout << "深拷贝构造" << endl; // 1. 复制普通成员 pid = other.pid; // 2. 为指针成员分配新空间 name = new char[32]{0}; // 3. 复制内容 memcpy(name, other.name, strlen(other.name)); } void hi() const { cout << "hi, " << name << ", pid=" << pid << endl; } void setPid(int pid) { this->pid = pid; } void setName(const char* name) { memset(this->name, 0, strlen(this->name)); memcpy(this->name, name, strlen(name)); } ~Person() { cout << "析构: " << name << endl; delete[] name; } }; int main() { Person p1(1001, "HELLO"); Person p2 = p1; // 调用深拷贝构造函数 p2.setPid(1002); p2.setName("Lucy"); p1.hi(); // hi, HELLO, pid=1001 p2.hi(); // hi, Lucy, pid=1002 return 0; // 各自释放自己的内存，没有问题 }

二、深拷贝的内存布局

深拷贝后的内存布局： p1: [pid=1001] [name] ──────┐ │ ┌───────┴───────┐ │ "HELLO" │ └───────────────┘ p2: [pid=1002] [name] ──────┐ │ ┌───────┴───────┐ │ "Lucy" │ └───────────────┘ 特点： 1. 每个对象拥有独立的内存 2. 修改 p2 不影响 p1 3. 析构时各自释放自己的内存

第四部分：拷贝构造函数的其他形式

一、拷贝构造函数的参数

拷贝构造函数的参数必须是引用，否则会形成无限递归：

class Person { public: // 错误！会造成无限递归 // Person(Person other) { } // 传值会再次调用拷贝构造 // 正确：使用 const 引用 Person(const Person& other) { } // 也可以是非 const 引用（较少用） Person(Person& other) { } };

二、深拷贝的完整实现

class String { private: char* data; size_t length; public: // 构造函数 String(const char* str = "") { length = strlen(str); data = new char[length + 1]; strcpy(data, str); cout << "构造: " << data << endl; } // 深拷贝构造函数 String(const String& other) { length = other.length; data = new char[length + 1]; strcpy(data, other.data); cout << "深拷贝: " << data << endl; } // 拷贝赋值运算符 String& operator=(const String& other) { if (this != &other) { // 防止自赋值 delete[] data; // 释放原有内存 length = other.length; data = new char[length + 1]; strcpy(data, other.data); cout << "拷贝赋值: " << data << endl; } return *this; } void print() const { cout << data << endl; } ~String() { cout << "析构: " << data << endl; delete[] data; } }; int main() { String s1("Hello"); String s2 = s1; // 深拷贝构造 String s3("World"); s3 = s1; // 拷贝赋值 s1.print(); // Hello s2.print(); // Hello s3.print(); // Hello return 0; }

三、禁用拷贝构造函数

某些类不应该被拷贝（如管理独占资源的类）：

// 方式1：C++11 使用 delete class NonCopyable { public: NonCopyable() = default; NonCopyable(const NonCopyable&) = delete; NonCopyable& operator=(const NonCopyable&) = delete; }; // 方式2：传统做法（声明为 private 且不实现） class NonCopyableOld { private: NonCopyableOld(const NonCopyableOld&); NonCopyableOld& operator=(const NonCopyableOld&); public: NonCopyableOld() {} }; int main() { NonCopyable a; // NonCopyable b = a; // 编译错误！ return 0; }

第五部分：浅拷贝与深拷贝对比

何时需要深拷贝？

// 需要深拷贝的情况 class NeedDeepCopy { private: int* data; // 指针成员 char* buffer; // 动态分配的内存 vector<int>* ptr; // 指针指向容器 }; // 不需要深拷贝的情况 class NoDeepCopy { private: int a, b, c; // 基本类型 string name; // string 自己管理内存 vector<int> vec; // 容器自己管理内存 };

第六部分：规则与最佳实践

一、三/五法则

三法则（C++98）：如果类需要自定义析构函数、拷贝构造函数或拷贝赋值运算符中的任何一个，那么通常需要自定义所有三个。

五法则（C++11）：增加了移动构造函数和移动赋值运算符。

class RuleOfFive { private: int* data; size_t size; public: // 构造函数 RuleOfFive(size_t s) : size(s), data(new int[s]) {} // 析构函数 ~RuleOfFive() { delete[] data; } // 拷贝构造函数 RuleOfFive(const RuleOfFive& other) : size(other.size), data(new int[other.size]) { std::copy(other.data, other.data + size, data); } // 拷贝赋值运算符 RuleOfFive& operator=(const RuleOfFive& other) { if (this != &other) { delete[] data; size = other.size; data = new int[size]; std::copy(other.data, other.data + size, data); } return *this; } // 移动构造函数 RuleOfFive(RuleOfFive&& other) noexcept : data(other.data), size(other.size) { other.data = nullptr; other.size = 0; } // 移动赋值运算符 RuleOfFive& operator=(RuleOfFive&& other) noexcept { if (this != &other) { delete[] data; data = other.data; size = other.size; other.data = nullptr; other.size = 0; } return *this; } };

二、最佳实践建议

1. 优先使用string和vector：它们已经正确实现了深拷贝

2. 遵循三/五法则：保持资源管理的一致性

3. 使用= default：当默认行为正确时显式声明

4. 使用= delete：当不希望有拷贝操作时禁用

5. 传参用 const 引用：避免不必要的拷贝

// 推荐：使用标准库类型 class GoodExample { string name; vector<int> scores; // 编译器生成的拷贝构造已正确实现深拷贝 }; // 推荐：显式声明意图 class ExplicitExample { public: ExplicitExample() = default; virtual ~ExplicitExample() = default; // 禁用拷贝 ExplicitExample(const ExplicitExample&) = delete; ExplicitExample& operator=(const ExplicitExample&) = delete; // 允许移动 ExplicitExample(ExplicitExample&&) = default; ExplicitExample& operator=(ExplicitExample&&) = default; };

总结

一、核心要点

二、快速判断是否需要深拷贝

class MyClass { // 如果有以下成员，通常需要深拷贝： char* ptr; // 原始指针 int* data; // 动态分配的数组 FILE* file; // 资源句柄 // 以下成员不需要深拷贝： int a; // 基本类型 string s; // 标准库类型 vector<int> v; // 标准库容器 };

三、常见陷阱提醒

// 错误：浅拷贝导致 double free class Bad { char* p; public: Bad() { p = new char[10]; } ~Bad() { delete[] p; } // 缺少拷贝构造函数和拷贝赋值 }; // 正确：深拷贝或禁用拷贝 class Good { char* p; public: Good() { p = new char[10]; } ~Good() { delete[] p; } Good(const Good& other) { p = new char[10]; memcpy(p, other.p, 10); } // 或者禁用拷贝 // Good(const Good&) = delete; };

拷贝构造函数是 C++ 资源管理的核心知识点之一。理解浅拷贝和深拷贝的区别，不仅能避免程序崩溃，更是理解 C++ 内存模型的重要一步。

在学习过程中，我最大的体会是：默认的不一定是对的。编译器为我们提供了便利，但当类涉及资源管理时，我们必须自己动手，确保资源的正确复制和释放。

掌握拷贝构造函数，是迈向专业 C++ 开发者的必经之路。希望这篇文章能帮助你彻底理解这个重要的概念