Skip to content

C++ 面向对象 ​


一、类与对象基础 ​

1. struct vs class ​

Q: C++ 中 struct 和 class 的区别?(高频)

structclass
默认成员权限publicprivate
默认继承权限public 继承private 继承
其他完全相同(都可以有成员函数、构造/析构、继承、多态)

C++ 中 struct 不只是 C 时代的"数据集合",几乎就是 class。一般约定:纯数据聚合用 struct,有复杂逻辑用 class。


2. 空类大小为什么是 1? ​

Q: 空类 sizeof 为什么是 1?

C++ 要求每个对象在内存中必须有独一无二的地址。如果空类大小为 0,那么 Empty arr[10] 中的 10 个对象地址都一样,无法区分。这 1 字节是占位符。

cpp
class Empty {};                      // sizeof(Empty) = 1

class Derived : public Empty {
    int x;
};
// sizeof(Derived) = 4(不是 5 或 8)
// 基类 Empty 的 1 字节被编译器优化掉了(Empty Base Optimization, EBO)

3. this 指针 ​

Q: this 指针的本质是什么?什么时候存在?

问题答案
本质编译器自动添加的隐式函数参数,指向调用该函数的对象
值当前调用函数的那个对象的地址
是否占空间不占对象的 sizeof
存在位置非静态成员函数、构造函数、析构函数
不存在于静态成员函数(属于类,不属于任何对象)
cpp
class A {
public:
    void f() { /* this 指向调用对象 */ }
};

A a1, a2;
a1.f();   // this = &a1
a2.f();   // this = &a2
// 函数还是同一个函数,只是 this 变了

静态成员函数没有 this 指针,因此不能访问非静态成员变量——它可以通过 类名::函数() 调用,此时可能没有任何对象存在。


二、构造函数与析构函数 ​

1. 初始化列表 ​

Q: 为什么推荐使用初始化列表?哪些成员必须用初始化列表?

对比初始化列表函数体内赋值
过程直接调用对应构造函数先默认构造,再赋值(多一次中间开销)
效率高低

以下三种成员只能通过初始化列表初始化:

成员类型原因
const 成员常量不可赋值,只能初始化
引用成员 int&引用必须在定义时绑定
没有默认构造函数的成员/基类编译器不知道如何自动创建
cpp
class Mandatory {
    const int a;         // 1. const 成员
    int& b;              // 2. 引用成员
    NoDefault c;         // 3. 无默认构造的成员(假设 NoDefault 没有无参构造)

public:
    Mandatory(int v1, int& v2, int v3)
        : a(v1), b(v2), c(v3)   // 必须用初始化列表
    { }
};

注意:成员初始化的顺序只由它们在类中声明的顺序决定,与初始化列表中的书写顺序无关。

cpp
class Order {
    int a;  // 先声明,先初始化
    int b;
public:
    Order(int x) : b(x), a(b) {}  // 危险!a 先初始化,此时 b 是随机值
};

2. explicit 关键字 ​

Q: explicit 的作用是什么?

禁止单参数构造函数引发的隐式类型转换。

cpp
class MyBuffer {
public:
    explicit MyBuffer(int size);   // 加上 explicit
};

void process(MyBuffer buf);
process(10);                       // ❌ 编译错误,禁止隐式转换
process(MyBuffer(10));             // ✅ 必须显式构造

不加 explicit 时,编译器会自动把 int 转成 MyBuffer,可能隐藏 Bug。


3. 析构函数与虚析构函数 ​

Q: 为什么基类的析构函数必须是 virtual?(高频)

情况行为后果
基类析构不是 virtualdelete 基类指针时,只调用基类析构派生类特有的堆资源不释放 → 内存泄漏
基类析构是 virtualdelete 基类指针时,先调派生类析构,再调基类析构资源正确释放
cpp
class Base {
public:
    virtual ~Base() {}   // 虚析构
};

class Derived : public Base {
    int* data;
public:
    Derived() : data(new int[100]) {}
    ~Derived() { delete[] data; }
};

// 基类指针指向子类对象
Base* p = new Derived();
delete p;   // 先调 ~Derived(),再调 ~Base()。如果 ~Base() 不是 virtual,则 ~Derived() 不会被调

工程准则:只要类里有一个虚函数(说明它会被继承),析构函数就必须设为 virtual。


4. 构造与析构的执行顺序 ​

Q: 构造和析构的执行顺序是怎样的?

阶段构造顺序(自上而下)析构顺序(自下而上)
1基类构造函数(多继承按声明顺序)派生类析构函数
2成员对象构造函数(按声明顺序)成员对象析构函数(逆序)
3自身构造函数体基类析构函数(逆序)

析构顺序与构造顺序严格相反。原因:派生类可能依赖基类提供的基础功能,基类先析构会导致派生类析构时访问已销毁的资源。


5. 构造函数中调用虚函数 ​

Q: 在构造函数/析构函数中调用虚函数会发生什么?

结论:无法实现动态多态,只会调用当前类的版本。

原理:

  1. 执行基类构造函数时,派生类的成员尚未初始化
  2. 此时对象的 vptr 指向的是**当前类(基类)**的虚函数表
  3. 即使函数声明为 virtual,也只会调用基类的实现
cpp
class Base {
public:
    Base() { print(); }           // 构造中调用虚函数
    virtual void print() { cout << "Base" << endl; }
};

class Derived : public Base {
public:
    virtual void print() { cout << "Derived" << endl; }
};

Derived d;   // 输出 "Base",不是 "Derived"!

替代方案:如果需要在构造后执行多态逻辑,使用"二段式初始化"(先构造,再调用显式的 init() 函数)。


6. default 与 delete ​

Q: = default 和 = delete 分别用来做什么?

用法作用典型场景
= default显式要求编译器生成默认版本基类虚析构:virtual ~Base() = default;
= delete禁用该函数禁止拷贝:MutexLock(const MutexLock&) = delete;
cpp
class NonCopyable {
public:
    NonCopyable() = default;
    NonCopyable(const NonCopyable&) = delete;             // 禁止拷贝
    NonCopyable& operator=(const NonCopyable&) = delete;  // 禁止赋值
};

= delete 的三种经典用法 ​

A. 禁止拷贝 / 移动(最常见的用途) ​
cpp
class ThreadPool {
public:
    ThreadPool(const ThreadPool&) = delete;             // 禁止拷贝构造
    ThreadPool& operator=(const ThreadPool&) = delete;  // 禁止拷贝赋值
    ThreadPool(ThreadPool&&) = delete;                  // 禁止移动构造
    ThreadPool& operator=(ThreadPool&&) = delete;       // 禁止移动赋值
};

线程池为什么要四连 delete? 线程池内部持有 OS 线程、互斥锁、条件变量——这些资源无法"克隆",拷贝或移动都会导致双重释放或悬空 this。

B. 禁用某个参数类型的重载(防止隐式转换) ​
cpp
void process(int value) { /* 处理整数 */ }

// 禁止隐式转换:不让 float、char、bool 等悄悄转成 int 走上面的重载
void process(float) = delete;
void process(char)  = delete;
void process(bool)  = delete;

process(42);    // ✅ 走 int 版本
process(3.14f); // ❌ 编译错误:float 版本已 delete
process('a');   // ❌ 编译错误:char 版本已 delete
C. 禁止某种 new/delete 形式 ​
cpp
struct StackOnly {
    void* operator new(std::size_t) = delete;  // 禁止堆分配
};

StackOnly obj;          // ✅ 栈上创建
// auto* p = new StackOnly();  // ❌ 编译错误!

struct HeapOnly {
    ~HeapOnly() = delete;  // 技巧:禁止栈上创建(无法自动析构)
    static void destroy(HeapOnly* p) { /* 手动析构逻辑 */ p->~HeapOnly(); }
};

// HeapOnly obj;         // ❌ 编译错误:析构被 delete
auto* p = new HeapOnly(); // ✅ 只能堆分配
HeapOnly::destroy(p);      // 手动销毁

---

### 7. default 与 {} 的区别

> **Q: `= default` 和自己写 `{}` 有什么区别?**

本质的区别在于:**= default 显式要求编译器生成‘编译器默认版本’的函数,而 {} 是‘用户自定义’的函数版本,只是内容恰好为空。**

**琐碎性—— 性能的关键**

- **= default:** 如果类没有虚函数、没有虚基类且成员也是琐碎的,那么 = default 的构造/析构函数就是 **Trivial(琐碎的)**。
- **{}:** 一旦有了大括号,它就是 **Non-trivial** 的。
- Trivial 类在 STL 容器中可以触发**底层优化**。比如在扩容移动元素时,编译器可以直接调用 memcpy 或 memmove,而**不是循环调用构造函数,性能差距极大**。

#### 四种写法的行为对比

以默认构造函数为例:

```cpp
class Foo {
public:
    // ① 什么都不写 —— 编译器在"需要时"自动生成
    // (用户定义了任何其他构造函数后,编译器就不再生成默认构造)

    // ② = default —— 显式要求编译器生成默认版本
    Foo() = default;

    // ③ 自己写空 {} —— 用户自定义的空函数体
    Foo() {}

    // ④ = delete —— 明确禁用该函数
    Foo() = delete;
};
什么都不写= default{}(空函数体)= delete
本质编译器按需隐式生成显式要求编译器生成用户自定义的函数显式禁用
Trivial?可能是(满足条件时)可能是(满足条件时)永远不是—
能参与重载?—✅✅✅(delete 的函数仍参与重载决议,匹配到时编译报错)
对移动函数的影响不影响其他函数的隐式生成不影响有影响(见 §二.8)影响(声明了拷贝 → 移动不自动生成)
意图表达模糊:"我不关心"清晰:"给我就行,用编译器版本"清晰:"我有自定义逻辑"清晰:"此路不通"

= default vs {}:Trivial 与非 Trivial 的本质区别 ​

这是最容易被追问的点。两者在运行结果上可能完全一样(都是空操作),但在编译器视角下有天壤之别:

cpp
#include <type_traits>

struct WithDefault {
    WithDefault() = default;   // 编译器生成 → 可能是 Trivial
};

struct WithEmptyBody {
    WithEmptyBody() {}         // 用户定义 → 一定不是 Trivial
};

// Trivial 类型判断
static_assert(std::is_trivial_v<WithDefault>);   // ✅ 通过(成员也都是 Trivial 时)
static_assert(std::is_trivial_v<WithEmptyBody>); // ❌ 失败!

Trivial 类型享有的特权:

特性Trivial(= default)非 Trivial({})
内存初始化malloc 分配即可,无需调构造函数必须调构造函数
内存拷贝memcpy 即可,无需调拷贝构造必须调拷贝构造
放入联合体 (union)✅ 允许(C++11+)❌ 受限
作为 constexpr 变量✅ 可以取决于实现
ABI 稳定性编译器控制受用户实现影响
cpp
// 实际影响示例
Trivial* arr1 = (Trivial*)malloc(sizeof(Trivial) * 1000);  // ✅ 合法
// → arr1 中的对象虽然未初始化,但类型是 Trivial,可以直接使用
// (值未定义,但不会触发 UB)

NonTrivial* arr2 = (NonTrivial*)malloc(sizeof(NonTrivial) * 1000); // ⚠️ 危险
// → arr2 中的对象未初始化,访问它们是未定义行为!
// → 必须逐个 placement new 构造

一句话:= default 把决定权交给编译器(可能获得 Trivial 优化),{} 则是用户抢过了方向盘(放弃了 Trivial 特权)。不需要自定义逻辑时,永远优先 = default。


8. 编译器默认生成的成员函数 ​

Q: 编译器会自动生成哪些成员函数?什么情况下不会生成?

函数自动生成条件不再生成的情况
默认构造函数类中没有任何用户定义的构造函数定义了任何构造函数
拷贝构造函数没有定义移动函数定义了移动构造/赋值 → 拷贝被 delete
拷贝赋值运算符没有定义移动函数定义了移动构造/赋值 → 拷贝被 delete
移动构造函数没有定义析构、拷贝、移动中任意一个定义了析构/拷贝/移动中任意一个
移动赋值运算符同上同上
析构函数没有自定义析构函数自定义了析构函数
cpp
// 经典陷阱:基类有了 virtual 析构,移动语义自动消失!
class Base {
public:
    virtual ~Base() = default;   // 自定义析构 → 移动构造/赋值不再自动生成
    // 如果还需要移动,必须显式 = default:
    Base(Base&&) = default;
    Base& operator=(Base&&) = default;
};

记忆规律:析构/拷贝/移动,显式定义了任何一个,其他几个都需要审视是否要补齐。


三、封装 ​

1. 访问控制 ​

Q: public / private / protected 的区别?

访问权限类内部派生类外部
public✅✅✅
protected✅✅❌
private✅❌❌

封装的核心思想:将数据(属性)和操作数据的函数(行为)捆绑在一起,隐藏内部实现细节,只暴露有限的对外接口。

  • 成员变量通常设为 private,通过 getter/setter 访问
  • 接口函数设为 public
  • 需要让派生类访问但不对外暴露的成员设为 protected

2. 接口与实现分离 ​

  • .h 文件:只放类声明(接口),告诉外界"能做什么"
  • .cpp 文件:放具体实现,隐藏"怎么做"

3. const 成员函数 ​

Q: 成员函数后面的 const 有什么作用?

cpp
class Person {
public:
    int getAge() const { return age; }  // 承诺不修改成员变量
private:
    int age;
};
效果说明
承诺只读函数内不能修改任何成员变量(mutable 除外)
const 对象可调用const Person& p 只能调用 const 成员函数
重载依据const 和非 const 版本可以构成重载

4. friend(友元) ​

friend 声明的函数或类可以访问本类的 private 成员。虽然打破了封装,但在运算符重载等场景中很实用。

cpp
class A {
private:
    int x;
    friend void print(A& a);     // 友元函数
    friend class B;              // 友元类
};

四、继承 ​

1. 继承的概念 ​

继承:基于已存在的类(基类)创建新类(派生类)。子类 is-a 父类。

  • 基类:包含通用的属性和行为
  • 派生类:自动获得基类成员,并可添加/修改自己的功能
cpp
class Animal {
public:
    void eat() { cout << "eat" << endl; }
};

class Dog : public Animal {      // public 继承
public:
    void bark() { cout << "bark" << endl; }
};

Dog d;
d.eat();    // 继承自 Animal
d.bark();   // 自己的方法

2. 三种继承方式 ​

Q: public / protected / private 继承的区别是什么?

基类成员访问级别public 继承protected 继承private 继承
public保持 public变为 protected变为 private
protected保持 protected变为 protected变为 private
private不可见不可见不可见

实际开发中,99% 的场景使用 public 继承,其余两种极少使用。


3. 子类调用父类构造函数 ​

如果父类没有默认构造函数,子类必须在初始化列表中显式调用父类构造函数。

cpp
class Animal {
    string name;
public:
    Animal(string n) : name(n) {}   // 没有默认构造
};

class Dog : public Animal {
public:
    Dog(string n) : Animal(n) {}    // 必须显式调用
};

4. 继承的分类 ​

类型描述问题
单继承一个子类只有一个父类无
多继承一个子类有多个父类可能导致菱形继承
菱形继承多继承中,多个父类继承自同一基类基类成员在子类中有多份,造成冗余
cpp
// 菱形继承
class Animal { public: int age; };
class Mammal : public Animal { };      // 普通继承
class Bird   : public Animal { };      // 普通继承
class Bat : public Mammal, public Bird { };  // Bat 中有两份 age

// 虚继承 — 解决菱形继承
class Mammal : virtual public Animal { };
class Bird   : virtual public Animal { };
class Bat : public Mammal, public Bird { };  // Bat 中只有一份 age

Q: 虚继承如何解决菱形问题?

虚继承保证在最终派生类中只保留一份虚基类的成员。底层通过**虚基类指针(vbptr)**间接访问,多了一层间接性。

Q: 多继承中,两个基类有同名函数怎么办?

会产生二义性,编译器报错。解决方式:

  1. 显式指定域:obj.Base1::func()
  2. 在派生类中重写:提供一个统一入口,内部转发到具体基类
cpp
class Printer {
public:
    void print() { cout << "打印文档" << endl; }
};

class Scanner {
public:
    void print() { cout << "扫描文档" << endl; }
};

class AllInOne : public Printer, public Scanner { };

AllInOne aio;
// aio.print();                // ❌ 编译错误:二义性
aio.Printer::print();          // ✅ 显式指定
aio.Scanner::print();

// 更优雅的解决方案 —— 派生类中重写:
class AllInOneFixed : public Printer, public Scanner {
public:
    void print() { Printer::print(); }  // 统一入口
};

5. 继承 vs 组合 ​

Q: 什么时候用继承,什么时候用组合?

关系含义示例
继承 (is-a)子类是父类的一种狗是动物
组合 (has-a)一个类包含另一个类汽车有引擎
cpp
// 继承:is-a
class Dog : public Animal { };

// 组合:has-a
class Car {
    Engine engine;   // Car has an Engine
};
继承组合
耦合度高(子类依赖父类实现)低
灵活性编译时决定,不可换运行时可变
封装性破坏封装(子类可见父类 protected)保持封装

设计原则:优先使用组合,只有当确实需要多态时才用继承。


6. 成员重写(Override) ​

子类可以定义与父类同名、同参数的函数,覆盖父类版本。

cpp
class Animal {
public:
    virtual void speak() { cout << "???" << endl; }
};

class Dog : public Animal {
public:
    void speak() override { cout << "汪汪" << endl; }   // override 检查是否真正重写
};

Animal* p = new Dog();
p->speak();   // 输出 "汪汪"(动态多态)
delete p;

Animal* p = new Dog() 被称为向上转型(派生类指针 → 基类指针),是安全的隐式转换。


7. 重载 vs 重写 vs 隐藏 ​

Q: 重载 (Overload)、重写 (Override)、隐藏 (Hide) 的区别?(高频)

重载 (Overload)重写 (Override)隐藏 (Hide)
作用域同一作用域内(同一个类)基类 ↔ 派生类之间基类 ↔ 派生类之间
函数签名函数名相同,参数列表必须不同函数名、参数列表、返回类型 完全相同函数名相同,参数列表可以相同也可以不同
virtual不需要(可以是 virtual)基类函数必须是 virtual不需要(只要基类函数不是 virtual,同名就会隐藏)
绑定时机编译时(静态多态)运行时(动态多态)编译时(静态绑定)
调用方式根据参数自动选择通过基类指针/引用,运行时查 vtable只看指针/引用类型,不看来实际对象

隐藏的陷阱(重点):

cpp
class Base {
public:
    void f(int)    { cout << "Base::f(int)" << endl; }     // 非虚函数
    void f(double) { cout << "Base::f(double)" << endl; }   // 重载
};

class Derived : public Base {
public:
    void f(int) { cout << "Derived::f(int)" << endl; }      // 隐藏了 Base 的所有 f!
};

Derived d;
d.f(1);        // 输出 "Derived::f(int)"(调用自己的)
d.f(3.14);     // 输出 "Derived::f(int)"(3.14 被隐式转成 int 了!)
// d.f(3.14) 期望调 Base::f(double),结果被隐藏了!

// 解决方案:
d.Base::f(3.14);                 // 方式一:显式指定域
// 或在派生类中:using Base::f;   // 方式二:引入基类的所有 f 到当前作用域

关键区分口诀:

场景判断方法
在同一个类里,同名不同参→ 重载
在派生类里,基类函数有 virtual,签名完全相同→ 重写
在派生类里,基类函数没有 virtual,或者即便有 virtual 但签名不同→ 隐藏

高频坑:派生类中定义一个与基类同名但参数不同的函数,即便基类是 virtual,它也是隐藏而非重写!override 关键字可以帮编译器发现这类错误。


五、多态 ​

1. 多态的分类 ​

Q: 静态多态和动态多态的区别?(高频)

静态多态(编译期)动态多态(运行期)
实现方式函数重载、运算符重载、模板虚函数 + 继承
原理名字修饰虚函数表(vtable)+ 虚函数指针(vptr)
绑定时机编译时确定运行时确定
性能无额外开销,可内联多一次查表,难内联
灵活性低(编译时已定)高(运行时根据实际类型决定)

2. 动态多态的实现条件 ​

  1. 必须有继承关系
  2. 基类必须有虚函数(virtual)
  3. 派生类必须**重写(override)**基类的虚函数
  4. 必须通过基类指针或引用调用
cpp
class Animal {
public:
    virtual void speak() { cout << "动物在叫" << endl; }
};

class Dog : public Animal {
public:
    void speak() override { cout << "汪汪" << endl; }
};

class Cat : public Animal {
public:
    void speak() override { cout << "喵喵" << endl; }
};

void makeSound(Animal& a) {
    a.speak();          // 运行时才知道是 Dog 还是 Cat
}

Dog d;
Cat c;
makeSound(d);  // "汪汪"
makeSound(c);  // "喵喵"

3. 虚函数底层原理(vtable & vptr) ​

Q: 虚函数的底层实现原理?(高频)

概念说明
虚函数表 (vtable)存储该类所有虚函数地址的函数指针数组,存放在只读数据段,每个类共用一张
虚函数指针 (vptr)存放在对象实例内存中(通常是布局开头),指向该类对应的 vtable,每个对象有一个

每个多态类各有一张(基类和每个+派生类各有各的,不共用),同一个类的所有对象共用这一张

运行时调用过程(p->speak()):

  1. 通过对象内存开头的 vptr,找到该类对应的 vtable
  2. 根据函数在表中的偏移量(编译期已确定),取出函数地址
  3. 跳转到该地址执行

这就是为什么叫动态绑定——函数地址不是在编译期写死,而是运行时查表获得。


4. 为什么必须是指针或引用才能触发多态? ​

Q: 为什么值传递会丢失多态?(对象切割 / Object Slicing)


① 先分清两个"类型":静态类型 vs 动态类型 ​

类型含义谁来确定
静态类型编译器编译时从代码里看到的类型(变量声明、函数形参里写的类型)编译器,编译期
动态类型对象在内存里的真实类型,它决定对象的 vptr 指向哪张虚函数表运行时,由实际创建的对象决定

虚调用的规则翻译成人话:调 a.speak() 时,不是按"编译器看到的类型"调,而是按"这个对象实际是谁"调。


② 为什么必须留到运行时 —— 同一个调用点,可能面对不同的真实对象 ​

关键点:makeSound 只有一份编译好的代码,但它会被反复调用,每次传入的真实对象可能不同:

cpp
void makeSound(Animal& a) {
    a.speak();    // 编译器编译这一行时,只知道 a 是 Animal
}

Dog d;	// 派生类对象,当基类指针指向它的时候,该对象内部生成的虚函数指针指向的是派生类的虚函数表
Cat c;
makeSound(d);   // 第一次执行到这里:a 实际是 Dog
makeSound(c);   // 第二次执行到这里:a 实际是 Cat

编译器编译 a.speak() 时面临一个死局:

  • 编译成"调 Animal::speak"?→ 第一次调用(传 Dog)就错了,应该汪汪
  • 编译成"调 Dog::speak"?→ 第二次调用(传 Cat)就错了,应该喵喵

它怎么选都是错的——正确答案取决于运行时才出现的信息。所以编译器只能编译成:运行时读 a 指向对象的 vptr → 查表 → 再跳过去调用。这样同一份代码,第一次查 Dog 的表 → 汪汪,第二次查 Cat 的表 → 喵喵。

这就是动态绑定的含义:决定调哪个函数这件事,被推迟到了运行时,而且每次执行可能不一样。


③ 值对象为什么不需要"运行时"? ​

cpp
void makeSound(Animal a) {   // 形参是值
    a.speak();               // 编译器:这个对象就是 Animal,还有别的可能吗?
}

Animal a 是一个实实在在的 Animal 对象——无论传什么进来,都会被拷贝成一个纯 Animal。所以编译器百分百确定:这个对象就是 Animal,动态类型 == 静态类型,答案唯一且编译期已知——调 Animal::speak。

此时再"运行时查表"就是多余的:查一百次都是 Animal 的表,结果永远不会变。多态需要的"不确定性"根本不存在。

一句话总结:指针/引用 = "我知道他是员工(Animal),但不知道具体是谁,得打电话问了才知道"(编译期不确定 → 留到运行时);值对象 = "人就在我面前,就是张三(Animal),不用问"(编译期确定 → 直接调)。


④ 对象切割是怎么发生的 —— 拷贝构造 + vptr 重置 ​

值传递时实际发生了两个步骤:

第 1 步:调用基类的拷贝构造函数 → 派生类成员被"切掉"

cpp
void byValue(Animal a) { ... }   // 形参需要构造一个 Animal 对象
Dog d;
byValue(d);                      // 实际调用 Animal::Animal(const Animal&)
  • d 是 Dog,IS-A Animal;
  • 基类拷贝构造的拷贝清单只包含基类自己的成员,Dog 特有的成员根本不在拷贝清单里 → 数据层面被切掉。

第 2 步:vptr 被重置 → 多态彻底失效

  • 拷贝构造本质上仍是构造一个新对象;任何对象构造完成后,其 vptr 一定被初始化为指向自己类的 vtable。vptr 从不从源对象复制(否则一个 Animal 对象拿着 Dog 的 vptr,调 Dog::speak 去访问 Dog 特有成员就会越界踩内存);
  • 所以新对象 a 的 vptr 指向 Animal 的 vtable → a.speak() 查表 → 调 Animal::speak。

核心:切割的本质不是"编译器把 Dog 变小",而是调用了基类拷贝构造,生成了一个全新的、纯粹的基类对象——Dog 的部分从来不属于这个新对象。


⑤ 对比验证 ​

cpp
void byValue(Animal a)      { a.speak(); }   // 永远调 Animal::speak
void byRef(Animal& a)       { a.speak(); }   // 动态绑定:a 只是 d 的别名
void byPtr(Animal* a)       { a->speak(); }  // 动态绑定:a 指向 d 的原地址

Dog d;
byValue(d);     // "动物在叫" — 拷贝构造 + vptr 重置,被切割
byRef(d);       // "汪汪" — 不产生新对象,d 的 vptr 仍指向 Dog::vtable
byPtr(&d);      // "汪汪" — 同上

⑥ 回答:为什么必须是指针/引用才能触发多态? ​

答:动态多态的本质,是运行时依据对象的动态类型解析虚函数调用。虚调用只有在调用目标无法于编译期确定时,才有必要留待运行时解析;而"无法确定"的前提,是表达式所见的静态类型与其实际指向对象的动态类型可以不一致。

指针和引用本质上是间接层——变量中保存的是目标对象的地址或别名,而非对象本体,因此同一基类类型的指针/引用可以在运行时绑定到任意派生类对象,静态类型与动态类型的差异得以成立,虚调用必须通过对象内存中的虚函数指针查虚函数表确定目标,动态绑定由此发生。

反之,按值传递时,新对象由基类拷贝构造函数构造,其类型就是基类本身,与静态类型必然一致,虚调用目标编译期即可确定,不存在运行时解析的空间,多态因此无法触发。


⑦ 回答:为什么值传递会发生对象切割? ​

答:对象切割是值传递时"调用基类拷贝构造函数以构造新对象"这一过程的必然结果,体现为两个层面。

其一,数据成员层面:派生类对象作为实参传递时,通过派生关系隐式绑定到基类拷贝构造的常量引用形参;而拷贝构造的拷贝范围仅覆盖基类自身的成员,派生类独有成员不在拷贝清单之内,因此被切掉。

其二,虚函数指针层面:拷贝构造本质上仍是一次完整的对象构造,构造完成后新对象的虚函数指针必然被初始化为指向基类的虚函数表,且绝不会从源对象复制——否则基类对象持有派生类虚表指针,调用派生类虚函数时可能访问并不存在的成员,产生未定义行为。新对象的虚函数指针指向基类虚函数表,虚调用解析至基类实现,多态随之失效。因此切割的实质并非"派生类对象被缩小",而是构造出了一个类型为基类的全新对象,派生类的部分自始至终不属于该对象。


5. 纯虚函数与抽象类 ​

Q: 什么是纯虚函数?它有哪些特点?抽象类有哪些限制?(高频)

(1) 什么是纯虚函数 ​

只有声明、没有实现(通常)的虚函数,写法是在声明末尾加 = 0:

cpp
virtual double area() = 0;   // 纯虚函数

它的作用:只定义"接口",不提供实现,强制所有派生类必须自己实现——从编译期就保证"所有派生类都会做这件事",至于怎么做,由各派生类决定。

(2) 纯虚函数的特点 ​

特点说明
声明格式virtual 返回类型 函数名(参数) = 0;
函数体通常不写;但允许定义函数体(有默认实现的纯虚函数,见考点一)
对类的影响包含纯虚函数的类自动变成抽象类
实例化抽象类不能实例化(不能 new、不能定义栈对象、不能按值传参、不能声明对象数组)
派生类的义务派生类必须实现全部纯虚函数,否则派生类自己也是抽象类,也不能实例化
调用方式不能通过抽象类对象调用;但派生类内部可以显式调用基类版本 Shape::area()

(3) 抽象类 ​

定义:包含至少一个纯虚函数的类。

限制 / 能力说明
不能实例化Shape s; / new Shape() / void f(Shape s) / Shape arr[10] 全部编译失败
指针/引用可以Shape* p = new Circle; ✅ —— 这正是多态的入口
可以有成员变量✅ 抽象类可以有数据成员、普通成员函数
可以有构造函数✅ 虽然不能实例化,但派生类构造时必须先调用基类构造(构造基类部分)
析构必须虚✅ 它必然被继承,按多态准则析构必须 virtual
cpp
class Shape {                          // 抽象类
protected:
    double scale;                      // ✅ 可以有成员变量
public:
    Shape(double s = 1.0) : scale(s) {}              // ✅ 可以有构造函数(派生类构造时调用)
    virtual double area() = 0;         // 纯虚函数:只定接口
    virtual ~Shape() {}                // 虚析构:必然被继承,必须虚
};

class Circle : public Shape {
    double r;
public:
    Circle(double rr, double s) : Shape(s), r(rr) {}
    double area() override { return 3.14 * r * r * scale; }   // 必须实现
};

Shape* p = new Circle(1.0, 2.0);       // ✅ 指针/引用可以,实例化的是 Circle
p->area();                             // 多态

(4) 虚函数 vs 纯虚函数(对比记忆) ​

对比项虚函数 virtual f()纯虚函数 virtual f() = 0
实现必须提供通常不提供(也可以有)
所属类普通类抽象类
能否实例化✅ 能❌ 不能
派生类可重写,也可不重写必须实现,否则还是抽象类
设计意图提供默认行为,允许扩展定义接口,强制实现

(5) 两个高频考点 ​

考点一:纯虚函数可以有函数体(默认实现)

cpp
class Shape {
public:
    virtual void print() = 0 {   // ✅ 合法!纯虚 + 默认实现
        cout << "Shape" << endl;
    }
};
class Circle : public Shape {
public:
    void print() override {      // ⚠️ 依然必须重写(不写,Circle 就还是抽象类)
        Shape::print();          // ✅ 但可以显式调用基类的默认版本
        cout << "Circle" << endl;
    }
};

考点二:纯虚析构函数必须提供实现

cpp
class Shape {
public:
    virtual ~Shape() = 0;   // 纯虚析构
};
Shape::~Shape() {}           // ⚠️ 必须在类外提供实现,否则链接错误!

原因:析构时派生类析构后一定会调用基类析构。纯虚析构若无实现,链接阶段找不到 Shape::~Shape() 的地址 → 链接错误(编译阶段能通过)。

想强制抽象、又没有合适函数可设纯虚时,就把析构设为纯虚——但记得给实现。

(6) 为什么需要纯虚函数 / 抽象类? ​

  1. 定义统一接口:所有派生类"必须会做这些事",编译期强制保证(漏实现直接编译失败,而不是运行期才发现)
  2. 防止实例化语义不完整的对象:抽象的"Shape"没有具体形态,实例化没有意义——只有具体形状才有面积
  3. 配合多态:抽象类作为基类指针/引用的类型,实现"接口统一、行为多样"
  4. C++ 没有 interface 关键字,全部纯虚函数 + 纯虚析构的抽象类,就扮演了"接口类"的角色(类似 Java 的 interface)

6. override 与 final ​

Q: override 和 final 的作用?

关键字修饰对象作用
override虚函数强制编译器检查是否真正重写了基类虚函数,防止拼写/签名错误
final类禁止该类被继承
final虚函数禁止该函数在派生类中被进一步重写
cpp
class Base {
public:
    virtual void f(int) {}
    virtual void g() {}
};

class Derived : public Base {
public:
    void f(int) override {}    // ✅ 正确重写
    // void f(long) override {} // ❌ 编译错误:签名不匹配,没有重写基类函数
    void g() final {}          // 禁止后续派生类再重写 g
};

class More : public Derived {
    // void g() override {}    // ❌ 编译错误:g 被 final 禁止重写
};

7. 虚函数与构造函数/析构函数总结 ​

问题结论原因
构造函数中调用虚函数?不会多态,调用当前类版本构造时 vptr 尚未指向派生类 vtable
析构函数中调用虚函数?不会多态,调用当前类版本析构时派生类已销毁,vptr 已回退
析构函数必须是 virtual?是(只要类会被继承)防止 delete 基类指针时不调派生类析构

8. 多态的代价 ​

代价类型具体影响
空间每个对象多一个 vptr(8 字节),每个类多一张 vtable
时间一次间接寻址(查表);破坏内联优化;可能导致分支预测失败/指令缓存失效

9. 为什么虚函数不能是模板? ​

Q: 为什么虚函数不能是模板?

  • vtable 大小必须在编译类时(编译前期)确定
  • 模板函数只有被调用时(编译中后期)才实例化,编译器无法预知会有多少个不同的模板实例
  • 两者冲突 → C++ 标准禁止虚函数模板
  • 变通方案:类型擦除(如 std::function、std::any)

9.1 实战:类型擦除模式 —— Any 类三层架构 ​

Q: 虚函数不能是模板,但又要让基类接口支持任意返回值类型,怎么办?

这是线程池项目中的真实问题:Task 基类用虚函数定义接口,但每个任务的返回值类型不同(int、string 等)。由于虚函数不能是模板(virtual T run() = 0 非法),需要一种方式统合"多态"和"泛型"。

方案:三层架构(类型擦除)

┌──────────────────────────────────────┐
│  Any 类(外壳 / 统一接口)── 非模板   │  ← 对外统一类型
│  std::unique_ptr<Base> base_;        │
└──────────────┬───────────────────────┘
               │ 持有
┌──────────────▼───────────────────────┐
│  Base 类(抽象接口 / 协议)── 非模板  │  ← 定义虚函数接口
│  virtual ~Base() {}                  │
└──────────────┬───────────────────────┘
               │ 继承
┌──────────────▼───────────────────────┐
│  Derive<T> 类(具体容器)── 模板类    │  ← 真正存储数据
│  T data_;                            │
└──────────────────────────────────────┘

逐层职责:

层级是否模板职责
Any(顶层)❌ 非模板对外统一接口。无论存什么类型都显示为 Any。内部持有 Base* 指针
Base(中间层)❌ 非模板抽象基类,定义虚函数接口。虚表大小固定,为 Any 提供操作异构数据的可能
Derive<T>(底层)✅ 模板真正的数据仓库。用户存 int → 实例化 Derive<int>;存 string → 实例化 Derive<string>

设计要点:

  1. Any 不能是模板:否则 Any<int> 和 Any<string> 是不同类型,无法放进同一个容器或作为统一返回值
  2. Base 提供统一指针类型:Base* 可以指向任何 Derive<T>,是类型擦除的关键
  3. Derive<T> 记住原始类型:数据存取时通过 dynamic_cast<Derive<T>*>(base_) 还原
cpp
// 存储:将 int 包进 Any
Any a;
// 内部:创建 Derive<int>,用 Base* 指向它

// 取出:从 Any 还原为 int
template<typename T>
T cast_() {
    Derive<T>* pd = dynamic_cast<Derive<T>*>(base_.get());
    if (pd == nullptr) throw "type mismatch!";
    return pd->data_;
}
int val = a.cast_<int>();   // 运行时类型检查

核心思想:Base(非模板)对外统一身份,Derive<T>(模板)对内记住类型。这就是 std::any / std::function 等标准库组件的底层实现原理。


10. RTTI —— 运行时类型信息 ​

Q: 什么是 RTTI?typeid 和 dynamic_cast 的用法?(高频)

RTTI(Run-Time Type Information)允许程序在运行时获取对象的实际类型信息。C++ 提供了两个核心运算符:

运算符作用失败行为
typeid获取对象的 type_info(包含类型名)—
dynamic_cast多态类型间的安全向下转型指针失败返回 nullptr,引用失败抛 std::bad_cast

dynamic_cast 使用条件:

  1. 基类必须有虚函数(即类必须是多态类型)
  2. 用于将基类指针/引用安全地转换为派生类指针/引用
cpp
class Animal {
public:
    virtual ~Animal() {}    // 必须有多态(至少一个虚函数)
};

class Dog : public Animal {
public:
    void bark() { cout << "汪汪" << endl; }
};

class Cat : public Animal { };

// ---- typeid ----
Animal* p = new Dog();
cout << typeid(*p).name();   // 输出实际类型(如 "class Dog")
// 注意:typeid(p) 返回的是 Animal*,需要 typeid(*p) 才是实际对象类型

// ---- dynamic_cast 指针版本 ----
Dog* dp = dynamic_cast<Dog*>(p);
if (dp) {
    dp->bark();              // 安全!确认是 Dog
}
Cat* cp = dynamic_cast<Cat*>(p);
if (cp == nullptr) {
    cout << "不是 Cat" << endl;
}

// ---- dynamic_cast 引用版本 ----
try {
    Cat& c = dynamic_cast<Cat&>(*p);   // p 实际是 Dog,转换失败抛异常
} catch (std::bad_cast& e) {
    cout << "转换失败!" << endl;
}

static_cast vs dynamic_cast 区别:

  • static_cast<Derived*>(base):编译时检查,不保证安全(可能转出一个错误类型)
  • dynamic_cast<Derived*>(base):运行时检查,安全但有一定开销

11. 多态实战:线程池任务系统设计 ​

Q: 线程池如何用多态实现"接口统一、行为多样"?

这是线程池项目中的真实设计——线程池不知道任务具体做什么,只定义一套统一接口。

(1) 任务基类设计 ​

cpp
// Task 基类:定义统一接口
class Task {
public:
    virtual Any run() = 0;    // 纯虚函数,子类必须实现
    virtual ~Task() {}        // 虚析构(关键!)
};

// 用户自定义任务:继承 + 重写
class MyTask : public Task {
    int a_, b_;
public:
    MyTask(int a, int b) : a_(a), b_(b) {}
    Any run() override {
        return a_ + b_;       // 返回任意类型结果
    }
};

(2) 为什么任务队列必须用指针? ​

cpp
std::queue<std::shared_ptr<Task>> taskQue_;   // ✅ 指针
// std::queue<Task> taskQue_;                 // ❌ 值类型——两个致命问题

问题一:抽象类不能实例化Task 含纯虚函数,无法创建 Task 对象 → std::queue<Task> 编译失败。

问题二:对象切割(Object Slicing) 即使 Task 不是纯虚类,queue<Task> 存值对象时——派生类对象被强制转为基类,派生类独有成员被切掉,vptr 指向基类虚表,多态彻底失效。

cpp
// 指针方案:完整保留派生类内存布局
MyTask t(1, 100);
std::shared_ptr<Task> p = std::make_shared<MyTask>(t);
// p 指向堆上的完整 MyTask 对象,vptr 仍指向 MyTask 的虚表
// 工作线程通过 p->run() → 查表 → 正确调用 MyTask::run()

(3) 智能指针选择:为什么是 shared_ptr? ​

方案问题
裸指针 Task*所有权不清:谁负责 delete?用户还是线程池?
unique_ptr<Task>不可拷贝,只能移动——进入队列后外部无法再引用
shared_ptr<Task>引用计数自动管理:队列持有 + 外部持有,最后一个释放者自动销毁

异步安全性:即使用户提交任务后代码块结束(局部变量销毁),只要 queue 还持有 shared_ptr,任务对象就不会被析构。

(4) 设计要点总结 ​

设计决策原因
基类 Task 含纯虚函数 run()定义统一接口,强制子类实现
基类析构函数为 virtual确保 delete 基类指针时正确调用子类析构
任务队列存指针而非对象避免对象切割,保持多态能力
使用 shared_ptr 管理生命周期引用计数自动回收,支持异步场景
返回值用 Any 类型擦除绕过"虚函数不能是模板"的限制

六、拷贝控制与资源管理 ​

1. 深拷贝与浅拷贝 ​

Q: 深拷贝和浅拷贝的区别?(高频)

浅拷贝 (Shallow Copy) ​

浅拷贝会把对象的所有字段都复制一遍。

  • 如果是基本类型(如 int, float):直接复制具体的值。
  • 如果是指针/引用类型:它把指针本身(内存地址)也复制过来。

结果:新旧两个对象里的指针都指向同一块内存地址。如果你通过其中一个对象修改了指针指向的数据,另一个对象的数据也会跟着变。

深拷贝 (Deep Copy) ​

深拷贝会为指针指向的内容开辟一块全新的内存空间,并将原内容递归地复制过去。(保证指向的数据一致,但是指向的空间不同)

  • 如果是基本类型:直接复制值(与浅拷贝一致)。
  • 如果是指针/引用类型:
    • 在内存(堆)中申请一块新的空间。
    • 把原指针指向的内容“克隆”到新空间。
    • 新对象的指针指向这块新空间。

结果:新旧对象在内存中是完全独立的。修改新对象的内容,绝不会影响原对象。

cpp
#include <iostream>
#include <cstring>

class String {
    char* data;
public:
    // 构造函数
    String(const char* s = "") {
        data = new char[strlen(s) + 1];
        strcpy(data, s);
    }
    // 1. 深拷贝构造
    // 特点:分配新内存,复制内容。两个对象拥有独立的内存空间。
    String(const String& other) {
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }
    // 2. 浅拷贝构造
    // 特点:直接复制指针地址。两个对象指向同一块内存。
    // 注意:在实际开发中,如果类内有指针成员,通常严禁直接使用浅拷贝。
    String(const String& other) {
        data = other.data;
    }
};

在 C++ 中,浅拷贝是指仅拷贝对象中的数据成员的值。对于指针成员,它只拷贝指针存储的地址,而不拷贝指针指向的实际数据。

如果不写拷贝构造函数,编译器会自动生成一个默认的拷贝构造函数。这个默认的构造函数执行的就是浅拷贝

如果类需要析构函数来释放内存,那么它几乎肯定也需要拷贝构造函数和拷贝赋值运算符来进行深拷贝。

在 C++11 之后,为了兼顾性能和安全,通常还会提供移动构造函数,它可以“夺取”临时对象的内存所有权,既避开了深拷贝的开销,又避开了浅拷贝的风险。


2. 移动语义 ​

Q: 移动语义解决了什么问题?

核心思想:"窃取"而非"复制"。将资源的所有权从一个对象转移到另一个对象。

概念说明
右值引用 &&标识**"临时对象"或"即将销毁的对象"**
std::move将左值强制转换为右值引用(本身不移动任何东西)
移动构造/赋值将原对象的指针直接赋给新对象,然后将原对象的指针置为 nullptr
cpp
class Buffer {
    char* data;
    size_t size;
public:
    // 移动构造
    Buffer(Buffer&& other) noexcept  // noexcept(C++11)保证不会抛出任何异常,如果有错误直接崩溃。
        : data(other.data), size(other.size)
    {
        other.data = nullptr;   // 原对象置空
        other.size = 0;
    }
};
拷贝移动
代价O(N)(逐字节复制)O(1)(只赋值指针)
原对象状态不变资源被"窃取",通常置空

3. 赋值操作符重载 ​

Q: 实现 operator= 需要注意什么?

传统写法三步:

  1. 自赋值检查:if (this == &other) return *this;
  2. 释放旧资源:delete 原有数据
  3. 深拷贝新资源:new + 复制
  4. 返回 *this:支持链式赋值 a = b = c

现代 Copy-and-Swap 写法:

cpp
class Buffer {
    char* data;
public:
    Buffer(const Buffer& other) { /* 深拷贝 */ }

    friend void swap(Buffer& a, Buffer& b) {
        using std::swap;
        swap(a.data, b.data);
    }

    // 值传递自动触发拷贝构造,产生临时对象 tmp
    Buffer& operator=(Buffer tmp) {
        swap(*this, tmp);     // 与 tmp 交换
        return *this;         // tmp 离开作用域,自动析构,带走旧资源
    }
};

Copy-and-Swap 是异常安全的:如果拷贝构造时分配失败抛异常,原对象不受影响。


4. RAII(资源获取即初始化) ​

Q: 什么是 RAII?为什么重要?(高频)

(1) 一句话定义 ​

RAII(Resource Acquisition Is Initialization,资源获取即初始化):把资源的获取放进构造函数,把资源的释放放进析构函数,让资源的生命周期与局部对象的生命周期绑定——对象构造完成,资源到手;对象销毁,资源自动释放。

名字的含义:C++ 对象在初始化阶段(构造)建立,而 RAII 把"获取资源"这个动作也放在初始化阶段完成,所以叫"资源获取即初始化"。

cpp
void func() {
    std::ifstream file("data.txt");  // 构造:打开文件(获取资源)
    // ... 使用文件 ...
}   // 离开作用域:析构自动关闭文件(释放资源)

(2) 它解决了什么问题 —— 对比手动管理 ​

传统 C 风格手动管理资源的三大痛点:

痛点示例后果
忘记释放忘了 delete / close内存 / 文件描述符泄漏
异常路径泄漏new 之后、delete 之前抛异常释放代码永远执行不到 → 泄漏
释放时机错误提前释放、重复释放悬空指针 / double free 崩溃
cpp
// ❌ 手动管理:任何一个提前 return 或异常,都会泄漏
void old_style() {
    File* f = open("data.txt");
    if (!process(f)) return;   // 提前返回 → 泄漏
    close(f);
}

// ✅ RAII:没有一行手动释放代码,也不可能泄漏
void raii_style() {
    std::ifstream f("data.txt");   // 构造:打开
    process(f);
}   // 无论正常返回还是抛异常,析构都会执行

(3) 为什么它"一定"可靠 —— 底层原理 ​

C++ 语言层面保证的机制:

  1. 局部对象离开作用域时析构函数必定被调用——无论是正常 return、提前 return,还是异常导致的栈展开(stack unwinding);
  2. 析构调用由编译器自动插入,程序员不可能忘记;
  3. 于是构造时获取、析构时释放,任何执行路径都不泄漏。

RAII 与手动释放的本质区别:可靠不是靠程序员自律,而是靠语言机制强制。 这正是 C++ 异常安全的基石。

(4) RAII 类的三要素 ​

要素要求
构造即获取构造函数中申请资源(new / open / lock)
析构即释放析构函数中释放资源(delete / close / unlock)
禁止拷贝资源只能有一个持有者;拷贝会造成 double free → 通常 delete 拷贝,或用移动语义转移所有权

(5) 手写示例:锁守卫(最经典的 RAII) ​

cpp
class MutexLock {
    std::mutex& mtx;
public:
    explicit MutexLock(std::mutex& m) : mtx(m) { mtx.lock(); }   // 构造:获取锁
    ~MutexLock() { mtx.unlock(); }                               // 析构:释放锁

    MutexLock(const MutexLock&) = delete;            // 禁止拷贝
    MutexLock& operator=(const MutexLock&) = delete;
};

std::mutex m;
void func() {
    MutexLock guard(m);   // 构造:加锁
    // ... 临界区,中途抛异常也不会死锁 ...
}   // 析构:自动解锁

(6) 标准库中的 RAII 典型实现 ​

资源RAII 封装
堆内存std::unique_ptr / std::shared_ptr(string / vector 等容器也是)
互斥锁std::lock_guard / std::unique_lock / std::scoped_lock
文件std::ifstream / std::ofstream
网络连接asio::tcp::socket 等(析构时自动关闭 socket)

(7) RAII 的边界(加分项) ​

  • 循环引用:两个 shared_ptr 互相指向时引用计数永不归零,资源无法释放 → 需要 weak_ptr 打破环。这也是"有了 RAII,为什么还需要 GC"这个问题的答案——GC 只在极复杂的对象图中才有意义,实际 C++ 工程很少需要
  • RAII 擅长生命周期确定的资源;对生命周期不确定的资源,要配合智能指针等组合方案管理

5. Rule of Three / Five / Zero ​

Q: 什么是 Rule of Three / Five / Zero?(高频)

(1) Rule of Three(C++98) ​

如果一个类需要自定义析构函数,那么它几乎肯定也需要自定义拷贝构造函数和拷贝赋值运算符。

  1. 析构函数里写了 delete $\rightarrow$ 说明类中持有堆内存指针(或其它系统资源)。
  2. 默认拷贝构造/赋值是“浅拷贝” $\rightarrow$ 只复制指针地址。
  3. 结果:两个对象的指针指向同一块内存。
  4. 后果:
    • Double Free:两个对象析构时,会对同一个地址 delete 两次,程序崩溃。
    • 悬空指针:一个对象改了数据或释放了内存,另一个对象完全不知情。

(2) Rule of Five(含移动语义) ​

把 Rule of Three 扩展到 5 个:析构函数、拷贝构造、拷贝赋值、移动构造、移动赋值。

编译器自动生成规则:

如果你显式定义了编译器仍会自动生成编译器不再自动生成
析构函数拷贝函数移动函数
拷贝构造/赋值—移动函数
移动构造/赋值—拷贝函数(被 delete)

结论:一旦涉及资源管理,手动接管其中一个,就必须接管全部五个。

(3) 三种所有权模式 ​

模式适用场景做法
独占所有权unique_ptr、MutexLock、Socketdelete 拷贝,default 移动
深度拷贝MyString、MyVector、Buffer手写深拷贝 + Copy-and-Swap
共享所有权引用计数资源用 std::shared_ptr,退回 Rule of Zero
cpp
// 独占所有权模式示例
class UniqueResource {
public:
    UniqueResource() = default;
    ~UniqueResource() { /* 释放 */ }

    UniqueResource(const UniqueResource&) = delete;            // 禁止拷贝
    UniqueResource& operator=(const UniqueResource&) = delete;

    UniqueResource(UniqueResource&&) = default;                // 允许移动
    UniqueResource& operator=(UniqueResource&&) = default;
};

(4) Rule of Zero(现代 C++ 目标) ​

如果类的所有成员都懂得如何"自我管理"(如 std::string、std::vector、std::unique_ptr),那么类本身就不需要显式定义任何大五函数。

cpp
// 无需手写任何资源管理函数
class Person {
    std::string name;
    std::vector<int> scores;
public:
    Person(std::string n) : name(std::move(n)) {}
    // 编译器自动生成:析构、拷贝、移动 —— 全部正确
};

(5) 什么时候不能用 Rule of Zero? ​

  1. 基类有虚函数:必须写 virtual ~Base() = default;(否则 delete 基类指针不会调派生类析构)
  2. 直接管理底层资源(如 epoll 的 int fd):编译器不知道 int 是句柄,需手写 RAII

从 Rule of Five 回归 Rule of Zero:把原始资源封装成独立的 RAII 小类,业务类即可回归 Zero。

(6) 实战:线程池的"四个禁止" ​

Q: 为什么 ThreadPool 类需要同时禁止拷贝和移动?

线程池项目中的 ThreadPool 类同时禁用了拷贝构造、拷贝赋值、移动构造、移动赋值:

cpp
class ThreadPool {
public:
    ThreadPool(const ThreadPool&) = delete;            // 禁止拷贝
    ThreadPool& operator=(const ThreadPool&) = delete;
    ThreadPool(ThreadPool&&) = delete;                 // 禁止移动
    ThreadPool& operator=(ThreadPool&&) = delete;
};

为什么连移动也要禁止?

操作为什么不行
拷贝OS 线程无法克隆;std::mutex 本身不可拷贝;两个线程池指向同一组线程 → 双重析构崩溃
移动线程函数中通过 std::bind 绑定了 this 指针,移动后旧地址失效 → 子线程访问野指针崩溃

核心原因:线程池内部的线程函数绑定了 this(std::bind(&ThreadPool::threadFunc, this))。如果线程池对象被移动,this 指针指向的旧地址变为未定义状态,但正在运行的子线程仍然通过旧 this 访问任务队列 → 非法内存访问,程序崩溃。

设计原则:管理 OS 线程、互斥锁、条件变量等不可拷贝资源的类,应显式 = delete 拷贝和移动,明确表达"独一无二的管理者"语义。


七、内存布局 ​

1. 内存对齐 ​

Q: 什么是内存对齐?为什么需要?(高频)

对齐:数据成员的起始地址必须是其大小的整数倍。

为什么? CPU 按"块"(4 或 8 字节)读取内存。如果数据跨两个块,CPU 要读两次再拼接,效率极低。对齐保证一次读取。

对齐规则:

  1. 成员偏移量必须是 min(成员大小, 对齐系数) 的整数倍
  2. 类总大小必须是最大成员大小的整数倍(保证数组成员也对齐)
cpp
// 糟糕的布局 — sizeof = 24
class Bad {
    char a;         // 1字节,填充7字节
    double b;       // 8字节
    int c;          // 4字节,填充4字节
};

// 优化后的布局 — sizeof = 16
class Good {
    double b;       // 8字节
    int c;          // 4字节
    char a;         // 1字节,填充3字节
};

减小填充的技巧:按成员大小从大到小排列。


2. 类大小计算综合 ​

Q: 有虚函数的类、多继承的类 sizeof 怎么算?(笔试题高频)

类的大小由以下几部分累加,并最终满足对齐规则:

组成部分说明何时存在
非静态成员变量含各基类的成员总是
vptr(虚函数表指针)8 字节(64位)/ 4 字节(32位)类有虚函数
vbptr(虚基类表指针)8 字节(64位)虚继承
Padding对齐填充总是可能
cpp
// 场景一:单继承 + 虚函数
class Base {
    int x;                          // 4 字节
    virtual void f() {}             // 有虚函数 → 有 vptr
};
// sizeof(Base) = 16
// 布局:vptr(8) + int(4) + padding(4) = 16

// 场景二:普通多继承(两个基类都有虚函数)
class A {
    int a;
    virtual void fa() {}
};  // sizeof(A) = 16  (vptr=8 + int=4 + pad=4)

class B {
    int b;
    virtual void fb() {}
};  // sizeof(B) = 16

class C : public A, public B {
    int c;
    void fa() override {}
    void fb() override {}
};
// sizeof(C) = 40
// 布局:A::vptr(8) + a(4) + pad(4) + B::vptr(8) + b(4) + pad(4) + c(4) + pad(4) = 40
// 关键:多继承时,有几个基类就有几个 vptr!

// 场景三:虚继承
class Base {
    int x;
    virtual void f() {}
};  // sizeof = 16

class Derived : virtual public Base {
    int y;
};
// sizeof(Derived) = 32(64位)
// 布局:vbptr(8) + y(4) + pad(4) + vptr(8) + x(4) + pad(4) = 32
// 关键:虚继承引入了 vbptr,子类的 vptr 和 vbptr 都存在

总结口诀:

  • 普通类 = 成员 + padding
  • 有虚函数 = 成员 + vptr + padding
  • 多继承 = 成员 + N × vptr + padding
  • 虚继承 = 成员 + vptr + vbptr + padding