1. 项目概述为什么默认成员函数是C面向对象的基石如果你已经理解了C中类和对象的基本概念比如如何定义一个class如何创建对象那么恭喜你你已经迈出了面向对象编程的第一步。但接下来你会发现一个有趣的现象即使你定义的类看起来空空如也它也能被创建、被复制、甚至被销毁。这背后是谁在默默工作答案就是默认成员函数。我刚开始写C时经常被一些“灵异”现象困扰。比如我写了一个简单的Student类只定义了几个成员变量没有写任何构造函数。但当我在main函数里写下Student stu;时程序居然能编译通过并运行。又比如我把一个Student对象赋值给另一个对象或者把它作为参数传给函数这些操作背后到底发生了什么直到我深入理解了编译器为我们自动生成的这六个“幕后英雄”很多困惑才迎刃而解。这六个默认成员函数分别是默认构造函数、析构函数、拷贝构造函数、拷贝赋值运算符、移动构造函数、移动赋值运算符。它们是C对象生命周期管理的核心理解它们你才能真正掌控你的对象从诞生到消亡的每一个细节写出高效、安全、不易出错的代码。这篇文章我就结合自己踩过的坑和积累的经验把这六个函数的来龙去脉、使用场景和避坑要点给你掰开揉碎了讲清楚。2. 默认成员函数全景解析编译器在背后做了什么2.1 什么是默认成员函数简单来说当你定义一个类时如果你没有显式地声明某些特定的成员函数编译器会“好心”地为你自动生成它们。这些由编译器自动生成的函数就是默认成员函数。它们的存在保证了任何类的基本对象操作创建、销毁、复制、移动都能进行即使你什么都没写。这里有一个关键点需要明确“默认”有两层含义。一是指“由编译器默认生成”二是指这个函数是“默认版本”的即执行最基础、最通用的操作。例如默认的拷贝构造函数就是简单地按位拷贝浅拷贝每个非静态成员变量。注意在C11标准之前只有前四个默认构造、析构、拷贝构造、拷贝赋值是编译器可能自动生成的。C11引入了移动语义因此增加了移动构造和移动赋值这两个默认成员函数。但它们的生成条件更为苛刻。2.2 六大默认成员函数清单与生成条件为了让你一目了然我把这六个函数的核心信息整理成了下面的表格。这张表是你理解后续所有内容的路线图建议先有个整体印象。函数名称函数签名示例以类MyClass为例编译器何时自动生成默认行为简述默认构造函数MyClass();当类中没有任何用户声明的构造函数时。对内置类型成员不做初始化值是未定义的对类类型成员调用其默认构造函数。析构函数~MyClass();当类中没有用户声明的析构函数时。对类类型成员调用其析构函数。内置类型成员无需释放函数体为空。拷贝构造函数MyClass(const MyClass other);当类中没有用户声明的拷贝构造函数且没有用户声明的移动操作时。对每个非静态成员执行成员级的拷贝初始化即调用该成员自身的拷贝构造函数或进行内置类型的值拷贝。拷贝赋值运算符MyClass operator(const MyClass other);当类中没有用户声明的拷贝赋值运算符且没有用户声明的移动操作时。对每个非静态成员执行成员级的拷贝赋值即调用该成员自身的拷贝赋值运算符或进行内置类型的值赋值。移动构造函数MyClass(MyClass other) noexcept;当类中没有任何用户声明的拷贝操作、移动操作和析构函数时。对每个非静态成员执行成员级的移动初始化即调用该成员自身的移动构造函数或进行内置类型的值移动对于内置类型就是拷贝。移动赋值运算符MyClass operator(MyClass other) noexcept;生成条件与移动构造函数完全相同。对每个非静态成员执行成员级的移动赋值即调用该成员自身的移动赋值运算符或进行内置类型的值移动拷贝。这张表里的“生成条件”是重中之重也是很多错误的根源。特别是移动操作的生成条件非常“挑剔”一旦你声明了拷贝操作或析构函数编译器就不会再为你生成默认的移动操作这有时会导致程序无法利用移动语义进行优化。我们会在后面的章节详细分析这些场景。3. 默认构造函数与析构函数对象的生与死3.1 默认构造函数无中生有的艺术默认构造函数就是在创建对象时不需要传递任何参数的构造函数。它的核心任务是完成对象的初始化。很多人误以为编译器生成的默认构造函数会把所有成员都初始化为0或空这是一个非常危险的误解。编译器生成的默认构造函数实际行为如下对于内置类型如int,double,指针的成员变量什么都不做其值是未定义的栈上是随机值堆上由new的行为决定。对于类类型如string,vector的成员变量调用该成员自身的默认构造函数。让我们通过一个例子来感受一下#include iostream #include string class Example { public: // 没有任何用户声明的构造函数编译器会生成默认构造函数 int num; // 内置类型不初始化 double price; // 内置类型不初始化 std::string name; // 类类型调用 std::string 的默认构造函数 int* ptr; // 指针类型不初始化 }; int main() { Example ex; // 调用编译器生成的默认构造函数 std::cout ex.num: ex.num std::endl; // 输出随机值 std::cout ex.price: ex.price std::endl; // 输出随机值 std::cout ex.name: \ ex.name \ std::endl; // 输出空字符串 std::cout ex.ptr: ex.ptr std::endl; // 输出随机地址可能是野指针 // 在堆上创建对于内置类型new 和 new() 有区别 Example* p1 new Example; // 内置类型不初始化 Example* p2 new Example(); // 内置类型会进行值初始化对类类型调用默认构造对内置类型初始化为0 std::cout p1-num: p1-num std::endl; // 随机值 std::cout p2-num: p2-num std::endl; // 0 delete p1; delete p2; return 0; }运行这段代码ex.num和ex.price的输出每次很可能都不一样这就是“未定义行为”。而ex.name则是一个有效的空字符串对象。什么时候需要自己写默认构造函数需要初始化内置类型成员比如你希望所有新创建的Student对象的id初始化为-1score初始化为0.0。类包含引用成员或const成员引用和const变量必须在创建时初始化编译器生成的默认构造函数无法做到这一点你必须自己写。类有虚函数如果类有虚函数通常需要初始化虚函数表指针vptr虽然编译器生成的默认构造函数会做这件事但如果你提供了任何其他构造函数就需要确保默认构造也能正确初始化vptr通常通过成员初始化列表调用基类构造函数。类继承自一个没有默认构造函数的基类派生类构造函数必须显式调用基类的某个构造函数。一个常见的坑声明了带参数的构造函数却忘了提供默认构造函数class Student { public: Student(int id, const std::string n) : stuId(id), name(n) {} // 错误这里没有提供默认构造函数 Student() private: int stuId; std::string name; }; int main() { Student stu1(101, Alice); // OK Student stu2; // 编译错误编译器不会生成默认构造函数因为我们已经声明了一个构造函数。 Student students[10]; // 同样错误数组要求元素可默认构造。 return 0; }解决方法很简单要么提供一个无参的默认构造函数要么在创建对象时总是提供参数。在现代C中更推荐使用 default来显式地要求编译器生成默认版本class Student { public: Student() default; // 显式要求编译器生成默认构造函数 Student(int id, const std::string n) : stuId(id), name(n) {} private: int stuId -1; // C11 起可以在类内提供默认成员初始化器 std::string name; };3.2 析构函数善始善终的保障析构函数在对象生命周期结束时被自动调用比如离开作用域、被delete等。它的核心任务是释放对象在生命周期内申请的资源。编译器生成的默认析构函数会按照成员声明的逆序对每个类类型的成员调用其自身的析构函数。关键理解默认析构函数只处理“成员对象”不处理“成员对象指向的资源”。这句话有点绕我们看一个经典的错误案例——浅拷贝导致的双重释放问题这个问题恰恰是因为依赖了默认的拷贝构造函数和默认的析构函数。class ShallowArray { public: ShallowArray(int size) : m_size(size), m_data(new int[size]) {} // 构造函数申请资源 // 没有声明析构函数、拷贝构造、拷贝赋值 - 编译器生成默认版本 // 默认析构函数~ShallowArray() {} 它不会 delete m_data! void setValue(int index, int value) { if(index m_size) m_data[index] value; } private: int* m_data; int m_size; }; int main() { { ShallowArray arr1(10); arr1.setValue(0, 100); ShallowArray arr2 arr1; // 调用编译器生成的默认拷贝构造函数浅拷贝 // arr2.m_data 和 arr1.m_data 指向同一块内存 } // 作用域结束arr2和arr1的析构函数被调用 // 先调用 ~ShallowArray() for arr2: 什么也没做默认析构函数体为空 // 再调用 ~ShallowArray() for arr1: 什么也没做 // 内存泄漏m_data指向的内存没有被释放。 // 更糟糕的情况如果默认析构函数里写了 delete[] m_data会导致同一块内存被释放两次程序崩溃。 return 0; }这个例子揭示了**“三法则”**C11后是“五法则”的起源如果一个类需要自定义析构函数那么它很可能也需要自定义拷贝构造函数和拷贝赋值运算符因为默认的版本浅拷贝无法正确管理资源如动态内存、文件句柄、网络连接等。正确的做法自己定义析构函数来释放资源class DeepArray { public: DeepArray(int size) : m_size(size), m_data(new int[size]) {} ~DeepArray() { delete[] m_data; } // 自定义析构函数释放资源 // 接下来我们通常还需要自定义拷贝构造和拷贝赋值见下一节来避免浅拷贝 private: int* m_data; int m_size; };现在当DeepArray对象销毁时delete[] m_data会被执行内存得以正确释放。但问题只解决了一半因为默认的拷贝行为仍然是浅拷贝我们还需要处理拷贝问题。4. 拷贝控制深拷贝与浅拷贝的抉择拷贝控制函数拷贝构造和拷贝赋值决定了当一个对象被用来初始化或赋值给另一个同类型对象时会发生什么。这是C中最容易出错的地方之一。4.1 拷贝构造函数拷贝构造函数用于用一个已存在的对象来初始化一个新对象。常见的触发场景有函数传参按值传递对象void func(MyClass obj);函数返回对象在某些情况下取决于编译器的返回值优化RVO/NRVO。用已存在对象初始化新对象MyClass obj2 obj1;或MyClass obj2(obj1);编译器生成的默认拷贝构造函数执行成员级的拷贝初始化member-wise copy initialization。对于内置类型直接复制比特位对于类类型调用该成员的拷贝构造函数。浅拷贝Shallow Copy的灾难让我们完善上面DeepArray的例子看看如果只定义了析构函数而没有定义拷贝构造会发生什么class DeepArray { public: DeepArray(int size) : m_size(size), m_data(new int[size]) { for(int i0; im_size; i) m_data[i] 0; } ~DeepArray() { delete[] m_data; } // 没有定义拷贝构造函数 - 编译器生成默认的浅拷贝 private: int* m_data; int m_size; }; int main() { DeepArray arr1(5); DeepArray arr2 arr1; // 默认拷贝构造arr2.m_data arr1.m_data; // 现在 arr1.m_data 和 arr2.m_data 指向同一块内存 return 0; } // 作用域结束析构顺序先arr2后arr1 // ~DeepArray() for arr2: delete[] m_data; (内存被释放) // ~DeepArray() for arr1: delete[] m_data; // 崩溃对已释放的内存再次执行delete[]这就是典型的“双重释放”错误。默认的浅拷贝只复制了指针的值没有复制指针指向的内存内容导致两个对象共享同一资源析构时争相释放引发未定义行为通常是程序崩溃。实现深拷贝Deep Copy为了解决这个问题我们必须自定义拷贝构造函数进行“深拷贝”——不仅复制指针还复制指针指向的数据。class SafeArray { public: SafeArray(int size) : m_size(size), m_data(new int[size]) { for(int i0; im_size; i) m_data[i] 0; } // 自定义拷贝构造函数 SafeArray(const SafeArray other) : m_size(other.m_size), m_data(new int[other.m_size]) { std::cout 拷贝构造函数被调用 std::endl; for(int i0; im_size; i) { m_data[i] other.m_data[i]; // 复制数据而不是指针 } } ~SafeArray() { delete[] m_data; } private: int* m_data; int m_size; }; int main() { SafeArray arr1(5); SafeArray arr2 arr1; // 调用我们自定义的拷贝构造函数进行深拷贝 // arr1 和 arr2 拥有各自独立的内存块互不影响 return 0; } // 安全析构各自释放自己的内存4.2 拷贝赋值运算符拷贝赋值运算符用于将一个已存在对象的值赋给另一个已存在的对象。触发场景obj2 obj1;编译器生成的默认拷贝赋值运算符执行成员级的拷贝赋值member-wise copy assignment。逻辑类似拷贝构造但对象已经存在。默认拷贝赋值的问题默认的拷贝赋值同样是浅拷贝会带来和默认拷贝构造一样的问题资源重复释放、内存泄漏。此外拷贝赋值还需要处理一个额外的重要问题自赋值self-assignment和异常安全exception safety。一个健壮的拷贝赋值运算符实现通常遵循“拷贝并交换copy-and-swap” idiom或者至少做到防止自赋值a a。释放左侧对象原有的资源。分配新资源并拷贝数据。保证异常安全如果中间步骤失败对象应保持原有状态。一个基础的拷贝赋值运算符实现非最优但清晰class SafeArray { public: // ... 构造函数、拷贝构造函数、析构函数同上 ... // 拷贝赋值运算符 SafeArray operator(const SafeArray other) { std::cout 拷贝赋值运算符被调用 std::endl; // 1. 防止自赋值 if (this other) { return *this; } // 2. 释放原有资源 delete[] m_data; // 3. 分配新资源并拷贝数据 m_size other.m_size; m_data new int[m_size]; for (int i 0; i m_size; i) { m_data[i] other.m_data[i]; } // 4. 返回 *this 以支持链式赋值 (a b c) return *this; } private: int* m_data; int m_size; };这个实现有一个潜在问题如果在new分配内存时失败抛出std::bad_alloc异常m_data已经被delete[]而m_size却已经更新为other.m_size对象状态被破坏不再一致。这就是异常不安全。更健壮的做法是先分配新内存复制数据成功后再释放旧内存和更新成员或者使用“拷贝并交换”技术。“三法则”与“五法则”三法则Rule of Three如果你需要自定义析构函数、拷贝构造函数或拷贝赋值运算符中的任何一个那么很可能三个都需要自定义。因为它们通常都是因为类需要管理资源而出现的。五法则Rule of FiveC11后由于移动语义的引入规则扩展了。如果你需要自定义拷贝控制函数析构、拷贝构造、拷贝赋值中的任何一个那么你应该考虑是否需要全部五个函数加上移动构造和移动赋值。通常管理资源的类需要定义这五个函数或者使用“零法则”Rule of Zero——使用智能指针等资源管理类来避免自己手动管理。5. 移动语义现代C的性能利器C11引入的移动语义是为了解决不必要的拷贝带来的性能开销。其核心思想是“偷”取临时对象右值的资源而不是进行昂贵的深拷贝。5.1 移动构造函数与移动赋值运算符移动构造函数和移动赋值运算符的参数都是右值引用T。它们“窃取”源对象临时对象的资源并将源对象置于一个可安全析构的状态通常是将其指针成员置为nullptr。编译器何时生成默认的移动操作回顾第2节的表格条件非常严格只有当类没有用户声明的拷贝操作拷贝构造和拷贝赋值、移动操作和析构函数时编译器才会生成默认的移动操作。这意味着如果你声明了析构函数很常见编译器就不会生成移动操作这是一个巨大的性能陷阱。默认移动操作的行为对每个非静态成员执行“成员级的移动”。对于内置类型就是拷贝对于定义了移动操作的类类型成员如std::string,std::vector则调用其移动操作。示例带有移动语义的类class ResourceHolder { public: ResourceHolder(size_t size) : m_size(size), m_data(new int[size]) { std::cout 构造函数分配资源 std::endl; } // 1. 自定义析构函数 ~ResourceHolder() { std::cout 析构函数释放资源 std::endl; delete[] m_data; } // 2. 自定义拷贝构造函数深拷贝 ResourceHolder(const ResourceHolder other) : m_size(other.m_size), m_data(new int[other.m_size]) { std::cout 拷贝构造函数深拷贝 std::endl; std::copy(other.m_data, other.m_data m_size, m_data); } // 3. 自定义拷贝赋值运算符略同上节 // 4. 声明移动构造函数因为有了析构函数编译器不会自动生成 ResourceHolder(ResourceHolder other) noexcept : m_size(0), m_data(nullptr) { // 先将自身置于安全状态 std::cout 移动构造函数 std::endl; *this std::move(other); // 调用移动赋值 } // 5. 声明移动赋值运算符 ResourceHolder operator(ResourceHolder other) noexcept { std::cout 移动赋值运算符 std::endl; if (this ! other) { // 自赋值检查 delete[] m_data; // 释放自身原有资源 m_data other.m_data; // “窃取”资源 m_size other.m_size; // 将源对象置于可安全析构状态 other.m_data nullptr; other.m_size 0; } return *this; } private: int* m_data; size_t m_size; }; // 使用示例 ResourceHolder createResource() { ResourceHolder temp(100); // ... 操作 temp ... return temp; // 编译器可能会应用RVO否则会调用移动构造函数如果可用 } int main() { ResourceHolder obj1 createResource(); // 可能调用移动构造 ResourceHolder obj2(50); obj2 std::move(obj1); // 调用移动赋值运算符obj1的资源被“移动”到obj2 // 此时 obj1 处于有效但未指定状态m_datanullptr对其使用是危险的但析构是安全的。 return 0; }关键点noexcept移动操作通常应该标记为noexcept这有助于标准库容器如std::vector在重新分配内存时使用移动而非拷贝提升性能。std::move它并不移动任何东西只是将一个左值强制转换为右值引用表示“这个对象可以被移动”。移动后源对象状态移动操作后源对象必须处于一个可析构和可赋值的状态。通常将其指针置nullptr大小置0。5.2 移动操作生成条件的陷阱与解决方案最常见的陷阱就是“因为定义了析构函数而导致移动操作被删除”。这会让你的类在需要移动的场景比如放入std::vector中退回到低效的拷贝操作。解决方案遵循“五法则”如果你定义了析构函数或拷贝操作考虑同时定义移动操作或者明确禁用它们。使用 default如果你需要移动操作的默认行为即成员级的移动并且编译器因为某些原因没有自动生成你可以显式地要求生成。class MyClass { public: ~MyClass() { /* 做一些清理但不涉及需要自定义移动的资源管理 */ } // 显式要求编译器生成默认的移动操作 MyClass(MyClass) default; MyClass operator(MyClass) default; // 同样可以 default 拷贝操作 MyClass(const MyClass) default; MyClass operator(const MyClass) default; };遵循“零法则”这是现代C的最佳实践。使用智能指针std::unique_ptr,std::shared_ptr、标准库容器std::vector,std::string等来管理资源。让这些成熟的类去处理拷贝和移动的细节你自己的类就不需要定义析构函数、拷贝/移动操作了编译器生成的默认版本就能正确工作。// “零法则”示例使用 std::vector 管理动态数组无需自定义五件套 class RuleOfZeroArray { public: RuleOfZeroArray(size_t size) : m_data(size) {} // vector 自己管理内存 // 无需定义析构、拷贝构造、拷贝赋值、移动构造、移动赋值 // 编译器生成的默认版本会调用 std::vector 对应的操作行为完全正确。 private: std::vectorint m_data; };6. 实战避坑指南与高级技巧理解了原理我们来看看实际编码中会遇到哪些坑以及如何优雅地处理默认成员函数。6.1 常见问题排查速查表问题现象可能原因解决方案编译错误use of deleted function编译器隐式删除了某个默认函数。例如类有const或引用成员但试图使用默认的拷贝赋值。检查成员变量。对于const/引用成员可能需要自定义拷贝赋值或考虑改变设计。程序运行时崩溃双重释放依赖了默认的拷贝操作进行浅拷贝但类管理着资源如裸指针。遵循“三/五法则”为管理资源的类自定义拷贝控制函数深拷贝或禁用拷贝delete。程序性能低下std::vector扩容时慢类定义了析构函数但未定义移动操作导致std::vector等容器在重新分配时使用拷贝而非移动。为类添加移动构造函数和移动赋值运算符或使用default并标记为noexcept。对象状态在赋值后意外改变拷贝赋值运算符没有处理自赋值a a导致资源被提前释放。在拷贝赋值运算符实现中加入自赋值检查if(this other) return *this;。对象拷贝后修改一个影响另一个浅拷贝问题。两个对象共享了同一份底层数据如指针。实现深拷贝或者使用共享语义的智能指针如std::shared_ptr。无法用{}列表初始化对象类提供了用户定义的构造函数但没有提供接受std::initializer_list或合适参数的构造函数。提供一个合适的构造函数或者使用 default声明一个默认构造函数。6.2 使用default与delete进行精确控制C11允许我们显式地指示编译器生成或删除默认函数。 default在函数声明后加上 default;可以要求编译器生成该函数的默认版本。这常用于在类声明中头文件里将特殊成员函数定义为内联的。class DefaultExample { public: DefaultExample() default; // 显式生成默认构造函数 DefaultExample(const DefaultExample) default; // 显式生成拷贝构造 DefaultExample(DefaultExample) default; // 显式生成移动构造 DefaultExample operator(const DefaultExample) default; DefaultExample operator(DefaultExample) default; ~DefaultExample() default; // 即使定义了其他构造函数默认构造依然存在 DefaultExample(int x) : data(x) {} private: int data 0; }; delete在函数声明后加上 delete;可以禁止该函数被调用。常用于禁止拷贝实现不可拷贝的类如std::mutex或禁止某些参数类型的重载。class NonCopyable { public: NonCopyable() default; // 禁止拷贝 NonCopyable(const NonCopyable) delete; NonCopyable operator(const NonCopyable) delete; // 允许移动 NonCopyable(NonCopyable) default; NonCopyable operator(NonCopyable) default; };6.3 继承体系下的默认成员函数在继承中派生类的默认成员函数会自动调用基类对应的成员函数。派生类的默认构造函数会先调用基类的默认构造函数。派生类的拷贝构造函数会先调用基类的拷贝构造函数。派生类的移动构造函数会先调用基类的移动构造函数如果基类有的话否则调用拷贝构造。派生类的拷贝/移动赋值运算符需要显式调用基类的对应运算符。派生类的析构函数会在函数体执行后自动调用基类的析构函数。重要提示在多态基类中析构函数应该声明为virtual以确保通过基类指针删除派生类对象时能够正确调用派生类的析构函数。如果一个类有任何虚函数它通常也应该有一个虚析构函数。class Base { public: virtual ~Base() default; // 虚析构函数 Base() default; Base(const Base) default; Base(Base) default; Base operator(const Base) default; Base operator(Base) default; }; class Derived : public Base { public: // 编译器生成的派生类默认成员函数会自动处理基类部分 // 例如~Derived() 会先执行 ~Derived() 的函数体如果有然后自动调用 ~Base()。 // Derived(const Derived other) : Base(other) { /* 派生类成员拷贝 */ } // Derived operator(const Derived other) { Base::operator(other); /* 派生类成员赋值 */ return *this; } private: std::vectorint data; };理解C的默认成员函数是写出正确、高效、现代C代码的必经之路。从最初的好奇“为什么空类也能实例化”到后来被深浅拷贝问题折磨再到最后熟练运用“五法则”和“零法则”来设计类这个过程是每个C开发者都会经历的。我的建议是在项目初期就明确每个类的拷贝和移动语义它是值类型需要深拷贝还是资源句柄需要移动语义可能禁止拷贝或者是仅包含其他管理类的复合类型可以使用默认行为。想清楚了这些你就能让编译器成为你的得力助手而不是bug的源泉。
