引言在 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, pid1001 p2.hi(); // hi, HELLO, pid1001 return 0; // 析构时同一块内存被释放两次 → 程序崩溃 }二、浅拷贝导致的问题内存布局浅拷贝后 p1: [pid1001] [name] ──────┐ │ p2: [pid1001] [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, pid1001 p2.hi(); // hi, Lucy, pid1002 return 0; // 各自释放自己的内存没有问题 }二、深拷贝的内存布局深拷贝后的内存布局 p1: [pid1001] [name] ──────┐ │ ┌───────┴───────┐ │ HELLO │ └───────────────┘ p2: [pid1002] [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; }三、禁用拷贝构造函数某些类不应该被拷贝如管理独占资源的类// 方式1C11 使用 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; }第五部分浅拷贝与深拷贝对比对比项浅拷贝深拷贝内存分配不分配新内存为指针成员分配新内存内存共享共享同一块内存各自独立修改影响相互影响互不影响析构安全可能导致 double free安全性能快较慢需要分配内存适用场景无指针成员的简单类包含指针成员的类何时需要深拷贝// 需要深拷贝的情况 class NeedDeepCopy { private: int* data; // 指针成员 char* buffer; // 动态分配的内存 vectorint* ptr; // 指针指向容器 }; // 不需要深拷贝的情况 class NoDeepCopy { private: int a, b, c; // 基本类型 string name; // string 自己管理内存 vectorint vec; // 容器自己管理内存 };第六部分规则与最佳实践一、三/五法则三法则C98如果类需要自定义析构函数、拷贝构造函数或拷贝赋值运算符中的任何一个那么通常需要自定义所有三个。五法则C11增加了移动构造函数和移动赋值运算符。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; } };二、最佳实践建议优先使用string和vector它们已经正确实现了深拷贝遵循三/五法则保持资源管理的一致性使用 default当默认行为正确时显式声明使用 delete当不希望有拷贝操作时禁用传参用 const 引用避免不必要的拷贝// 推荐使用标准库类型 class GoodExample { string name; vectorint 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; // 标准库类型 vectorint 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 开发者的必经之路。希望这篇文章能帮助你彻底理解这个重要的概念