1. 项目概述为什么“类和对象”是C的基石如果你正在复习C或者准备面试看到“类和对象”这个标题可能会觉得这太基础了不就是class和new一下吗但以我十多年的经验来看恰恰是这些最基础的概念构成了C面向对象编程的骨架也是面试官最喜欢深挖、最能区分候选人水平的地方。很多人能写出一个类却说不清访问限定符的细微差别能背出六个默认成员函数的名字却搞不懂编译器在什么情况下会默默生成它们以及这背后隐藏的陷阱。这次复习我们不搞花架子就扎扎实实地把“类和对象”这块地基打牢。我会带你从“为什么需要类”这个最根本的问题出发一步步拆解访问限定符public、private、protected的设计哲学和实际应用场景然后重点攻坚那六个由编译器“暗中相助”的默认成员函数构造函数、析构函数、拷贝构造函数、拷贝赋值运算符、移动构造函数、移动赋值运算符。我会用大量我实际踩过的坑和调试过的案例告诉你这些知识点在真实项目里是怎么用的以及怎么避开那些教科书上不会写的“雷区”。无论你是想巩固基础还是备战大厂面试这篇内容都能让你对C面向对象的理解从“知道”提升到“通透”的层次。2. 类的引入与封装思想从结构体到类2.1 结构体的局限与类的诞生在C语言里我们习惯用结构体struct来组织相关联的数据。比如我们要表示一个学生struct Student_C { char name[20]; int age; float score; };然后写一堆函数来操作它initStudent,printStudent,setScore等等。数据和操作数据的函数是分离的。这带来几个问题第一任何地方的代码都可以随意修改Student_C结构体里的数据没有保护很容易出现数据被意外篡改的bug。第二数据和函数没有逻辑上的绑定关系代码的组织性不够强。C中的“类”class就是为了解决这些问题而生的。类的核心思想是封装Encapsulation。你可以把类想象成一个智能的、自带操作说明的“数据盒子”。盒子里面装着数据称为成员变量或属性也装着能操作这些数据的函数称为成员函数或方法。最关键的是这个盒子可以设置“访问权限”决定盒子里的哪些东西可以从外面直接看到和操作哪些东西被隐藏起来只能通过盒子提供的特定接口来间接操作。用C的类来重写上面的例子class Student { private: // 数据通常隐藏起来 std::string name; int age; float score; public: // 对外提供的操作接口 // 设置成绩可以加入校验逻辑 void setScore(float s) { if (s 0.0f s 100.0f) { score s; } else { std::cout Invalid score! std::endl; } } // 获取成绩 float getScore() const { return score; } // 打印学生信息 void printInfo() const { std::cout Name: name , Age: age , Score: score std::endl; } };看到区别了吗score现在是private的外部代码不能直接student.score 150;这样乱写了。必须通过我们提供的setScore函数而这个函数内部可以加入有效性检查。这就是封装的力量将数据隐藏仅暴露必要的、安全的操作接口。实操心得很多新手会觉得把所有成员都设为public多方便为什么要“自找麻烦”用private加getter/setter在小型程序或练习中可能看不出差别但在大型项目或团队协作中这至关重要。一旦数据直接暴露后期如果你想修改数据存储方式比如把score从float改成int或者增加一些设置数据时的副作用比如每次改分数要记录日志你会发现所有直接访问score的代码都需要修改工作量是灾难性的。而如果一开始就通过函数接口访问你只需要修改这一个函数内部的实现即可。这是一种为未来变化预留空间的编程习惯。2.2 class与struct在C中的关键区别这里有一个C特有的重要知识点在C中struct也被升级了它也可以有成员函数、构造函数、访问限定符。那么class和struct的唯一区别是什么默认访问权限不同。在class中默认的访问权限是private。在struct中默认的访问权限是public。也就是说class MyClass { int x; // 默认是 private public: int y; }; struct MyStruct { int a; // 默认是 public private: int b; };这个区别源于历史兼容性。C让struct保持默认public是为了兼容C语言的用法C的结构体成员都是直接访问的。而在定义新抽象数据类型时更推荐使用class因为它默认私有更符合封装“隐藏数据”的初衷。注意事项虽然语法上区别很小但在实际项目和编码规范中通常有一个约定俗成的习惯struct更偏向于用来表示一个纯粹的数据结构只有数据成员或者只有很少的、简单的成员函数比如构造函数。而class则用来表示具有复杂行为和不变式的抽象数据类型。但这只是习惯并非强制语法规则。3. 访问限定符详解public, private, protected访问限定符是封装思想的具体实现工具它们控制了类成员的“可见性”。理解它们不能只靠死记要结合场景。3.1 public对外的服务窗口public成员构成了类的接口。这是类与外部世界包括main函数、其他类的函数等沟通的桥梁。通常将成员函数设为public用于被外部调用而数据成员极少设为public除非这个数据是常量const或者非常简单无需任何保护例如某些仅用于内部记录、不影响类逻辑状态的标志位但这种情况也较少见。class BankAccount { private: double balance; // 余额必须隐藏 public: // 公共接口 bool deposit(double amount); // 存款 bool withdraw(double amount); // 取款内部会校验余额 double getBalance() const; // 查询余额 // 构造函数也通常是public的否则无法创建对象 BankAccount(double initialBalance); };外部代码可以这样使用BankAccount myAccount(1000.0); myAccount.deposit(500.0); // OK调用公共接口 // myAccount.balance 1000000.0; // 错误balance是private的无法直接访问 double money myAccount.getBalance(); // OK通过接口获取3.2 private内部的保险箱private成员是类的实现细节。外部代码完全无法访问除非使用friend但慎用。这是封装的核心用于隐藏数据和不希望暴露的内部辅助函数。为什么要用private强制使用接口确保对数据的任何操作都经过你设计的函数你可以在函数里添加校验、日志、触发事件等逻辑。保持类不变式类不变式是指对象在其生命周期内必须始终保持为真的条件。比如一个Date类月份必须在1-12之间。如果把月份变量设为public外部可以直接设为13不变式就被破坏了。如果设为private通过setMonth函数就可以进行检查。降低耦合度外部代码不依赖于类的内部数据结构。以后你完全可以把balance从double类型改成某个高精度货币类只要getBalance的返回类型和语义不变外部代码一行都不用改。class Date { private: int year; int month; // 1-12 int day; // 1-31根据月份和闰年变化 public: void setMonth(int m) { if (m 1 m 12) { month m; // 可能还需要根据月份调整天数day的有效范围 } else { throw std::invalid_argument(Invalid month); } } };3.3 protected家族内部的传承protected访问权限是为“继承”这个特性量身定做的。它介于public和private之间。对本类来说protected和private一样类自己的成员函数可以访问。对派生类子类来说protected成员是可见的、可访问的而private成员是不可见的。对外部代码来说protected和private一样都不能访问。可以把protected理解为给未来子类开的一个“后门”。当你设计一个基类有些成员你不想对全世界公开所以不是public但又希望子类能够使用或重写它们所以不能是private这时就用protected。class Shape { protected: // 子类需要知道这些数据来实现面积、周长计算 double x, y; // 形状的基准点坐标 std::string color; public: virtual double area() const 0; // 纯虚函数接口 virtual void draw() const; // 虚函数可被重写 }; class Circle : public Shape { private: double radius; public: double area() const override { return 3.14159 * radius * radius; } void draw() const override { // 在绘制时可能需要用到从Shape继承来的 protected 成员 x, y, color std::cout Drawing a color circle at ( x , y ) std::endl; } };在上例中x,y,color对Shape的外部使用者是不可见的但Circle类在实现自己的draw函数时可以使用它们这保证了代码在继承体系内的复用性。常见误区与排查很多初学者容易混淆protected的用途或者过度使用它。一个常见的错误是因为图方便把本应是private的数据成员改成protected让子类直接修改。这破坏了封装性因为现在不止一个类基类能控制这个数据多个子类都可以随意修改维护起来同样困难。一个实用的原则是除非明确需要子类直接访问或修改否则优先使用private。即使子类需要也可以考虑在基类提供protected的getter/setter函数而不是直接暴露数据成员。4. 类的6个默认成员函数深度解析这是C类和对象中最硬核、也最容易出问题的一部分。当你定义一个类而没有显式定义下面这些函数时编译器会在需要的时候为你自动生成一个默认版本。理解它们何时生成、做了什么、有什么陷阱是写出健壮C代码的关键。4.1 构造函数与析构函数对象的生与死构造函数在对象创建时自动调用用于初始化对象的状态。它的名字与类名相同没有返回类型。析构函数在对象生命周期结束时自动调用比如离开作用域、被delete用于清理资源。它的名字是~加类名没有参数和返回类型。class MyString { private: char* m_data; size_t m_size; public: // 1. 构造函数 MyString(const char* str ) { std::cout Constructor called std::endl; m_size strlen(str); m_data new char[m_size 1]; // 在堆上分配内存 strcpy(m_data, str); } // 2. 析构函数 ~MyString() { std::cout Destructor called for: m_data std::endl; delete[] m_data; // 释放堆内存防止内存泄漏 } void print() const { std::cout m_data std::endl; } };编译器生成的默认版本默认构造函数如果你没有定义任何构造函数编译器会生成一个。它什么也不做只是调用成员变量自己的默认构造函数对于内置类型如int、指针则是不进行初始化值是未定义的。默认析构函数如果你没有定义编译器会生成一个。它什么也不做对于类类型成员会调用其析构函数对于内置类型则什么都不做。实操心得必须自定义析构函数的情况Rule of Three/Five的起点上面的MyString类就是一个典型例子。它管理了动态分配的内存m_data。编译器生成的默认析构函数只会销毁m_data这个指针变量本身而不会释放它指向的那块堆内存。这会导致内存泄漏。因此如果一个类需要管理资源内存、文件句柄、网络连接等你必须自定义析构函数来正确释放资源。一旦你自定义了析构函数通常意味着你也需要处理拷贝和赋值的问题见下文这就是著名的“三/五法则”。4.2 拷贝构造函数与拷贝赋值运算符浅拷贝的陷阱这是面试必考也是实际项目中最容易踩坑的地方。拷贝构造函数用同类型的另一个对象来初始化一个新对象时调用。 形式T(const T other)拷贝赋值运算符将一个对象的值赋给另一个已经存在的对象时调用。 形式T operator(const T other)编译器生成的默认版本浅拷贝 默认的拷贝构造函数和拷贝赋值运算符行为是“按成员拷贝”member-wise copy。对于指针成员它们只拷贝指针的值地址而不拷贝指针指向的内容。这会导致两个对象的指针指向同一块内存。// 接上面的MyString类假设我们使用编译器生成的拷贝构造和拷贝赋值 int main() { MyString str1(Hello); MyString str2 str1; // 调用默认拷贝构造函数浅拷贝 // 此时 str1.m_data 和 str2.m_data 指向同一块内存 str1.print(); // Hello str2.print(); // Hello // 修改str2的内容为了演示假设我们有个不安全的修改方法 // str2.m_data[0] J; // 这也会改变str1 // 更严重的问题当main函数结束对象析构时 // 先析构str2释放了那块内存 // 再析构str1试图释放同一块已经释放的内存 - 程序崩溃双重释放 }这就是经典的浅拷贝问题。对于管理资源的类我们必须进行深拷贝。class MyString { // ... 其他成员同上 public: // 3. 拷贝构造函数深拷贝 MyString(const MyString other) { std::cout Copy Constructor called std::endl; m_size other.m_size; m_data new char[m_size 1]; strcpy(m_data, other.m_data); } // 4. 拷贝赋值运算符深拷贝 MyString operator(const MyString other) { std::cout Copy Assignment called std::endl; if (this ! other) { // 1. 防止自赋值 a a delete[] m_data; // 2. 释放原有资源 m_size other.m_size; m_data new char[m_size 1]; // 3. 分配新资源 strcpy(m_data, other.m_data); } return *this; // 4. 返回本对象的引用 } };拷贝赋值运算符的四个要点务必记住检查自赋值if (this ! other)。防止a a时先释放了自己的资源然后又试图从已释放的资源拷贝数据。释放旧资源在分配新资源前必须释放对象当前持有的资源否则会内存泄漏。分配新资源并拷贝进行深拷贝。返回本对象的引用为了支持链式赋值a b c。注意事项三法则如果一个类需要自定义析构函数那么它几乎肯定也需要自定义拷贝构造函数和拷贝赋值运算符。因为需要深拷贝的资源管理逻辑是相同的。这就是经典的“三法则”。在C11之前这是最重要的类设计准则之一。4.3 移动构造函数与移动赋值运算符性能优化的利器C11C11引入了右值引用和移动语义主要为了解决临时对象拷贝带来的性能开销。编译器也会生成默认的移动操作。移动语义的核心与其深拷贝一个即将销毁的临时对象右值的资源不如“偷”它的资源过来然后将它置于一个可安全析构的状态。移动构造函数T(T other) noexcept移动赋值运算符T operator(T other) noexceptclass MyString { // ... 其他成员同上 public: // 5. 移动构造函数 MyString(MyString other) noexcept // noexcept很重要标准库容器移动时会检查 : m_data(other.m_data), m_size(other.m_size) { // 直接“窃取”资源 std::cout Move Constructor called std::endl; // 将源对象置于有效但可析构的状态 other.m_data nullptr; other.m_size 0; } // 6. 移动赋值运算符 MyString operator(MyString other) noexcept { std::cout Move Assignment called 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; } };何时调用移动操作当源对象是一个右值如临时对象、std::move转换的结果时编译器会优先选择移动构造或移动赋值因为它们效率更高只是转移指针没有内存分配和拷贝。MyString createString() { MyString temp(Temporary); return temp; // 此处可能触发NRVO返回值优化否则会调用移动构造 } int main() { MyString s1(Hello); MyString s2 std::move(s1); // 强制使用移动构造之后s1不再拥有“Hello” // s1现在是有效但空的状态m_data为nullptr MyString s3; s3 createString(); // createString()返回的是临时对象右值调用移动赋值 }编译器生成的默认移动操作 如果你没有声明拷贝操作、移动操作和析构函数那么编译器会生成默认的移动构造函数和移动赋值运算符它们的行为是“按成员移动”对内置类型直接拷贝值对类类型成员调用其移动操作如果存在否则调用拷贝操作。 但如果你显式声明了拷贝操作、析构函数中的任何一个编译器不会再自动生成默认的移动操作。这是为了兼容老代码避免意外的移动导致错误。实操心得五法则与 default现代CC11以后的准则是“五法则”如果一个类需要自定义析构函数、拷贝构造函数、拷贝赋值运算符中的一个那么很可能五个函数加上两个移动操作都需要仔细考虑。 一个良好的实践是如果你需要自定义这些特殊成员函数明确地使用 default来让编译器生成默认版本或者使用 delete来禁止某个操作这会让你的意图更清晰。class RuleOfFive { public: RuleOfFive() default; // 默认构造 ~RuleOfFive() default; // 默认析构 RuleOfFive(const RuleOfFive) default; // 默认拷贝构造 RuleOfFive operator(const RuleOfFive) default; // 默认拷贝赋值 RuleOfFive(RuleOfFive) default; // 默认移动构造 RuleOfFive operator(RuleOfFive) default; // 默认移动赋值 // 或者如果你不想让对象被拷贝 // RuleOfFive(const RuleOfFive) delete; // RuleOfFive operator(const RuleOfFive) delete; };5. 综合实战一个具备完整六大函数的String类让我们把所有知识点整合起来实现一个简化但功能完整的MyString类并观察各个函数被调用的时机。#include iostream #include cstring #include utility class MyString { private: char* m_data; size_t m_size; public: // 1. 默认构造函数 MyString(const char* str ) : m_data(nullptr), m_size(0) { std::cout [Default] Constructor: (str ? str : empty) std::endl; if (str) { m_size strlen(str); m_data new char[m_size 1]; strcpy(m_data, str); } } // 2. 析构函数 ~MyString() { std::cout [Destructor] Cleaning up: (m_data ? m_data : nullptr) std::endl; delete[] m_data; } // 3. 拷贝构造函数 (深拷贝) MyString(const MyString other) : m_data(nullptr), m_size(0) { std::cout [Copy] Constructor from: other.m_data std::endl; m_size other.m_size; if (m_size 0) { m_data new char[m_size 1]; strcpy(m_data, other.m_data); } } // 4. 拷贝赋值运算符 (深拷贝) MyString operator(const MyString other) { std::cout [Copy] Assignment from: other.m_data to: m_data std::endl; if (this ! other) { delete[] m_data; m_size other.m_size; m_data nullptr; if (m_size 0) { m_data new char[m_size 1]; strcpy(m_data, other.m_data); } } return *this; } // 5. 移动构造函数 MyString(MyString other) noexcept : m_data(other.m_data), m_size(other.m_size) { std::cout [Move] Constructor from: other.m_data std::endl; other.m_data nullptr; // 置空源对象防止双重释放 other.m_size 0; } // 6. 移动赋值运算符 MyString operator(MyString other) noexcept { std::cout [Move] Assignment from: other.m_data to: m_data 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; } // 辅助函数打印内容 void print() const { std::cout Content: \ (m_data ? m_data : nullptr) \ std::endl; } }; // 测试函数返回临时对象 MyString createTempString() { MyString temp(Temporary String); return temp; // 期待触发移动语义或NRVO } int main() { std::cout 1. 基本构造与析构 std::endl; MyString s1(Hello World); s1.print(); std::cout \n 2. 拷贝构造 std::endl; MyString s2 s1; // 拷贝构造 s2.print(); std::cout \n 3. 拷贝赋值 std::endl; MyString s3; s3 s2; // 拷贝赋值 s3.print(); std::cout \n 4. 移动构造 std::endl; MyString s4 std::move(s3); // 移动构造s3被“掏空” s4.print(); std::cout s3 after move: ; s3.print(); // s3现在应该是空状态 std::cout \n 5. 移动赋值 std::endl; MyString s5; s5 createTempString(); // 函数返回右值调用移动赋值 s5.print(); std::cout \n 6. 离开作用域析构顺序 std::endl; // main函数结束所有局部对象s1, s2, s4, s5按创建相反顺序析构 // s3已被移动但其析构函数仍会被调用处理nullptr是安全的 return 0; }运行这段代码仔细观察输出你会清晰地看到各个函数在对象生命周期中是如何被调用的。理解这些调用时机对于调试内存问题和性能优化至关重要。6. 常见问题与排查技巧实录在实际开发和面试中关于类和对象的问题层出不穷。这里我总结几个最典型的问题和排查思路。6.1 问题对象被意外拷贝导致性能下降或逻辑错误场景在函数传参或返回值时无意中触发了昂贵的拷贝操作。void processString(MyString str) { // 按值传递会触发拷贝构造 // ... 处理str } MyString s(large data...); processString(s); // 这里发生了一次深拷贝如果字符串很大开销巨大排查与解决使用const引用传递如果函数不需要修改对象总是使用const T。void processString(const MyString str) { // 没有拷贝 // 只能读取str }使用移动语义如果函数需要接管对象的所有权或者对象是临时值使用值传递并配合std::move。void takeOwnership(MyString str) { // 只接受右值 // 移动str的资源 } takeOwnership(std::move(s)); // 明确转移所有权编译器优化了解RVO返回值优化和NRVO具名返回值优化。现代编译器会在某些情况下消除函数返回时的拷贝或移动。MyString createString() { MyString local(hi); return local; // 编译器可能会直接构造在调用者的位置避免拷贝/移动 }6.2 问题默认生成的函数不符合预期场景类中有指针成员但忘记了“三/五法则”导致浅拷贝和双重释放。排查代码审查时重点检查类中是否有动态分配的资源new/malloc或需要手动管理的资源文件描述符、套接字等。如果存在立刻自问我需要自定义析构函数来释放资源吗通常是需要我需要自定义拷贝构造函数和拷贝赋值运算符来实现深拷贝吗如果资源需要独占通常需要我可以定义移动构造函数和移动赋值运算符来提升性能吗如果支持拷贝通常可以且应该定义移动操作使用 delete明确禁止拷贝如果这个类根本不应该被拷贝比如管理唯一资源的句柄类。class NonCopyable { public: NonCopyable() default; ~NonCopyable() default; NonCopyable(const NonCopyable) delete; // 禁止拷贝构造 NonCopyable operator(const NonCopyable) delete; // 禁止拷贝赋值 // 可以定义移动操作 NonCopyable(NonCopyable) default; NonCopyable operator(NonCopyable) default; };6.3 问题继承体系中基类析构函数非虚导致的资源泄漏这是一个经典且严重的问题。class Base { public: Base() { /* 可能分配资源 */ } ~Base() { std::cout Base destructor\n; /* 可能释放资源 */ } // 非虚析构函数 }; class Derived : public Base { public: Derived() { m_data new int[100]; } ~Derived() { delete[] m_data; std::cout Derived destructor\n; } private: int* m_data; }; int main() { Base* ptr new Derived(); delete ptr; // 这里只调用了 ~Base()没有调用 ~Derived()内存泄漏 }排查与解决黄金法则如果一个类设计为会被继承即有可能用基类指针指向派生类对象并且基类有需要清理的资源或者派生类可能有那么基类的析构函数必须声明为virtual。class Base { public: virtual ~Base() default; // 虚析构函数 };即使基类析构函数什么都不做也声明为virtual。这是一个低成本的安全保障。反之如果一个类明确不会被用作基类比如final类或者没有虚函数可以将其析构函数声明为非虚这有助于优化。6.4 问题const成员函数与mutable关键字场景你想在一个const对象上调用成员函数或者在一个const成员函数内修改某个不影响对象逻辑状态的成员。class Cache { private: mutable std::string cached_result; // 使用 mutable bool cache_valid; int expensive_calculation() const; // 假设这个计算很耗时 public: std::string get_result() const { if (!cache_valid) { // 错误不能在const成员函数内修改非mutable成员 // cached_result std::to_string(expensive_calculation()); // cache_valid true; } return cached_result; } };解决将那些从对象逻辑角度看是常量但从实现角度看可能需要修改的成员如缓存、互斥锁、引用计数声明为mutable。这样const成员函数也可以修改它们。class Cache { private: mutable std::string cached_result; mutable bool cache_valid{false}; int expensive_calculation() const; public: std::string get_result() const { if (!cache_valid) { cached_result std::to_string(expensive_calculation()); cache_valid true; } return cached_result; } };mutable的使用要谨慎确保修改的确实是“物理状态”而非“逻辑状态”。类和对象是C面向对象的根基理解其背后的机制而非仅仅记住语法是写出正确、高效、易维护代码的关键。复习时多问几个“为什么”多动手写一些包含资源管理的类体会拷贝和移动的差异这些经验远比死记硬背要来得深刻。在实际项目中遵循“五法则”善用default和delete明确每个类的职责和边界你的C代码质量会提升一个档次。