C++进阶（5万字解析，超详细！！!）

目录

1 语言基础

1.1 基础数据类型范围与精度

2.2 作用域与生命周期

作用域

生命周期

2.3 const的全面用法

2 指针与引用

2.1 内存布局

2.2 指针与引用的本质区别及使用场景

2.3 理解空指针与野指针

3 面向对象与设计模式

3.1 OOP：封装、继承、多态（虚函数表原理）

虚函数表

3.2 设计模式：单例、工厂、观察者

单例模式

工厂模式

观察者模式

4 资源管理与RALL

4.1 智能指针

shared_ptr（共享）

unique_ptr（独占）

weak_ptr（防循环引用）

循环引用问题

4.2 RALL原则

5 STL与泛型编程

5.1 容器

vector

map/unordered_map

list

5.2 算法

sort

find

remove_if

5.3 lambda：结合STL算法使用

6 现代c++常用特性

6.1 auto类型推导

6.2 范围for循环

6.3 constexpr编译期计算

7 拷贝/移动语义

7.1 深拷贝 vs 浅拷贝

7.2 右值引用与move

7.3 移动构造函数

8 异常安全与设计模式

8.1 try_catch正确用法（不滥用）

8.2 noexcept关键字

8.3 接口设计原则（Pimpl模式隐藏细节）

9 并发与内存模型

9.1 thread与async

9.2 互斥锁

9.3 死锁预防

9.4 原子操作

9.4.1 内存顺序

9.4.2 比较交换（CAS）

---

1 语言基础

1.1 基础数据类型范围与精度

整数类型

有符号整数

类型	字节大小	范围	说明
char	1	-128 ~ 127	可能等价于signed char
signed char	1	-128 ~ 127
short	2	-32,768 ~ 32,767
int	4(通常)	-2,147,483,648 ~ 2,147,483,647	至少2字节，平台相关
long	4或8	-2³¹ ~ 2³¹-1 或 -2⁶³ ~ 2⁶³-1	平台相关
long long	8	-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807	C++11引入

无符号整数

类型	字节大小	范围	说明
unsigned char	1	0 ~ 255
unsigned short	2	0 ~ 65,535
unsigned int	4(通常)	0 ~ 4,294,967,295
unsigned long	4或8	0 ~ 2³²-1 或 0 ~ 2⁶⁴-1
unsigned long long	8	0 ~ 18,446,744,073,709,551,615

浮点类型

类型	字节大小	精度(小数位)	范围(绝对值)	说明
float	4	6-7位	1.2e-38 ~ 3.4e38	单精度
double	8	15-16位	2.3e-308 ~ 1.7e308	双精度
long double	8,12,16	18-19位以上	更大范围	平台相关

布尔与字符类型

类型	字节大小	范围/值	说明
bool	1(通常)	true 或 false	理论上1位，但占用1字节
char	1	-128~127 或 0~255	可能是有符号或无符号
wchar_t	2或4	0~65,535 或 更大	宽字符
char16_t	2	0~65,535	UTF-16字符(C++11)
char32_t	4	0~4,294,967,295	UTF-32字符(C++11)

2.2 作用域与生命周期

作用域

作用域是指程序中标识符（如变量、函数、类型等）的可见区域。在C++中，主要有以下几种作用域：

1. 局部作用域（块作用域）

• 在函数内部或一个代码块（由花括号{}包围）内声明的标识符具有局部作用域。

• 它们只在声明它们的块内可见，包括该块内的嵌套块。

• 例如，在函数内部定义的变量，只能在函数内部访问。

1. void func()
2. {
3. int x = 10; // 局部变量，作用域开始
4. {
5. int y = 20; // 在这个内层块中声明，只在这个内层块中可见
6. cout << x << endl; // 可以访问x
7. }
8. // cout << y << endl; // 错误，y在这里不可见
9. } // x的作用域结束

复制代码

2. 函数作用域

• 实际上，C++中只有标号（如goto语句使用的标号）具有函数作用域。标号在函数内部声明，可以在函数内的任何位置使用（即使在声明之前），但只能在同一函数内使用。

1. void func()
2. {
3. start: // 标签在整个函数内可见
4. // ...
5. goto start;
6. }

复制代码

3. 函数原型作用域

• 在函数原型中声明的参数名具有函数原型作用域。这些名字只在函数原型中可见，通常只是为了可读性，编译器会忽略它们。

1. void func(int x, int y); // x和y的作用域仅限于此原型，在函数定义中可以使用不同的名字

复制代码

4. 文件作用域（全局作用域）

• 在所有函数和类之外声明的标识符具有文件作用域，也称为全局作用域。

• 它们从声明点开始，直到文件末尾都可见，并且可以被同一文件中的其他函数访问。

• 如果使用extern关键字进行声明，则可以在多个文件之间共享。

1. int globalVar = 100; // 全局变量，文件作用域
3. void func1()
4. {
5. globalVar = 200; // 可以访问全局变量
6. }
8. int main()
9. {
10. cout << globalVar << endl; // 输出200（如果func1被调用过）
11. return 0;
12. }

复制代码

5. 类作用域

• 在类中定义的成员（数据成员和成员函数）具有类作用域。

• 类的成员在类的所有成员函数中都是可见的，但是通过对象、引用、指针或作用域解析运算符来访问

1. class MyClass
2. {
3. private:
4. int data; // 类作用域
5. public:
6. void setData(int d)
7. {
8. data = d; // 在成员函数中可以直接访问类的成员
9. }
10. };
12. int main()
13. {
14. MyClass obj;
15. // cout << data; // 错误，不能直接访问类成员
16. obj.setData(10); // 通过对象调用成员函数
17. return 0;
18. }

复制代码

6. 命名空间作用域

• 定义在命名空间内的标识符具有命名空间作用域。

• 它们从声明点开始，直到命名空间结束都可见。

• 可以通过using声明或using指令引入到当前作用域，或者通过命名空间名和作用域解析运算符来访问。

1. namespace MyNamespace
2. {
3. int value = 42;
4. }
6. int main()
7. {
8. cout << MyNamespace::value << endl; // 通过命名空间访问
9. using MyNamespace::value;
10. cout << value << endl; // 可以直接访问
11. return 0;
12. }

复制代码

生命周期

生命周期是指标识符（特别是变量和对象）存在的时间段，即从创建到销毁的时间。生命周期与存储类别密切相关。

1. 自动生命周期（局部变量）

• 在函数内部或块内声明的局部变量（包括函数参数）具有自动生命周期。

• 它们在声明时创建（进入块时），在块结束时销毁。

• 通常存储在栈上。

1. void func()
2. {
3. int x = 5; // 生命周期开始
4. // 使用x
5. } // 生命周期结束，x被销毁

复制代码

2. 静态生命周期

• 全局变量、静态局部变量和静态成员变量具有静态生命周期。

• 它们在程序开始执行时创建（或第一次使用时，取决于具体实现），在程序结束时销毁。

• 存储在静态存储区。

1. int globalVar; // 静态生命周期，程序开始时创建，程序结束时销毁
3. void func()
4. {
5. static int count = 0; // 静态局部变量，第一次进入函数时创建，程序结束时销毁
6. count++;
7. }
9. class MyClass
10. {
11. static int staticVar; // 静态成员变量，具有静态生命周期
12. };

复制代码

3. 动态生命周期

• 通过new运算符动态分配的内存具有动态生命周期。

• 它们在new时创建，直到通过delete显式释放时才销毁。

• 存储在堆上。

1. int main()
2. {
3. int* p = new int(10); // 动态生命周期开始
4. // 使用p
5. delete p; // 动态生命周期结束，释放内存
6. return 0;
7. }

复制代码

4. 线程局部生命周期

• 使用thread_local关键字声明的变量具有线程局部生命周期。

• 每个线程都有该变量的独立实例，线程开始时创建，线程结束时销毁。

1. thread_local int tlsVar = 0; // 每个线程都有自己的tlsVar

复制代码

2.3 const的全面用法

定义常量变量

使用 const 定义常量变量，必须在定义时初始化，且之后不能修改。

1. const int a = 10;
2. a = 20; // 错误：不能修改常量

复制代码

指针与const

指向常量的指针：指针指向的内容是常量，不能通过指针修改内容，但指针本身可以指向其他地址。

1. const int* p; // 或者 int const* p;
2. int b = 5;
3. p = &b;
4. *p = 10; // 错误：不能通过p修改b的值

复制代码

常量指针：指针本身是常量，初始化后不能指向其他地址，但可以通过指针修改所指向的内容（除非指向的是常量）。

1. int* const p = &b;
2. *p = 20; // 正确：可以修改b的值
3. int c = 30;
4. p = &c; // 错误：不能修改指针的指向

复制代码

指向常量的常量指针：指针本身和指向的内容都是常量。

1. const int* const p = &b;
2. // *p = 30; // 错误：不能修改指向的内容
3. // p = &c; // 错误：不能修改指针的指向

复制代码

函数与const

常量参数：函数参数使用 const，表示在函数内部不会修改该参数。通常用于指针或引用参数，以保护原始数据。

1. void func(const int* p)
2. {
3. // *p = 10; // 错误：不能修改
4. }

复制代码

常量引用：常量引用常用于函数参数，避免拷贝，同时不允许修改原始数据。

1. void func2(const int& x)
2. {
3. // x = 10; // 错误：不能修改
4. }

复制代码

常量成员函数：在成员函数后加 const，表示该函数不会修改类的成员变量（除非成员变量被声明为 mutable）。

1. class MyClass
2. {
3. int value;
4. public:
5. int getValue() const
6. {
7. // value = 10; // 错误：不能修改成员变量
8. return value;
9. }
10. };

复制代码

常量返回值：函数返回常量值，通常用于返回指针或引用，防止返回值被修改。

1. const int& getRef(const int& a)
2. {
3. return a;
4. }
5. // 调用
6. int x = 5;
7. const int& y = getRef(x);
8. // y = 10; // 错误：不能通过y修改

复制代码

类与const

常量成员变量：类的常量成员变量必须在构造函数的初始化列表中初始化。

1. class MyClass
2. {
3. const int constMember;
4. public:
5. MyClass(int val) : constMember(val) {}
6. };

复制代码

常量对象：常量对象只能调用常量成员函数。

1. const MyClass obj(10);
2. // obj.getValue(); // 正确，getValue是常量成员函数
3. // 如果有一个非常量成员函数，则常量对象不能调用

复制代码

修饰函数参数中的指针或引用：如上所述，可以防止函数内部修改指针或引用所指向的数据。

在类型转换中的使用：const_cast 可以用于去除常量性，但必须谨慎使用，因为修改原本是常量的对象会导致未定义行为。

1. const int a = 10;
2. int* p = const_cast<int*>(&a);
3. *p = 20; // 未定义行为，因为a原本是常量

复制代码

与#define宏常量的区别

• const 有类型检查，更安全。

• const 常量在编译时确定，可以调试。

• #define 是文本替换，无类型，容易出错。

在模板中的应用：在模板中，const 可以用于模板参数，表示常量类型。

1. template<typename T>
2. const T& max(const T& a, const T& b)
3. {
4. return a > b ? a : b;
5. }

复制代码

修饰lambda表达式：C++11 以后，lambda表达式可以指定为常量（默认情况下，即使捕获列表为值捕获，lambda的函数调用运算符也是可变的）。但是，如果lambda被声明为const，则不能修改捕获的变量（即使是以值方式捕获的非mutable lambda）。

实际上，在C++11中，lambda表达式默认是不可修改捕获的变量的，除非使用mutable关键字。而C++17引入了constexpr lambda

1. int x = 10;
2. auto lambda = [x]() const
3. { // 注意：这个语法在C++11/14中并不直接支持，实际上lambda的常量性是通过mutable来控制的
4. // x = 5; // 错误：不能修改捕获的变量
5. return x;
6. };

复制代码

修饰类类型的对象：如果类类型的对象被声明为const，那么只能调用其const成员函数。

2 指针与引用

2.1 内存布局

C++的内存布局通常可以分为以下几个部分：

1. 栈（Stack）：用于存储局部变量、函数参数和函数调用的上下文。栈由编译器自动管理，通过压栈和出栈操作进行分配和释放。栈内存的分配是连续的，通常有限，但访问速度快。

• 特点：自动分配和释放，由编译器管理

• 存储内容：

  • 局部变量

  • 函数参数

  • 函数返回地址

• 大小限制：通常较小（Linux下默认8MB，Windows下1MB）

• 分配方式：LIFO（后进先出）

• 访问速度：快

1. void func()
2. {
3. int x = 10; // x在栈上
4. char buffer[100]; // buffer在栈上
5. // 函数结束时自动释放
6. }

复制代码

堆（Heap）：用于动态内存分配。堆内存由程序员手动管理（在C++中，使用new和delete或malloc和free）。堆内存的分配不是连续的，需要更复杂的管理，因此访问速度相对较慢，但大小只受系统内存限制。

• 特点：手动分配和释放，由程序员管理

• 存储内容：

  • 动态分配的内存（new/malloc）

• 大小限制：受系统内存限制

• 访问速度：相对较慢

• 注意事项：容易产生内存泄漏

1. int* p = new int(10); // 在堆上分配
2. delete p; // 必须手动释放

复制代码

全局/静态存储区：用于存储全局变量和静态变量（包括静态局部变量和静态成员变量）。这部分内存在程序启动时分配，在程序结束时释放。它又可以分为：

• 已初始化数据段（data segment）：存储已初始化的全局变量和静态变量。

• 未初始化数据段（bss segment）：存储未初始化的全局变量和静态变量（在程序启动时会被初始化为0或nullptr）。

• 存储内容：

  • 全局变量

  • 静态变量（static）

  • 常量数据（常量字符串等）

• 生命周期：整个程序运行期间

1. int globalVar = 100; // 全局变量 - 数据段
2. static int staticVar = 200; // 静态变量 - 数据段
3. const char* str = "Hello"; // 常量字符串 - 只读数据段

复制代码

1. 常量存储区：用于存储常量，如字符串常量和其他常量。这部分内存通常是只读的。

2. 代码区：用于存储程序的执行代码（机器指令）。

   • 存储内容：

     • 可执行代码

     • 常量（const变量，取决于定义位置）

   • 特点：只读，共享内存

1. const int MAX_SIZE = 100; // 可能存储在代码区或只读数据段

复制代码

1. 高地址
2. ┌─────────────────┐
3. │ 栈区 │ ← 向下增长
4. ├─────────────────┤
5. │ 堆区 │ ← 向上增长
6. ├─────────────────┤
7. │ BSS段(未初始化) │
8. ├─────────────────┤
9. │ 数据段(已初始化) │
10. ├─────────────────┤
11. │ 代码区 │
12. └─────────────────┘
13. 低地址

复制代码

2.2 指针与引用的本质区别及使用场景

本质区别：

• 指针是一个变量，存储的是另一个变量的内存地址。指针本身有地址，并且可以改变其指向。

• 引用是一个别名，一旦被初始化为一个对象，就不能再改变为另一个对象的别名。引用没有自己的地址（不能获取引用的地址，它和它引用的对象使用相同的地址）

使用上的区别：

• 指针可以重新赋值指向不同的对象，也可以为nullptr

• 引用必须在定义时初始化，并且一旦绑定到一个对象上，就不能再绑定到其他对象。因此，引用没有空引用。

指针的使用场景：

• 需要能够指向空（无对象）的情况。

• 需要能够在不同时刻指向不同对象的情况

• 需要存储和操作内存地址，比如动态内存分配（new返回指针）

• 需要遍历数组或数据结构（如链表、树）时，使用指针移动

• 多态：通过基类指针指向派生类对象

• 需要传递函数指针或回调函数时

引用的使用场景：

• 函数参数：希望函数内修改传入的变量，并且不希望传递空值。引用传递避免了拷贝，同时保证了绑定对象的存在。

• 函数返回值：返回引用可以避免返回时的拷贝，但必须注意不能返回局部变量的引用（因为局部变量在函数结束后被销毁）。通常用于返回类成员、静态变量或传入的引用参数等。

• 操作符重载：比如流操作符<<和>>，赋值操作符=等，通常返回引用以支持链式调用

• 别名：为一个复杂的表达式或变量起一个别名，使代码更清晰

注意事项：

• 引用在底层通常是通过指针实现的，但语言层面隐藏了这一细节。

• 指针可以有多级（如指向指针的指针），而引用只有一级。

• 指针可以参与算术运算（如指针加减），而引用不能。

• 使用指针时需要注意内存管理，避免内存泄漏和野指针。

• 引用更安全，但灵活性不如指针。

2.3 理解空指针与野指针

空指针是指不指向任何有效对象或函数的指针。在C++11之前，我们通常用NULL（实际上是0）或者0来表示空指针。从C++11开始，引入了nullptr关键字，用来表示空指针，它是空指针常量，具有明确的类型（std::nullptr_t）。（如果是c++11标准之后，不建议使用NULL，因为0是整数，不是指针类型）

野指针是指向无效内存地址的指针。这种指针不是空指针，但它指向的内存可能已经被释放或者从未分配。使用野指针会导致未定义行为，通常是程序崩溃或数据损坏。

野指针的产生原因：

• 指针未初始化：声明指针变量时没有初始化，它的值是随机的

• 指针指向的内存被释放后未置空

• 指针指向局部变量，但该变量已经离开作用域

• 指针运算超出数组边界

如何避免野指针：

• 初始化指针：声明指针时应该立即初始化（为nullptr或者有效地址）

• 释放内存后立即置空

• 避免返回局部变量的地址

• 使用智能指针

• 使用引用代替指针：引用必须初始化，并且不能改变指向，所以不会成为野引用

3 面向对象与设计模式

3.1 OOP：封装、继承、多态（虚函数表原理）

封装是将数据（变量）和操作数据的函数（方法）组合在一起，形成一个类（class）。同时，通过访问修饰符（public、private、protected）来控制对类内部数据和函数的访问权限，从而隐藏内部实现细节，只暴露必要的接口。

封装的优点：

• 数据隐藏：保护类的内部状态，防止外部代码随意修改

• 接口与实现分离：用户只需知道如何使用类提供的接口，而不必了解内部实现

• 提高代码可维护性：内部实现可以自由更改，只要接口保持不变，就不会影响使用该类的代码

继承允许我们定义一个类（称为派生类或者子类）基于另一个类（称为基类或父类）。派生类继承基类的成员（属性和方法），并可以添加自己的新成员或重写基类的方法。继承实现了代码的重用和层次关系。

继承的类型：

• 公有继承：基类的公有成员在派生类中保持公有，保护成员保持保护

• 保护继承：基类的公有和保护成员在派生类中都变为保护成员

• 私有继承：基类的公有和保护成员在派生类中变为私有成员

private：完全私有，只能在本类中访问

protected：可在本类和派生类中访问

public：完全公开，任何地方都可访问

继承中的访问控制：

基类成员访问权限	公有继承	保护继承	私有继承
public	public	protected	private
protected	protected	protected	private
private	不可访问	不可访问	不可访问

用虚继承的方式解决菱形继承问题：三层继承，中层使用虚继承

1. class Animal
2. {
3. public:
4. void breathe() { cout << "Breathing\n"; }
5. };
7. // 虚继承
8. class Mammal : virtual public Animal
9. {
10. };
12. class WingedAnimal : virtual public Animal
13. {
14. };
16. // Bat只包含一份Animal的副本
17. class Bat : public Mammal, public WingedAnimal
18. {
19. };

复制代码

多态通常通过虚函数实现，允许使用基类的指针或引用来调用派生类中重写的方法。同一个函数调用会根据实际对象的类型执行不同的操作。

多态的条件：

• 必须有继承关系

• 基类中必须有虚函数

• 派生类必须重写基类的虚函数

• 通过基类的指针或引用调用虚函数

静态多态（编译时多态）：

• 函数重载

• 运算符重载

动态多态（运行时多态）：

• 虚函数机制

虚函数表

虚函数表是在编译时创建的静态表，存储了类中所有虚函数的地址。每个包含虚函数的类都有自己的虚函数表，而每个该类的对象都包含一个指向该虚函数表的指针。

没有虚函数的情况：函数调用是在编译时确定的（静态绑定），因此调用的是Base::func。

1. class Base
2. {
3. public:
4. void func() { cout << "Base::func" << endl; }
5. };
7. class Derived : public Base
8. {
9. public:
10. void func() { cout << "Derived::func" << endl; }
11. };
13. int main()
14. {
15. Base* obj = new Derived();
16. obj->func(); // 输出: Base::func（静态绑定）
17. delete obj;
18. }

复制代码

有虚函数的情况：函数调用是在运行时根据对象的实际类型确定的（动态绑定）

1. class Base
2. {
3. public:
4. virtual void func1() { cout << "Base::func1" << endl; }
5. virtual void func2() { cout << "Base::func2" << endl; }
6. void func3() { cout << "Base::func3" << endl; }
7. };
9. class Derived : public Base
10. {
11. public:
12. void func1() override { cout << "Derived::func1" << endl; }
13. void func2() override { cout << "Derived::func2" << endl; }
14. };
16. int main()
17. {
18. Base* obj = new Derived();
19. obj->func1(); // 输出: Derived::func1（动态绑定）
20. obj->func2(); // 输出: Derived::func2（动态绑定）
21. obj->func3(); // 输出: Base::func3（静态绑定）
22. delete obj;
23. }

复制代码

单继承情况的虚函数表内存布局：

1. class Base
2. {
3. public:
4. virtual void func1() { }
5. virtual void func2() { }
6. int base_data;
7. };
9. class Derived : public Base
10. {
11. public:
12. void func1() override { }
13. virtual void func3() { }
14. int derived_data;
15. };

复制代码

1. Base对象:
2. +----------------+
3. | vptr | --> 指向Base的虚函数表
4. +----------------+
5. | base_data |
6. +----------------+
8. Derived对象:
9. +----------------+
10. | vptr | --> 指向Derived的虚函数表
11. +----------------+
12. | base_data | (继承自Base)
13. +----------------+
14. | derived_data |
15. +----------------+
17. Base的虚函数表:
18. +----------------+
19. | &Base::func1 |
20. +----------------+
21. | &Base::func2 |
22. +----------------+
24. Derived的虚函数表:
25. +----------------+
26. | &Derived::func1| // 重写了Base::func1
27. +----------------+
28. | &Base::func2 | // 没有重写，所以还是Base::func2
29. +----------------+
30. | &Derived::func3| // 新增的虚函数
31. +----------------+

复制代码

多继承情况的虚函数表内存布局：

1. class Base1
2. {
3. public:
4. virtual void func1() { }
5. int data1;
6. };
8. class Base2
9. {
10. public:
11. virtual void func2() { }
12. int data2;
13. };
15. class Derived : public Base1, public Base2
16. {
17. public:
18. void func1() override { }
19. void func2() override { }
20. virtual void func3() { }
21. int data3;
22. };

复制代码

1. Derived对象:
2. +----------------+
3. | vptr1 | --> 指向Derived的Base1部分虚函数表
4. +----------------+
5. | Base1::data1 |
6. +----------------+
7. | vptr2 | --> 指向Derived的Base2部分虚函数表
8. +----------------+
9. | Base2::data2 |
10. +----------------+
11. | Derived::data3 |
12. +----------------+
14. Derived的Base1部分虚函数表:
15. +----------------+
16. | &Derived::func1| // 重写了Base1::func1
17. +----------------+
18. | &Derived::func3| // 新增的虚函数
19. +----------------+
21. Derived的Base2部分虚函数表:
22. +----------------+
23. | &Derived::func2| // 重写了Base2::func2
24. +----------------+
25. | 偏移量/thunk | // 可能包含this指针调整信息
26. +----------------+

复制代码

虚函数表指针： 虚函数表指针的位置：

• 通常位于对象的起始位置（但这不是C++标准要求的，只是大多数编译器的实现方式）

• 每个有虚函数的对象至少有一个vptr

• 多重继承中，对象可能有多个vptr

虚函数表指针的初始化：

• 在构造函数中初始化

• 初始化顺序：先基类后派生类

• 在对象构造过程中，vptr可能被多次修改

虚函数调用的实现：

1. Base* obj = new Derived();
2. obj->func1(); // 虚函数调用

复制代码

实际过程：

1. 通过对象的vptr找到虚函数表

2. 在虚函数表中通过固定的偏移量找到函数地址

3. 通过函数地址调用函数，并传递正确的this指针

this指针调整：在多继承中，当通过第二个基类的指针调用派生类的虚函数时，需要调整this指针

1. Derived* d = new Derived();
2. Base2* b2 = d; // 这里b2指向Derived对象中的Base2子对象
3. b2->func2(); // 调用时，this指针需要调整到Derived对象的起始位置

复制代码

虚函数表的构造过程：

编译时：

1. 编译器为每个包含虚函数的类生成一个虚函数表

2. 表中按声明顺序存放虚函数地址

3. 对于被重写的函数，使用派生类的函数地址

4. 对于未被重写的函数，使用基类的函数地址

运行时：

1. 在对象构造时设置vptr

2. 在构造函数初始化列表中，vptr被设置为当前类的虚函数表

3. 如果有基类，先调用基类构造函数（设置基类的vptr）

4. 然后调用派生类构造函数（重新设置vptr）

3.2 设计模式：单例、工厂、观察者

单例模式

确保一个类只有一个实例，并提供全局访问点。

实现要点：

1. 构造函数私有化：确保外部不能直接创建对象。

2. 禁用拷贝和赋值：避免通过拷贝或赋值创建新实例。

3. 提供全局访问点：通过静态成员函数获取唯一实例。

4. 线程安全：多线程环境下确保只创建一个实例。

5. 延迟初始化（可选）：有些场景下希望第一次使用时才创建实例（懒汉式），而有些场景下希望程序启动时就创建（饿汉式）。

6. 资源释放：一般情况下，单例对象在程序运行期间一直存在，不需要手动释放。如果使用new创建，可以考虑使用智能指针，或者使用静态成员变量（在程序结束时自动销毁）。使用局部静态变量方式可以自动销毁。

懒汉式（线程不安全）和饿汉式（线程安全），现代C++中推荐线程安全懒汉式（使用局部静态变量）。

1. class Singleton
2. {
3. private:
4. Singleton() {}
5. Singleton(const Singleton&) = delete;
6. Singleton& operator=(const Singleton&) = delete;
8. public:
9. static Singleton& getInstance()
10. {
11. static Singleton instance; // 线程安全
12. return instance;
13. }
14. };

复制代码

工厂模式

简单工厂模式：一个工厂类，根据参数创建不同的产品。适用于产品类型较少的情况。

要点：

1. 一个工厂类，一个产品接口（或抽象类），多个具体产品类。

2. 工厂类中有一个静态方法（或非静态），根据参数创建具体产品。

1. #include <iostream>
2. using namespace std;
4. // 产品接口
5. class Shape
6. {
7. public:
8. virtual void draw() = 0;
9. virtual ~Shape() {}
10. };
12. // 具体产品：圆形
13. class Circle : public Shape
14. {
15. public:
16. void draw() override
17. {
18. cout << "Draw a circle." << endl;
19. }
20. };
22. // 具体产品：正方形
23. class Square : public Shape
24. {
25. public:
26. void draw() override
27. {
28. cout << "Draw a square." << endl;
29. }
30. };
32. // 简单工厂
33. class ShapeFactory
34. {
35. public:
36. // 根据类型创建形状
37. static Shape* createShape(const string& type)
38. {
39. if (type == "circle")
40. {
41. return new Circle();
42. } else if (type == "square")
43. {
44. return new Square();
45. } else
46. {
47. return nullptr;
48. }
49. }
50. };
52. int main()
53. {
54. Shape* circle = ShapeFactory::createShape("circle");
55. Shape* square = ShapeFactory::createShape("square");
57. if (circle) circle->draw();
58. if (square) square->draw();
60. delete circle;
61. delete square;
63. return 0;
64. }

复制代码

优点：

• 客户端不需要知道具体产品类的类名，只需要知道参数。

• 通过配置文件，可以不用修改客户端代码，而更换和增加新的具体产品。

缺点：

• 工厂类集中了所有产品的创建逻辑，一旦不能正常工作，整个系统都受影响。

• 系统扩展困难，一旦增加新产品就不得不修改工厂逻辑。

工厂方法模式：定义一个创建对象的接口，但让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

要点：

1. 一个产品接口，多个具体产品。

2. 一个工厂接口（或抽象类），多个具体工厂，每个具体工厂对应一个具体产品。

1. #include <iostream>
2. using namespace std;
4. // 产品接口
5. class Shape
6. {
7. public:
8. virtual void draw() = 0;
9. virtual ~Shape() {}
10. };
12. // 具体产品：圆形
13. class Circle : public Shape
14. {
15. public:
16. void draw() override
17. {
18. cout << "Draw a circle." << endl;
19. }
20. };
22. // 具体产品：正方形
23. class Square : public Shape
24. {
25. public:
26. void draw() override
27. {
28. cout << "Draw a square." << endl;
29. }
30. };
32. // 工厂接口
33. class ShapeFactory
34. {
35. public:
36. virtual Shape* createShape() = 0;
37. virtual ~ShapeFactory() {}
38. };
40. // 具体工厂：创建圆形
41. class CircleFactory : public ShapeFactory
42. {
43. public:
44. Shape* createShape() override
45. {
46. return new Circle();
47. }
48. };
50. // 具体工厂：创建正方形
51. class SquareFactory : public ShapeFactory
52. {
53. public:
54. Shape* createShape() override
55. {
56. return new Square();
57. }
58. };
60. int main()
61. {
62. ShapeFactory* circleFactory = new CircleFactory();
63. ShapeFactory* squareFactory = new SquareFactory();
65. Shape* circle = circleFactory->createShape();
66. Shape* square = squareFactory->createShape();
68. circle->draw();
69. square->draw();
71. delete circle;
72. delete square;
73. delete circleFactory;
74. delete squareFactory;
76. return 0;
77. }

复制代码

优点：

• 客户端不需要知道具体产品类的类名，只需要知道对应的工厂。

• 在系统增加新的产品时，只需要添加具体产品类和对应的具体工厂类，无需修改现有代码，符合开闭原则。

缺点：

• 每增加一个产品，就需要增加一个具体工厂类，增加了系统的复杂度。

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

要点：

1. 多个产品接口，每个产品接口有多个具体产品。

2. 一个工厂接口，可以创建多个产品，每个具体工厂对应一个产品族。

示例代码：假设有两种产品：颜色和形状。颜色有红色和蓝色，形状有圆形和正方形。抽象工厂可以创建一组相关的产品，比如红色圆形、蓝色正方形等。

1. #include <iostream>
2. using namespace std;
4. // 抽象产品：颜色
5. class Color
6. {
7. public:
8. virtual void fill() = 0;
9. virtual ~Color() {}
10. };
12. // 具体产品：红色
13. class Red : public Color
14. {
15. public:
16. void fill() override
17. {
18. cout << "Fill with red color." << endl;
19. }
20. };
22. // 具体产品：蓝色
23. class Blue : public Color
24. {
25. public:
26. void fill() override
27. {
28. cout << "Fill with blue color." << endl;
29. }
30. };
32. // 抽象产品：形状
33. class Shape {
34. public:
35. virtual void draw() = 0;
36. virtual ~Shape() {}
37. };
39. // 具体产品：圆形
40. class Circle : public Shape
41. {
42. public:
43. void draw() override
44. {
45. cout << "Draw a circle." << endl;
46. }
47. };
49. // 具体产品：正方形
50. class Square : public Shape
51. {
52. public:
53. void draw() override
54. {
55. cout << "Draw a square." << endl;
56. }
57. };
59. // 抽象工厂
60. class AbstractFactory
61. {
62. public:
63. virtual Color* createColor() = 0;
64. virtual Shape* createShape() = 0;
65. virtual ~AbstractFactory() {}
66. };
68. // 具体工厂：创建红色和圆形
69. class RedCircleFactory : public AbstractFactory
70. {
71. public:
72. Color* createColor() override
73. {
74. return new Red();
75. }
76. Shape* createShape() override
77. {
78. return new Circle();
79. }
80. };
82. // 具体工厂：创建蓝色和正方形
83. class BlueSquareFactory : public AbstractFactory
84. {
85. public:
86. Color* createColor() override
87. {
88. return new Blue();
89. }
90. Shape* createShape() override
91. {
92. return new Square();
93. }
94. };
96. int main()
97. {
98. AbstractFactory* factory1 = new RedCircleFactory();
99. Color* red = factory1->createColor();
100. Shape* circle = factory1->createShape();
102. red->fill();
103. circle->draw();
105. AbstractFactory* factory2 = new BlueSquareFactory();
106. Color* blue = factory2->createColor();
107. Shape* square = factory2->createShape();
109. blue->fill();
110. square->draw();
112. delete red; //因为类是在堆上创建的，所以必须要手动delete
113. delete circle;
114. delete factory1;
115. delete blue;
116. delete square;
117. delete factory2;
119. return 0;
120. }

复制代码

优点：

• 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

• 增加新的产品族很方便，无需修改现有系统。

缺点：

• 增加新的产品等级结构（即增加新的产品类型）很麻烦，需要修改抽象工厂和所有的具体工厂。

观察者模式

定义对象间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会得到通知。

要点：

• Subject（主题）：维护观察者列表，提供添加、删除和通知观察者的接口

• Observer（观察者）：定义更新接口，用于在主题状态改变时接收通知

• ConcreteSubject（具体主题）：存储具体状态，状态改变时通知所有观察者

• ConcreteObserver（具体观察者）：实现更新接口，保持与主题状态的一致性

1. #include <iostream>
2. #include <vector>
3. #include <memory>
4. #include <functional>
5. #include <mutex>
6. #include <algorithm>
8. // 现代观察者模式最佳实践
9. template<typename... Args>
10. class Observable //观察者回调函数的参数类型
11. {
12. private:
13. using Callback = std::function<void(Args...)>;
15. struct ObserverEntry //存储每个观察者的信息
16. {
17. std::weak_ptr<void> weakKey; // 用于取消订阅的键
18. Callback callback;//回调函数
19. int priority{0};//优先级，用于排序
21. bool operator<(const ObserverEntry& other) const
22. {
23. return priority < other.priority;
24. }
25. };
27. std::vector<ObserverEntry> observers;//存储所有观察者
28. mutable std::shared_mutex mutex;//用于多线程保护的共享互斥锁
29. std::atomic<bool> notifying{false};//原子布尔变量，防止重入通知
31. public:
32. // 订阅（返回可用于取消订阅的token）
33. template<typename T>
34. std::shared_ptr<T> subscribe(Callback callback, int priority = 0)
35. {
36. auto key = std::make_shared<T>();
38. std::unique_lock lock(mutex);
39. observers.push_back({key, callback, priority});
40. std::sort(observers.begin(), observers.end());
42. return key;
43. }
45. // 取消订阅
46. template<typename T>
47. void unsubscribe(const std::shared_ptr<T>& key)
48. {
49. std::unique_lock lock(mutex);
50. observers.erase(
51. std::remove_if(observers.begin(), observers.end(),
52. [&key](const ObserverEntry& entry)
53. {
54. return entry.weakKey.lock() == key;
55. }),
56. observers.end()
57. );
58. }
60. // 通知所有观察者（线程安全，异常安全）
61. void notify(Args... args)
62. {
63. if (notifying.exchange(true))
64. {
65. return; // 防止重入
66. }
68. std::vector<ObserverEntry> observersCopy;
69. {
70. std::shared_lock lock(mutex);
71. observersCopy = observers;
72. }
74. try
75. {
76. // 按优先级顺序通知
77. for (const auto& entry : observersCopy)
78. {
79. if (auto key = entry.weakKey.lock())
80. {
81. try
82. {
83. entry.callback(args...);
84. }
85. catch (const std::exception& e)
86. {
87. std::cerr << "观察者回调异常: " << e.what() << std::endl;
88. // 继续执行其他观察者
89. }
90. }
91. }
92. } catch (...)
93. {
94. notifying.store(false);
95. throw;
96. }
98. notifying.store(false);
100. // 清理已销毁的观察者
101. cleanup();
102. }
104. private:
105. void cleanup() //清理方法：移除所有weakKey已经过期的观察者
106. {
107. std::unique_lock lock(mutex);
108. observers.erase(
109. std::remove_if(observers.begin(), observers.end(),
110. [](const ObserverEntry& entry)
111. {
112. return entry.weakKey.expired();
113. }),
114. observers.end()
115. );
116. }
117. };
119. // 使用示例
120. class Button
121. {
122. private:
123. Observable<int, int> onClick; // x, y坐标
125. public:
126. auto connectClick(std::function<void(int, int)> handler) //连接点击事件
127. {
128. return onClick.subscribe<int>(handler);
129. }
131. void click(int x, int y) //模拟按钮点击
132. {
133. std::cout << "按钮被点击: (" << x << ", " << y << ")" << std::endl;
134. onClick.notify(x, y);
135. }
136. };
138. int main()
139. {
140. Button button;//创建Button对象，连接两个点击事件处理其，然后触发点击事件，最后再连接一个处理器
142. // 订阅点击事件
143. auto token1 = button.connectClick([](int x, int y)
144. {
145. std::cout << "处理器1: 点击位置 (" << x << ", " << y << ")" << std::endl;
146. });
148. auto token2 = button.connectClick([](int x, int y)
149. {
150. std::cout << "处理器2: 按钮点击事件" << std::endl;
151. });
153. // 触发事件
154. button.click(100, 200);
156. // 取消订阅
157. button.connectClick([](int, int)
158. {
159. // 这个不会执行，因为token2被释放了
160. });
162. return 0;
163. }

复制代码

4 资源管理与RALL

4.1 智能指针

shared_ptr（共享）

特点：共享所有权，引用计数

共享所有权的智能指针。多个shared_ptr可以指向同一个对象，并通过引用计数来管理对象的生命周期。当最后一个shared_ptr被销毁时，对象才会被释放。

1. #include <memory>
2. #include <iostream>
4. void shared_ptr_demo()
5. {
6. // 创建 shared_ptr
7. std::shared_ptr<int> p1 = std::make_shared<int>(100); // 推荐
8. std::shared_ptr<int> p2(p1); // 复制，引用计数+1
10. std::cout << "p1.use_count(): " << p1.use_count() << std::endl; // 2
11. std::cout << "p2.use_count(): " << p2.use_count() << std::endl; // 2
13. // 独立指针
14. std::shared_ptr<int> p3 = std::make_shared<int>(200);
15. std::cout << "p3.use_count(): " << p3.use_count() << std::endl; // 1
17. // 重置指针
18. p2.reset(); // 释放所有权
19. std::cout << "p1.use_count(): " << p1.use_count() << std::endl; // 1
21. // 自定义删除器
22. auto custom_deleter = [](int* p)
23. {
24. std::cout << "Custom delete: " << *p << std::endl;
25. delete p;
26. };
27. std::shared_ptr<int> p4(new int(300), custom_deleter);
29. // 数组支持（C++17起）
30. std::shared_ptr<int[]> p5(new int[5]{10, 20, 30, 40, 50});
31. std::cout << p5[2] << std::endl; // 30
32. }

复制代码

注意：使用shared_ptr时要注意循环引用问题，如果两个对象相互使用shared_ptr指向对方，那么引用计数永远不会降到0，导致内存泄漏。这时可以使用weak_ptr来解决。

引用计数原理：

1. p1 ──┐
2. │───> 对象 (ref_count=2)
3. p2 ──┘

复制代码

unique_ptr（独占）

特点：独占所有权，不可复制

独占所有权的智能指针。同一时间只能有一个unique_ptr指向一个给定对象。当unique_ptr被销毁时，它所指向的对象也会被自动销毁。 它不能复制，只能移动。这意味着，所有权可以从一个unique_ptr转移到另一个unique_ptr，但不会有两个unique_ptr同时拥有同一个对象。

1. #include <memory>
2. #include <iostream>
4. void unique_ptr_demo()
5. {
6. // 创建 unique_ptr
7. std::unique_ptr<int> p1(new int(10));
8. auto p2 = std::make_unique<int>(20); // 推荐方式(C++14)
10. // 访问数据
11. std::cout << *p1 << std::endl; // 10
12. std::cout << *p2 << std::endl; // 20
14. // 转移所有权
15. std::unique_ptr<int> p3 = std::move(p1);
16. std::cout << (p1 == nullptr) << std::endl; // 1 (true)
17. std::cout << *p3 << std::endl; // 10
19. // 自定义删除器
20. auto deleter = [](int* p)
21. {
22. std::cout << "Deleting int: " << *p << std::endl;
23. delete p;
24. };
25. std::unique_ptr<int, decltype(deleter)> p4(new int(30), deleter);
27. // 数组支持
28. std::unique_ptr<int[]> p5(new int[5]{1, 2, 3, 4, 5});
29. std::cout << p5[2] << std::endl; // 3
30. }

复制代码

常用方法：

1. std::unique_ptr<T> up;
2. up.reset(ptr); // 接管新指针，释放原指针
3. up.release(); // 释放所有权，返回原始指针，不删除对象
4. up.get(); // 获取原始指针
5. up.swap(other); // 交换指针

复制代码

也可以使用std::make_unique（C++14引入）来创建unique_ptr，这样更安全，因为如果内存分配失败，它会抛出异常，而且使用它时不需要直接使用new。

1. auto p = std::make_unique<int>(10);

复制代码

weak_ptr（防循环引用）

特点：弱引用，不增加应用计数，解决循环引用问题

弱引用的智能指针，它不控制对象的生命周期，而是指向一个由shared_ptr管理的对象。weak_ptr的构造和析构不会影响引用计数。它主要用于解决shared_ptr的循环引用问题。

1. #include <memory>
2. #include <iostream>
4. class Node
5. {
6. public:
7. std::string name;
8. std::shared_ptr<Node> next;
9. std::weak_ptr<Node> prev; // 使用 weak_ptr 避免循环引用
11. Node(const std::string& n) : name(n)
12. {
13. std::cout << "Node " << name << " created" << std::endl;
14. }
16. ~Node()
17. {
18. std::cout << "Node " << name << " destroyed" << std::endl;
19. }
20. };
22. void weak_ptr_demo()
23. {
24. auto node1 = std::make_shared<Node>("Node1");
25. auto node2 = std::make_shared<Node>("Node2");
27. // 建立双向链接（使用 weak_ptr 避免循环引用）
28. node1->next = node2;
29. node2->prev = node1;
31. // 使用 weak_ptr
32. std::weak_ptr<Node> weak_node = node1;
34. // 检查对象是否还存在
35. if (auto shared_node = weak_node.lock())
36. {
37. std::cout << "Node exists: " << shared_node->name << std::endl;
38. } else {
39. std::cout << "Node has been destroyed" << std::endl;
40. }
42. // 重置 shared_ptr
43. node1.reset();
45. if (auto shared_node = weak_node.lock())
46. {
47. std::cout << "Node still exists" << std::endl;
48. } else {
49. std::cout << "Node has been destroyed" << std::endl;
50. }
51. }

复制代码

常用方法：

1. std::weak_ptr<T> wp;
2. wp.lock(); // 尝试获取 shared_ptr，失败返回空
3. wp.expired(); // 检查对象是否已被删除
4. wp.use_count(); // 获取引用计数

复制代码

注意：weak_ptr不能直接访问对象，必须通过lock()函数获取一个shared_ptr，然后使用。如果对象已经被释放，lock()会返回一个空的shared_ptr。

1. std::shared_ptr<int> sp = std::make_shared<int>(30);
2. std::weak_ptr<int> wp = sp;
4. // 使用weak_ptr访问对象
5. if (std::shared_ptr<int> np = wp.lock())
6. {
7. std::cout << *np << std::endl;
8. }
9. else
10. {
11. std::cout << "对象已释放" << std::endl;
12. }

复制代码

循环引用问题

1. class BadNode
2. {
3. public:
4. std::shared_ptr<BadNode> next;
5. std::shared_ptr<BadNode> prev; // 错误：相互持有 shared_ptr
7. BadNode(const std::string& n) : name(n)
8. {
9. std::cout << "BadNode " << n << " created" << std::endl;
10. }
12. ~BadNode()
13. {
14. std::cout << "BadNode " << name << " destroyed" << std::endl; // 永远不会执行
15. }
17. private:
18. std::string name;
19. };
21. void circular_reference_demo()
22. {
23. auto node1 = std::make_shared<BadNode>("Node1");
24. auto node2 = std::make_shared<BadNode>("Node2");
26. // 循环引用：两者都不会被销毁
27. node1->next = node2;
28. node2->prev = node1;
30. std::cout << "node1.use_count(): " << node1.use_count() << std::endl; // 2
31. std::cout << "node2.use_count(): " << node2.use_count() << std::endl; // 2
32. // 退出时，引用计数从2减到1，内存泄漏！
33. }

复制代码

4.2 RALL原则

构造函数获取资源，析构函数释放资源

RAII的核心思想是将资源（如动态内存、文件句柄、网络连接、锁等）的生命周期与对象的生命周期绑定，在对象构造时获取资源，在对象析构时释放资源。这样，只要对象能正确析构，资源就能被正确释放，从而避免资源泄漏。

RALL的工作原理：

• 在类的构造函数中获取资源（分配内存、打开文件、加锁等）

• 在类的析构函数中释放资源（释放内存、关闭文件、解锁等）

• 这样，当对象离开作用域时（无论是正常离开还是因为异常），析构函数都会被调用，从而释放资源。

管理动态内存（类似智能指针）：

1. template<typename T>
2. class SimpleUniquePtr
3. {
4. private:
5. T* ptr;
7. public:
8. // 构造函数获取资源
9. explicit SimpleUniquePtr(T* p = nullptr) : ptr(p) {}
11. // 析构函数释放资源
12. ~SimpleUniquePtr()
13. {
14. delete ptr;
15. }
17. // 禁止拷贝
18. SimpleUniquePtr(const SimpleUniquePtr&) = delete;
19. SimpleUniquePtr& operator=(const SimpleUniquePtr&) = delete;
21. // 允许移动
22. SimpleUniquePtr(SimpleUniquePtr&& other) noexcept : ptr(other.ptr)
23. {
24. other.ptr = nullptr;
25. }
27. SimpleUniquePtr& operator=(SimpleUniquePtr&& other) noexcept
28. {
29. if (this != &other)
30. {
31. delete ptr;
32. ptr = other.ptr;
33. other.ptr = nullptr;
34. }
35. return *this;
36. }
38. // 访问操作
39. T& operator*() const { return *ptr; }
40. T* operator->() const { return ptr; }
41. T* get() const { return ptr; }
43. // 资源释放
44. void reset(T* p = nullptr)
45. {
46. delete ptr;
47. ptr = p;
48. }
49. };

复制代码

RALL与异常安全：

1. void badFunction()
2. {
3. int* ptr = new int(100);
4. someFunctionThatMayThrow(); // 如果抛出异常，delete不会执行，内存泄漏
5. delete ptr;
6. }
8. void goodFunction()
9. {
10. std::unique_ptr<int> ptr = std::make_unique<int>(100); // 使用RAII
11. someFunctionThatMayThrow(); // 即使抛出异常，ptr的析构函数也会被调用，内存被释放
12. }

复制代码

C++标准库中的智能指针（unique_ptr、shared_ptr、weak_ptr）是RAII的典型应用。它们管理动态内存，确保在适当的时候释放内存。

作用域绑定资源生命周期：

1. void scope_based_management()
2. {
3. {
4. LockRAII lock(mutex); // 进入作用域时加锁
5. // 临界区代码
6. // 如果这里抛出异常，锁仍然会自动释放
7. } // 离开作用域时自动解锁
9. // 不同作用域不同资源
10. {
11. FileRAII file1("a.txt", "r");
12. // 使用file1
13. } // file1自动关闭
15. {
16. FileRAII file2("b.txt", "w");
17. // 使用file2
18. } // file2自动关闭
19. }

复制代码

RALL的优点：

1. 自动释放资源：不再需要手动释放资源，减少错误。

2. 异常安全：即使发生异常，资源也能被正确释放。

3. 代码简洁：将资源管理逻辑封装在类中，使用代码更清晰。

4. 资源所有权明确：通过对象的生命周期明确资源的所有权。

RALL的注意事项：

1. 资源的所有权：RAII对象应独占资源的所有权，避免多个RAII对象管理同一资源（除非使用引用计数如shared_ptr）。

2. 拷贝控制：如果RAII类需要拷贝，需要仔细考虑拷贝语义（深拷贝或转移所有权）。通常，如果资源不可共享，应禁止拷贝（如unique_ptr），或使用引用计数（如shared_ptr）。

3. 资源泄露：确保在构造函数中获取资源时没有泄漏，如果构造函数抛出异常，析构函数不会被调用，因此需要确保构造函数是异常安全的。

c++标准库中的RALL类

1. #include <memory>
2. #include <fstream>
3. #include <mutex>
5. void standard_library_raii()
6. {
7. // 1. 内存管理
8. std::unique_ptr<int> ptr = std::make_unique<int>(42);
9. std::shared_ptr<int> shared = std::make_shared<int>(42);
11. // 2. 文件管理
12. std::ifstream file("data.txt"); // RAII：自动关闭文件
13. std::ofstream output("output.txt");
15. // 3. 互斥锁管理
16. std::mutex mtx;
17. {
18. std::lock_guard<std::mutex> lock(mtx); // RAII锁
19. // 临界区
20. } // 自动解锁
22. // 4. 动态数组
23. std::vector<int> vec; // RAII：自动管理内存
24. vec.push_back(1);
25. // 离开作用域时自动释放内存
26. }

复制代码

RALL设计原则：

1. 资源获取在构造函数中完成

2. 资源释放在析构函数中完成

3. 使用移动语义支持资源所有权的转移

4. 通常禁用拷贝构造函数和拷贝赋值运算符

5. 考虑异常安全性

5 STL与泛型编程

5.1 容器

vector

vector 是一个动态数组，它能够存储连续内存中的元素，并且可以动态地调整大小。

• 元素在内存中是连续存储的，这意味着可以通过指针算术来访问元素。

• 当当前容量不足以容纳新元素时，vector会重新分配一个更大的内存块（通常是当前容量的两倍），并将现有元素复制到新内存中。

常用操作：

• 访问元素：使用[]运算符或at()方法（at()会进行边界检查）。

• 尾部添加/删除：push_back()和pop_back()，平均时间复杂度为O(1)（不考虑重新分配的情况）。

• 中间插入/删除：insert()和erase()，需要移动元素，时间复杂度为O(n)。

• 大小和容量：size()返回元素数量，capacity()返回当前分配的内存可以容纳的元素数量。

优缺点：

• 优点：连续内存使得访问速度快，支持随机访问，缓存友好。

• 缺点：在中间插入或删除元素效率低，动态调整大小时可能需要昂贵的复制操作。

适用场景：

• 需要频繁随机访问元素。

• 主要是在尾部添加或删除元素。

• 不需要在中间频繁插入或删除。

vector扩容机制：

vector的扩容机制是动态数组的核心特性。当vector的当前容量（capacity）不足以容纳新元素时，就需要扩容。 扩容的一般步骤：

1. 分配一块更大的内存空间（具体大小取决于实现，通常是当前容量的两倍或1.5倍）。

2. 将原有元素从旧内存移动到新内存（如果是非POD类型，移动过程中可能会调用元素的拷贝构造函数或移动构造函数）。

3. 释放旧内存。

4. 更新vector的内部指针，容量等状态。

vector 的扩容是自动的！这是 vector 内部机制，不需要手动实现。

当你使用 push_back、emplace_back、insert 等方法向 vector 中添加元素，而当前容量（capacity）不足以容纳新元素时，vector 会自动进行扩容。

注意事项：

1. 性能考虑：自动扩容虽然方便，但频繁扩容会导致性能下降。如果你知道大概需要多少元素，最好使用 reserve 预分配。

2. 迭代器失效：扩容后，所有迭代器、指针和引用都会失效，需要重新获取。

3. 异常安全：vector 的扩容操作是异常安全的，如果扩容失败（如内存不足），会抛出 std::bad_alloc 异常，且原 vector 保持不变。

map/unordered_map

• map 是一个关联容器，存储键值对，并且按照键的顺序排序。它通常使用红黑树实现。

• unordered_map 也是一个关联容器，但它不保证顺序，通常使用哈希表实现。

map：

• 优点：有序，便于范围查询，操作的时间复杂度稳定为O(log n)。

• 缺点：相比unordered_map，访问速度较慢（因为树结构）。

unordered_map：

• 优点：平均情况下插入、删除、查找的时间复杂度为O(1)。

• 缺点：最坏情况下（哈希冲突严重）性能下降为O(n)，无序。

适用场景：

• map：需要有序的键值对，或者需要范围查询。

• unordered_map：对顺序没有要求，需要快速的单个元素访问。

红黑树：

红黑树是一种自平衡的二叉搜索树，它在每个节点上增加了一个存储位表示节点的颜色（红色或黑色）。通过对任何一条从根到叶子的路径上各个节点颜色的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而是近似平衡的。

红黑树满足以下性质：

1. 每个节点要么是红色，要么是黑色。

2. 根节点是黑色的。

3. 每个叶子节点（NIL节点，空节点）是黑色的。

4. 如果一个节点是红色的，则它的两个子节点都是黑色的（即不能有两个连续的红色节点）。

5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点（称为黑高）。

1. 旋转：为了在插入和删除后重新平衡树，需要进行旋转操作。旋转有两种：左旋和右旋。

   • 左旋：将节点x的右子树y提升为新的父节点，x成为y的左子节点，y的左子节点成为x的右子节点。

   • 右旋：将节点x的左子树y提升为新的父节点，x成为y的右子节点，y的右子节点成为x的左子节点。

2. 插入：新插入的节点通常被着色为红色，以避免违反黑高性质。然后，通过一系列的颜色更改和旋转来修复可能出现的连续红色节点问题。

3. 删除：删除操作比插入更复杂。删除一个节点后，可能会破坏红黑树的性质，需要通过颜色更改和旋转来修复。

哈希表：

1. // 哈希表（Hash Table）是一种：
2. // 1. 键值对存储结构
3. // 2. 通过哈希函数将键映射到数组索引
4. // 3. 理想情况下提供O(1)的插入、删除和查找
6. // 基本工作原理：
7. // key → 哈希函数 → 哈希值 → 数组索引 → 存储value
9. // 在C++标准库中，unordered_map通常实现为：
10. // - 数组：存储桶（buckets）
11. // - 每个桶：链表或红黑树（C++11后引入）
13. // 解决哈希冲突的两种主要方法：
14. // 1. 链地址法（Separate Chaining）：每个桶是链表
15. // 2. 开放地址法（Open Addressing）：线性探测、二次探测等
17. // C++ unordered_map使用链地址法
18. /*
19. buckets数组
20. +---+ +-------+ +-------+ +-------+
21. | 0 | -> | key1 | -> | key4 | -> | key7 | -> nullptr
22. +---+ +-------+ +-------+ +-------+
23. | 1 | -> nullptr
24. +---+
25. | 2 | -> | key2 | -> | key5 | -> nullptr
26. +---+ +-------+ +-------+
27. | 3 | -> | key3 | -> | key6 | -> nullptr
28. +---+ +-------+ +-------+
29. ...
30. |n-1| -> nullptr
31. +---+
33. 哈希函数：h(key) = key % n
34. */

复制代码

list

list 是一个双向链表，允许在常数时间内在任何位置进行插入和删除操作。

• 每个元素（节点）包含指向前一个和后一个节点的指针。

• 内存不是连续的，因此不能通过索引直接访问元素。

常用操作：

• 插入：push_back()、push_front()、insert()，时间复杂度为O(1)（如果已知插入位置）。

• 删除：pop_back()、pop_front()、erase()，时间复杂度为O(1)（如果已知删除位置）。

• 访问：只能通过迭代器进行访问，不支持随机访问。

• 优点：在任意位置插入和删除效率高，不需要移动其他元素。

• 缺点：访问元素效率低，内存开销大（每个元素都需要额外的指针空间），缓存不友好。

适用场景：

• 需要频繁在中间插入或删除元素。

• 不需要随机访问，只需要顺序访问。

5.2 算法

以下三个算法函数都定义在头文件中

sort

sort用于对容器（如vector、deque、数组等）中的元素进行排序，默认是升序排序。

1. template< class RandomIt >
2. void sort( RandomIt first, RandomIt last );
4. template< class RandomIt, class Compare >
5. void sort( RandomIt first, RandomIt last, Compare comp );

复制代码

参数：

• first：指向待排序序列的第一个元素的迭代器。

• last：指向待排序序列的最后一个元素之后位置的迭代器。

• comp：比较函数，用于定义排序的顺序。它是一个二元谓词，接受两个参数，返回true如果第一个参数应该排在第二个参数之前。

使用：

1. #include <iostream>
2. #include <vector>
3. #include <algorithm>
5. int main()
6. {
7. std::vector<int> v = {5, 3, 1, 4, 2};
9. // 默认升序排序
10. std::sort(v.begin(), v.end());
11. for (int i : v) std::cout << i << " "; // 输出: 1 2 3 4 5
12. std::cout << std::endl;
14. // 降序排序
15. std::sort(v.begin(), v.end(), std::greater<int>());
16. for (int i : v) std::cout << i << " "; // 输出: 5 4 3 2 1
17. std::cout << std::endl;
19. // 使用lambda表达式自定义排序
20. std::sort(v.begin(), v.end(), [](int a, int b) {
21. return a < b; // 升序
22. });
23. for (int i : v) std::cout << i << " "; // 输出: 1 2 3 4 5
24. std::cout << std::endl;
26. return 0;
27. }

复制代码

• sort要求迭代器是随机访问迭代器，所以它不能用于链表（如list）和关联容器（如set、map）。链表有自己特有的sort成员函数。

• sort的平均时间复杂度为O(N log N)，其中N是待排序元素的数量。

find

find用于在容器中查找特定值，返回指向第一个等于该值的元素的迭代器。如果未找到，则返回结束迭代器（即last）。

1. template< class InputIt, class T >
2. InputIt find( InputIt first, InputIt last, const T& value );

复制代码

参数：

• first：指向查找范围的起始位置的迭代器。

• last：指向查找范围的结束位置（最后一个元素之后）的迭代器。

• value：要查找的值。

使用：

1. #include <iostream>
2. #include <vector>
3. #include <algorithm>
5. int main()
6. {
7. std::vector<int> v = {1, 2, 3, 4, 5};
9. // 查找值为3的元素
10. auto it = std::find(v.begin(), v.end(), 3);
11. if (it != v.end())
12. {
13. std::cout << "Found: " << *it << std::endl; // 输出: Found: 3
14. // 也可以计算索引
15. std::cout << "Index: " << (it - v.begin()) << std::endl; // 输出: Index: 2
16. }
17. else
18. {
19. std::cout << "Not found" << std::endl;
20. }
22. // 查找值为10的元素（不存在）
23. it = std::find(v.begin(), v.end(), 10);
24. if (it == v.end())
25. {
26. std::cout << "10 not found" << std::endl; // 输出: 10 not found
27. }
29. return 0;
30. }

复制代码

注意：

• find是线性查找，时间复杂度为O(N)。

• 对于已排序的序列，可以使用binary_search（二分查找）来获得更快的查找速度（O(log N)），但binary_search只返回是否存在，不返回位置。如果需要位置，可以使用lower_bound。

remove_if

remove_if用于从容器中移除满足特定条件的元素。注意，remove_if并不会真正删除元素，而是将不满足条件的元素移动到容器的前部，并返回一个指向新的逻辑结束位置的迭代器。之后，通常需要调用容器的erase方法来真正删除元素。

1. template< class ForwardIt, class UnaryPredicate >
2. ForwardIt remove_if( ForwardIt first, ForwardIt last, UnaryPredicate p );

复制代码

参数：

• first、last：指定要处理的元素范围。

• p：一元谓词，接受一个元素，返回true则将该元素移除（即移动到后面）。

使用：

1. #include <iostream>
2. #include <vector>
3. #include <algorithm>
5. int main()
6. {
7. std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
9. // 移除所有偶数
10. auto new_end = std::remove_if(v.begin(), v.end(), [](int n)
11. {
12. return n % 2 == 0;
13. });
15. // 此时，v中的元素变为：1,3,5,7,9,?,?,?,?,? （?表示未指定值，通常为原值）
16. // 注意：remove_if只是将不需要移除的元素移动到前面，并返回新的逻辑结束迭代器
17. // 物理大小没有改变
19. // 打印逻辑范围内的元素
20. for (auto it = v.begin(); it != new_end; ++it)
21. {
22. std::cout << *it << " "; // 输出: 1 3 5 7 9
23. }
24. std::cout << std::endl;
26. // 真正删除元素
27. v.erase(new_end, v.end());
29. // 现在v的物理大小也改变了
30. for (int i : v) std::cout << i << " "; // 输出: 1 3 5 7 9
31. std::cout << std::endl;
33. return 0;
34. }

复制代码

注意：

• remove_if并不会改变容器的大小，只是将不被移除的元素移动到前面，并返回新的逻辑结束位置。要真正删除元素，需要结合erase使用（这种方法称为“erase-remove”惯用法）。

• 对于链表（如list），有remove_if成员函数，它可以直接删除元素，不需要再调用erase。

• 时间复杂度为O(N)，其中N是容器中元素的数量。

5.3 lambda：结合STL算法使用

1. [capture] (parameters) -> return_type
2. {
3. // 函数体
4. }

复制代码

• capture：捕获列表，用于捕获外部变量。可以是值捕获、引用捕获或混合捕获。

• parameters：参数列表，类似于普通函数的参数列表。

• return_type：返回类型，可以省略，编译器会根据函数体中的返回语句自动推导。

• 函数体：与普通函数一样。

捕获列表的几种形式：

• []：不捕获任何外部变量。

• [=]：以值捕获的方式捕获所有外部变量。

• [&]：以引用捕获的方式捕获所有外部变量。

• [var]：以值捕获的方式捕获特定变量 var。

• [&var]：以引用捕获的方式捕获特定变量 var。

• [=, &var]：默认以值捕获所有外部变量，但是以引用捕获 var。

• [&, var]：默认以引用捕获所有外部变量，但是以值捕获 var。

使用sort进行自定义排序：

1. #include <iostream>
2. #include <vector>
3. #include <algorithm>
5. int main()
6. {
7. std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6};
9. // 使用 lambda 表达式按降序排序
10. std::sort(numbers.begin(), numbers.end(), [](int a, int b) {
11. return a > b; // 降序
12. });
14. for (int num : numbers)
15. {
16. std::cout << num << " ";
17. }
18. std::cout << std::endl;
20. return 0;
21. }

复制代码

使用for_each遍历并修改元素：

1. #include <iostream>
2. #include <vector>
3. #include <algorithm>
5. int main()
6. {
7. std::vector<int> numbers = {1, 2, 3, 4, 5};
9. // 使用 lambda 表达式将每个元素乘以2
10. std::for_each(numbers.begin(), numbers.end(), [](int &n) {
11. n *= 2;
12. });
14. for (int num : numbers)
15. {
16. std::cout << num << " ";
17. }
18. std::cout << std::endl;
20. return 0;
21. }

复制代码

for_each遍历容器中的每个元素，并对每个元素执行指定的操作。

1. template< class InputIt, class UnaryFunction >
2. UnaryFunction for_each( InputIt first, InputIt last, UnaryFunction f );

复制代码

参数：

• first, last：要遍历的范围

• f：一元函数对象，接受容器中的元素（通过解引用迭代器得到）作为参数，返回值被忽略。

1. #include <iostream>
2. #include <vector>
3. #include <algorithm>
5. int main()
6. {
7. std::vector<int> nums = {1, 2, 3, 4, 5};
9. // 使用lambda打印每个元素
10. std::for_each(nums.begin(), nums.end(), [](int n) {
11. std::cout << n << " ";
12. });
13. // 输出：1 2 3 4 5
15. // 修改每个元素（注意参数为引用）
16. std::for_each(nums.begin(), nums.end(), [](int &n) {
17. n *= 2;
18. });
20. // 再次打印
21. std::for_each(nums.begin(), nums.end(), [](int n) {
22. std::cout << n << " ";
23. });
24. // 输出：2 4 6 8 10
26. return 0;
27. }

复制代码

• for_each可以修改元素，如果lambda参数是引用。

• 可以使用for_each来执行任何不需要返回值的操作。

使用transform转换容器元素

1. #include <iostream>
2. #include <vector>
3. #include <algorithm>
5. int main() {
6. std::vector<int> src = {1, 2, 3, 4, 5};
7. std::vector<int> dst(src.size());
9. // 将 src 中的每个元素加1，并存储到 dst 中
10. std::transform(src.begin(), src.end(), dst.begin(), [](int n) {
11. return n + 1;
12. });
14. for (int num : dst)
15. {
16. std::cout << num << " ";
17. }
18. std::cout << std::endl;
20. return 0;
21. }

复制代码

transform：将函数应用于范围中的每个元素，并将结果存储在另一个范围中（或原地转换）。

1. // 一元操作版本
2. template< class InputIt, class OutputIt, class UnaryOperation >
3. OutputIt transform( InputIt first1, InputIt last1,
4. OutputIt d_first, UnaryOperation unary_op );
6. // 二元操作版本
7. template< class InputIt1, class InputIt2, class OutputIt, class BinaryOperation >
8. OutputIt transform( InputIt1 first1, InputIt1 last1, InputIt2 first2,
9. OutputIt d_first, BinaryOperation binary_op );

复制代码

一元操作：

1. #include <iostream>
2. #include <vector>
3. #include <algorithm>
4. #include <iterator>
6. int main()
7. {
8. std::vector<int> src = {1, 2, 3, 4, 5};
9. std::vector<int> dst;
11. // 将src中每个元素平方，并插入到dst中
12. std::transform(src.begin(), src.end(), std::back_inserter(dst),
13. [](int n) { return n * n; });
15. // 打印dst
16. std::for_each(dst.begin(), dst.end(), [](int n) { std::cout << n << " "; });
17. // 输出：1 4 9 16 25
19. // 原地转换：将src中的每个元素加1
20. std::transform(src.begin(), src.end(), src.begin(),
21. [](int n) { return n + 1; });
23. // 打印src
24. std::for_each(src.begin(), src.end(), [](int n) { std::cout << n << " "; });
25. // 输出：2 3 4 5 6
27. return 0;
28. }

复制代码

二元操作：

1. #include <iostream>
2. #include <vector>
3. #include <algorithm>
4. #include <iterator>
6. int main()
7. {
8. std::vector<int> a = {1, 2, 3, 4, 5};
9. std::vector<int> b = {10, 20, 30, 40, 50};
10. std::vector<int> result;
12. // 将a和b中对应元素相加
13. std::transform(a.begin(), a.end(), b.begin(),
14. std::back_inserter(result),
15. [](int x, int y) { return x + y; });
17. // 打印result
18. std::for_each(result.begin(), result.end(),
19. [](int n) { std::cout << n << " "; });
20. // 输出：11 22 33 44 55
22. return 0;
23. }

复制代码

• transform需要指定目标位置，可以使用back_inserter来在容器尾部插入，或者确保目标容器有足够空间。

• 一元操作和二元操作分别用于一个和两个输入序列。

使用find_if查找满足条件的元素

1. #include <iostream>
2. #include <vector>
3. #include <algorithm>
5. int main()
6. {
7. std::vector<int> numbers = {1, 2, 3, 4, 5, 6};
9. // 查找第一个大于3的元素
10. auto it = std::find_if(numbers.begin(), numbers.end(), [](int n) {
11. return n > 3;
12. });
14. if (it != numbers.end())
15. {
16. std::cout << "找到第一个大于3的元素: " << *it << std::endl;
17. }
18. else
19. {
20. std::cout << "未找到" << std::endl;
21. }
23. return 0;
24. }

复制代码

find_if：在范围内查找第一个满足条件的元素，返回指向该元素的迭代器。

1. template< class InputIt, class UnaryPredicate >
2. InputIt find_if( InputIt first, InputIt last, UnaryPredicate p );

复制代码

1. #include <iostream>
2. #include <vector>
3. #include <algorithm>
5. int main()
6. {
7. std::vector<int> nums = {1, 2, 3, 4, 5, 6};
9. // 查找第一个偶数
10. auto it = std::find_if(nums.begin(), nums.end(),
11. [](int n) { return n % 2 == 0; });
13. if (it != nums.end())
14. {
15. std::cout << "找到偶数: " << *it << std::endl; // 输出：2
16. }
17. else
18. {
19. std::cout << "没有找到偶数" << std::endl;
20. }
22. // 查找第一个大于10的数
23. auto it2 = std::find_if(nums.begin(), nums.end(),
24. [](int n) { return n > 10; });
26. if (it2 == nums.end())
27. {
28. std::cout << "没有找到大于10的数" << std::endl;
29. }
31. return 0;
32. }

复制代码

• 如果找不到，返回last（即结束迭代器）。

• 与之类似的算法有find（查找特定值）、find_if_not（查找第一个不满足条件的）。

使用remove_if和erase删除满足条件的元素

1. #include <iostream>
2. #include <vector>
3. #include <algorithm>
5. int main()
6. {
7. std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9};
9. // 删除所有偶数
10. auto new_end = std::remove_if(numbers.begin(), numbers.end(), [](int n) {
11. return n % 2 == 0;
12. });
14. numbers.erase(new_end, numbers.end());
16. for (int num : numbers)
17. {
18. std::cout << num << " ";
19. }
20. std::cout << std::endl;
22. return 0;
23. }

复制代码

remove_if：将满足条件的元素移动到容器末尾，并返回一个指向新的逻辑末尾的迭代器。注意，它并不真正删除元素，也不改变容器的大小。 erase：真正从容器中删除元素。

1. template< class ForwardIt, class UnaryPredicate >
2. ForwardIt remove_if( ForwardIt first, ForwardIt last, UnaryPredicate p );

复制代码

1. #include <iostream>
2. #include <vector>
3. #include <algorithm>
5. int main()
6. {
7. std::vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8, 9};
9. // 移除所有偶数
10. auto new_end = std::remove_if(nums.begin(), nums.end(),
11. [](int n) { return n % 2 == 0; });
13. // 此时，nums中的元素可能是：1,3,5,7,9,?,?,?,? （?表示未指定，通常是被移除的元素）
14. // 容器大小没有变，但[begin, new_end)是不包含被移除元素的序列
16. // 打印[begin, new_end)范围内的元素
17. std::for_each(nums.begin(), new_end,
18. [](int n) { std::cout << n << " "; });
19. std::cout << std::endl; // 输出：1 3 5 7 9
21. // 真正删除元素，使用erase
22. nums.erase(new_end, nums.end());
24. // 现在容器中只有奇数
25. std::for_each(nums.begin(), nums.end(),
26. [](int n) { std::cout << n << " "; });
27. // 输出：1 3 5 7 9
29. return 0;
30. }

复制代码

• remove_if和erase结合使用来真正删除元素，这被称为“erase-remove”惯用法。

• 对于顺序容器（如vector、deque、string），erase会真正减少容器的大小。

• 对于list，有remove_if成员函数，它可以直接删除元素，效率更高。

使用accumulate进行累加（需要包含）

1. #include <iostream>
2. #include <vector>
3. #include <numeric>
5. int main()
6. {
7. std::vector<int> numbers = {1, 2, 3, 4, 5};
9. // 使用 lambda 表达式进行累加，初始值为0
10. int sum = std::accumulate(numbers.begin(), numbers.end(), 0,
11. [](int acc, int n) {
12. return acc + n;
13. });
15. std::cout << "和为: " << sum << std::endl;
17. return 0;
18. }

复制代码

accumulate：计算给定范围内元素的累积值（求和、求积等），可以指定初始值和二元操作函数。

1. template< class InputIt, class T >
2. T accumulate( InputIt first, InputIt last, T init );
4. template< class InputIt, class T, class BinaryOperation >
5. T accumulate( InputIt first, InputIt last, T init,
6. BinaryOperation op );

复制代码

1. #include <iostream>
2. #include <vector>
3. #include <numeric> // accumulate在此头文件中
5. int main()
6. {
7. std::vector<int> nums = {1, 2, 3, 4, 5};
9. // 求和，初始值为0
10. int sum = std::accumulate(nums.begin(), nums.end(), 0);
11. std::cout << "和: " << sum << std::endl; // 输出：15
13. // 求积，初始值为1
14. int product = std::accumulate(nums.begin(), nums.end(), 1,
15. [](int a, int b) { return a * b; });
16. std::cout << "积: " << product << std::endl; // 输出：120
18. // 拼接字符串
19. std::vector<std::string> words = {"Hello", " ", "World", "!"};
20. std::string concat = std::accumulate(words.begin(), words.end(),
21. std::string(""));
22. std::cout << concat << std::endl; // 输出：Hello World!
24. // 使用自定义操作：将向量中的每个元素乘以2然后累加
25. int double_sum = std::accumulate(nums.begin(), nums.end(), 0,
26. [](int acc, int n) {
27. return acc + n * 2;
28. });
29. std::cout << "每个元素乘以2后求和: " << double_sum << std::endl; // 输出：30
31. return 0;
32. }

复制代码

• accumulate的初始值类型决定了返回类型，所以要注意选择合适的初始值类型（比如求和时初始值为0，求积时为1）。

• 二元操作函数接受两个参数：第一个是当前的累积值，第二个是当前元素。

6 现代c++常用特性

6.1 auto类型推导

auto类型推导的基本规则：

1. auto在推导类型时，会忽略顶层const（即变量本身是常量，但指向的对象可以是常量也可以不是），但会保留底层const（例如指针所指向的对象是常量）。

2. 当使用auto声明引用时，auto会保留表达式的引用类型和const属性。

3. 当使用auto声明指针时，auto会推导出指针类型，但也会保留底层const。

auto必须初始化：

1. auto x; // 错误：必须初始化
2. auto y = 10; // 正确

复制代码

何时使用auto的最佳实践：

1. // 推荐使用auto
2. auto result = calculateValue(); // 类型可能很复杂
3. for (auto& item : container) // 范围循环
4. auto ptr = std::make_unique<MyClass>(); // 智能指针
6. // 可能需要明确类型
7. int count = 10; // 基本类型更清晰
8. float pi = 3.14f; // 明确使用float而不是double

复制代码

6.2 范围for循环

使用for(auto& x : vec)时，我们声明了一个引用类型，这意味着：

1. 我们不会复制容器中的每一个元素，而是直接引用元素本身。

2. 因此，如果修改x，就会修改容器中对应的元素（因为x是引用）。

3. 同时，因为避免了拷贝，对于大型对象或容器，使用引用可以提高效率。

但是，如果只是读取元素而不修改，通常使用const引用，即for(const auto& x : vec)，以避免不必要的拷贝并且保护元素不被修改。

1. std::vector<int> vec = {1, 2, 3, 4, 5};
3. // 1. 引用方式（可以修改元素）
4. for (auto& x : vec)
5. {
6. x *= 2; // 修改原始元素
7. }
9. // 2. 常量引用方式（只读，高效）
10. for (const auto& x : vec)
11. {
12. // x *= 2; // 错误：不能修改
13. std::cout << x << " ";
14. }
16. // 3. 值拷贝方式（创建副本，不能修改原始元素）
17. for (auto x : vec)
18. {
19. x = 100; // 只修改副本，不影响vec
20. }
22. // 4. 显式指定类型
23. for (int& x : vec)
24. { // 明确知道类型时
25. x += 10;
26. }

复制代码

6.3 constexpr编译期计算

C++中的constexpr关键字用于指示一个值或函数可以在编译时计算。

constexpr变量：必须在编译时初始化，并且其值必须是编译时常量。

1. constexpr int size = 10; // 正确，编译时常量
2. constexpr double pi = 3.1415926; // 正确
4. int n = 20;
5. constexpr int sz = n; // 错误，n不是编译时常量

复制代码

constexpr函数：是指能用于常量表达式的函数。在C++11中，constexpr函数只能包含一条return语句，而C++14放宽了限制。

1. //c++11
2. constexpr int factorial(int n)
3. {
4. return n <= 1 ? 1 : (n * factorial(n - 1));
5. }
7. // 使用
8. constexpr int fact5 = factorial(5); // 编译时计算，结果为120
10. //c++14
11. constexpr int factorial(int n)
12. {
13. int result = 1;
14. for (int i = 1; i <= n; ++i)
15. {
16. result *= i;
17. }
18. return result;
19. }
21. constexpr int fact5 = factorial(5); // 编译时计算

复制代码

constexpr函数的参数不一定必须是编译时常量。如果传入非常量参数，则函数在运行时计算。

constexpr指针：常量指针，即指针本身是常量，而不是所指向的对象是常量。

1. int x = 10;
2. constexpr int* p = &x; // p是一个常量指针，指向x
3. // 注意：这里x的地址必须在编译时已知，但x不是constexpr变量，所以&x不是常量表达式，因此实际上这行代码会编译错误。
5. constexpr int y = 20;
6. constexpr const int* q = &y; // q是一个指向常量的常量指针，且&y是常量表达式

复制代码

constexpr构造函数：

1. class Point
2. {
3. public:
4. constexpr Point(double x = 0, double y = 0) : x_(x), y_(y) {}
5. constexpr double x() const { return x_; }
6. constexpr double y() const { return y_; }
7. // C++14允许constexpr函数修改成员变量
8. constexpr void setX(double x) { x_ = x; }
9. constexpr void setY(double y) { y_ = y; }
10. private:
11. double x_, y_;
12. };
14. // 使用
15. constexpr Point p(1.0, 2.0); // 编译时创建Point对象
16. constexpr double x = p.x(); // 编译时调用成员函数

复制代码

编译期计算的优势：

1. 性能提升：将计算从运行时移到编译时，减少运行时间。

2. 类型安全：编译时计算可以捕获更多错误。

3. 可用于模板元编程：constexpr函数可以替代部分模板元编程。

注意事项：

• constexpr变量和函数必须非常简单，通常只能使用其他constexpr变量和函数。

• constexpr函数可以同时用于编译时和运行时，但编译时必须传入常量表达式参数。

• 在C++11中，constexpr函数体只能有一条语句，但可以是return语句和条件运算符组成的复杂表达式。

7 拷贝/移动语义

7.1 深拷贝 vs 浅拷贝

浅拷贝（Shallow Copy）

• 浅拷贝只复制对象的成员变量的值，包括指针的值（即地址），而不复制指针所指向的内存。

• 这意味着，原对象和拷贝对象中的指针成员将指向同一块内存。

• 当其中一个对象修改了这块内存，另一个对象也会受到影响。

• 如果其中一个对象销毁时释放了这块内存，另一个对象的指针就成了悬空指针（dangling pointer），再次访问或释放会导致未定义行为。

深拷贝（Deep Copy）

• 深拷贝不仅复制对象的成员变量，还会为指针成员分配新的内存，并复制指针所指向的数据。

• 这样，原对象和拷贝对象拥有各自独立的内存空间，互不影响。

• 深拷贝通常需要在拷贝构造函数和赋值运算符中显式实现。

注意事项：

1. 默认的拷贝构造函数和赋值运算符执行的是浅拷贝。

2. 如果类中有指针成员，并且指向动态分配的内存，通常需要实现深拷贝以避免双重释放和悬空指针的问题。

3. 在C++中，实现深拷贝时，通常需要同时实现拷贝构造函数、赋值运算符和析构函数（这被称为“三法则”）。在C++11以后，还有移动语义（移动构造函数和移动赋值运算符）需要考虑（“五法则”或“六法则”）。

三法则（Rule of Three）

如果一个类需要显式定义以下其中之一，那么它很可能需要显式定义所有三个：

• 析构函数

• 拷贝构造函数

• 拷贝赋值运算符

五法则（Rule of Five）

在C++11中，由于移动语义的引入，可以扩展为五法则：

• 析构函数

• 拷贝构造函数

• 拷贝赋值运算符

• 移动构造函数

• 移动赋值运算符

需要深拷贝的情况：

1. 类包含原始指针，指向动态分配的内存

2. 类管理文件句柄、网络连接等资源

3. 需要独立副本，修改副本不影响原对象

不需要深拷贝的情况：

1. 所有成员都是基本类型（int, double等）

2. 成员使用智能指针（shared_ptr, unique_ptr）

3. 对象是不可变的

4. 使用移动语义可以避免拷贝

建议优先使用智能指针，避免手动内存管理，减少深拷贝的必要性；对于资源密集型对象，实现移动构造函数和移动赋值运算符。

7.2 右值引用与move

• 左值（lvalue）：指表达式结束后依然存在的对象，可以取地址。

• 右值（rvalue）：指表达式结束时就不再存在的临时对象，不能取地址。

右值引用使用两个&符号表示，例如int&&。右值引用只能绑定到右值（临时对象）。

1. int a = 10; // a 是左值
2. int&& rref = 10; // 10 是右值，rref 是右值引用
3. int&& rref2 = a; // 错误！不能将左值绑定到右值引用
5. // 正确：std::move 将左值转换为右值引用
6. int&& rref3 = std::move(a);

复制代码

移动语义允许将资源（如堆内存）从一个对象转移到另一个对象，从而避免深拷贝。通常通过移动构造函数和移动赋值运算符实现。

移动构造函数接受一个右值引用参数，并“窃取”该参数的资源，然后将该参数置于有效但不确定的状态（通常为空）。

1.  class MyString
2.  {
3.  private:
4.   char* data;
5.   size_t length;
6.  ​
7.  public:
8.   // 移动构造函数
9.   MyString(MyString&& other) noexcept
10.   : data(other.data), length(other.length)
11.   {
12.   other.data = nullptr;
13.   other.length = 0;
14.   }
15.  ​
16.   // 移动赋值运算符
17.   MyString& operator=(MyString&& other) noexcept
18.   {
19.   if (this != &other)
20.   {
21.   delete[] data; // 释放当前资源
22.   data = other.data;
23.   length = other.length;
24.   other.data = nullptr;
25.   other.length = 0;
26.   }
27.   return *this;
28.   }
29.  ​
30.   // 其他成员函数...
31.  };

复制代码

std::move是一个函数模板，它将左值转换为右值引用，从而允许使用移动语义。注意，使用std::move后，原对象的状态将被改变，因此通常不再使用原对象（除非重新赋值）。

1.  #include <utility> // std::move
2.  ​
3.  std::string str1 = "Hello";
4.  std::string str2 = std::move(str1); // 移动构造
5.  ​
6.  // 此时 str1 变为有效但未指定的状态
7.  // 通常为空，但不能依赖其内容

复制代码

• std::move 不移动任何东西

• 只是将左值转换为右值引用，告诉编译器"这个对象可以被移动"

完美转发允许函数模板将其参数以原有的值类别（左值或右值）转发给其他函数。这通过使用右值引用和std::forward实现。

1. template<typename T>
2.  void wrapper(T&& arg)
3.  {
4.   // arg 是通用引用（既可以绑定左值也可以绑定右值）
5.   // std::forward 保持参数原有的值类别
6.   process(std::forward<T>(arg));
7.  }
8.  ​
9.  void process(int& x)
10.  {
11.   std::cout << "左值: " << x << std::endl;
12.  }
13.  ​
14.  void process(int&& x)
15.  {
16.   std::cout << "右值: " << x << std::endl;
17.  }
18.  ​
19.  int main()
20.  {
21.   int a = 10;
22.   wrapper(a); // 调用左值版本
23.   wrapper(20); // 调用右值版本
24.   wrapper(std::move(a)); // 调用右值版本
25.  }

复制代码

• 移动后的对象处于有效但不确定的状态，通常可以重新赋值或析构。

• 对于内置类型，移动和拷贝相同，没有性能提升。

• 移动操作通常应标记为noexcept，以允许标准库容器在重新分配内存时使用移动而非拷贝（例如std::vector）。

注意：

• 使用noexcept标记移动操作，确保不会抛出异常

• 移动后对象应处于有效状态：通常为空或者默认状态

• 不要过度使用move

• 在需要资源转移时使用移动语义

• 实现移动构造函数后，应考虑删除拷贝操作（如果需要）

7.3 移动构造函数

移动构造函数是C++11引入的一种特殊构造函数，用于将资源从一个对象移动到另一个对象，而不是进行深拷贝。移动构造函数通常接受一个右值引用作为参数，并且会“窃取”参数中的资源，然后将参数置于有效但不可用的状态（通常为空）。

1. class MyClass
2. {
3. public:
4. // 移动构造函数
5. MyClass(MyClass&& other) noexcept
6. {
7. // 转移资源
8. data = other.data;
9. size = other.size;
10. // 将原对象置于有效状态（通常为空）
11. other.data = nullptr;
12. other.size = 0;
13. }
14. };

复制代码

移动构造函数的几个要点：

1. 参数类型：必须是同类型的右值引用，即 MyClass&&。

2. 通常不会抛出异常，因此应该用 noexcept 修饰，这对于标准库容器在重新分配内存时使用移动而非拷贝很重要。

3. 移动构造函数会“窃取”源对象的资源，然后将源对象的资源指针置为空（或其他合适的状态），这样源对象的析构函数就不会释放这些资源了。

移动构造函数的使用场景：

• 当用一个临时对象初始化另一个对象时。

• 当使用 std::move 将一个左值转换为右值，然后用于初始化时。

移动构造函数与拷贝构造函数的区别：

• 拷贝构造函数会复制资源，两个对象独立。

• 移动构造函数只是转移资源，移动后源对象不再拥有资源。

如果类没有定义移动构造函数，编译器可能会自动生成一个（在某些条件下），但自动生成的移动构造函数只是简单地移动每个成员变量（对于内置类型就是拷贝，对于类类型则调用其移动构造函数）。如果类有自定义的拷贝构造函数、拷贝赋值运算符或析构函数，编译器不会自动生成移动构造函数。这时，如果需要移动操作，就必须自己定义。

8 异常安全与设计模式

8.1 try_catch正确用法（不滥用）

避免滥用的准则：

• 不要用异常替代正常控制流

• 不要捕获所有异常而不处理

• 最小化try块范围

应该使用异常的情况：

• 构造函数失败

• 资源获取失败（文件、网格、内存等）

• 程序状态无法恢复的错误

• 库/API的边界处

不应该使用异常的情况：

• 正常的控制流程

• 频繁发生的错误（使用返回值）

• 性能关键的代码路径

• 析构函数（通常）

• 信号处理程序

8.2 noexcept关键字

• noexcept：表示函数不会抛出任何异常。

• noexcept(expression)：如果expression为true，则函数不会抛出异常；如果为false，则可能抛出异常。

1. void myFunction() noexcept; // 保证不抛出异常
3. void anotherFunction() noexcept(true); // 同上，明确指定不抛出
5. void yetAnotherFunction() noexcept(false); // 可能抛出异常

复制代码

为什么使用 noexcept：

1. 性能优化：编译器知道函数不会抛出异常后，可以生成更高效的代码，因为不需要处理异常抛出的情况。

1. // 编译器可以为noexcept函数生成更高效的代码
2. void optimizedFunction() noexcept
3. {
4. // 编译器知道不会抛出异常，可以：
5. // 1. 减少异常处理表的生成
6. // 2. 进行更多内联优化
7. // 3. 减少栈展开代码
8. for (int i = 0; i < 1000; ++i)
9. {
10. // 密集计算
11. }
12. }

复制代码

1. 移动操作和析构函数：标准库中的一些操作（如std::vector的重新分配）会使用移动操作（如果它们被标记为noexcept），否则会使用拷贝操作。因此，将移动构造函数和移动赋值运算符标记为noexcept可以提高性能。

2. 代码清晰性：明确告诉其他开发者该函数不会抛出异常，简化错误处理。

注意事项：

1. 违反noexcept说明：如果函数被标记为noexcept但抛出了异常，程序会调用std::terminate()终止。因此，确保noexcept函数真的不会抛出异常。

2. 析构函数：析构函数默认是noexcept的，除非显式指定为noexcept(false)。通常，析构函数不应该抛出异常。

3. 移动操作：如果移动操作可能抛出异常，那么它不应该被标记为noexcept，因为异常安全很难保证。

应该使用noexcept的情况：

• 析构函数（默认就是）

• 移动构造函数和移动赋值运算符

• 交换（swap）操作

• 简单访问器和修改器（getter/setter）

• 数学计算和纯函数

• 内存操作（如memcpy的包装）

不应该使用noexcept的情况：

• 可能失败的资源获取（文件、网络、内存）

• 可能抛出异常的算法

• 用户提供的回调函数

• 复杂业务逻辑函数

与throw（）的区别： 在C++11之前，使用throw()来指定函数不抛出异常。但是，如果函数抛出了异常，会调用std::unexpected()，这通常会导致程序终止。C++11中，noexcept更高效，因为编译器不需要为noexcept函数准备异常传播的代码。throw()在C++11中被废弃，在C++17中被移除。为了兼容，C++11中noexcept等同于noexcept(true)，而throw()等同于noexcept(false)。

8.3 接口设计原则（Pimpl模式隐藏细节）

在C++中，Pimpl（Pointer to Implementation，指向实现的指针）模式是一种用来隐藏类实现细节的技术。它通过将类的实现细节（私有成员）移动到一个单独的类中，并在原类中仅保留一个指向该实现类的指针来实现。这样，原类的头文件就只需要包含实现类的声明，而不需要包含实现类所需的任何头文件，从而减少了编译依赖，加快了编译速度，并且隐藏了实现细节。

Pimpl模式的基本步骤：

1. 在头文件中声明一个实现类（通常是一个嵌套类，但也可以是非嵌套的）的前向声明，然后声明一个指向该实现类的指针（通常使用智能指针，如std::unique_ptr）。

2. 在源文件中定义实现类，并实现原类的成员函数，这些成员函数通过操作实现类来完成功能。

不使用pimpl模式时：

1. // widget.h
2. #include <string>
3. #include <vector>
5. class Widget
6. {
7. public:
8. Widget();
9. ~Widget();
10. void doSomething();
11. private:
12. std::string name;
13. std::vector<int> data;
14. // 其他私有成员，可能涉及更多的头文件包含
15. };

复制代码

使用pimpl模式后：

1. // widget.h
2. #include <memory>
4. class Widget
5. {
6. public:
7. Widget();
8. ~Widget(); // 需要声明，因为std::unique_ptr需要知道析构函数
9. Widget(Widget&&) = default; // 移动构造
10. Widget& operator=(Widget&&) = default; // 移动赋值
11. // 注意：需要禁止拷贝构造和拷贝赋值，或者实现深拷贝（因为unique_ptr不可拷贝）
12. Widget(const Widget&) = delete;
13. Widget& operator=(const Widget&) = delete;
15. void doSomething();
16. private:
17. class Impl; // 前向声明
18. std::unique_ptr<Impl> pImpl;
19. };
21. // widget.cpp
22. #include "widget.h"
23. #include <string>
24. #include <vector>
26. //在源文件中定义Impl类并实现Widget的成员函数
27. class Widget::Impl
28. {
29. public:
30. std::string name;
31. std::vector<int> data;
32. // 其他私有成员
33. };
35. Widget::Widget() : pImpl(std::make_unique<Impl>()) {}
37. // 必须定义析构函数，因为Impl是不完整类型，而unique_ptr的默认析构需要完整类型
38. // 但是，如果使用std::unique_ptr，我们需要在Widget的析构函数之前知道Impl的完整类型
39. // 因此，在widget.cpp中，Impl已经定义，所以析构函数可以正常编译。
40. Widget::~Widget() = default;
42. void Widget::doSomething()
43. {
44. // 通过pImpl访问实现
45. pImpl->name = "example";
46. pImpl->data.push_back(42);
47. }

复制代码

注意：由于使用了std::unique_ptr，我们需要在头文件中声明析构函数，并在源文件中实现（即使它是默认的）。这是因为std::unique_ptr的析构函数需要知道Impl的完整类型，而在头文件中，Impl只是一个前向声明，所以编译器无法生成默认的析构函数。因此，我们必须在Impl类定义之后（即在源文件中）定义析构函数。

另外，需要注意的是，由于使用了std::unique_ptr，Widget类默认是不支持拷贝的（因为std::unique_ptr不可拷贝）。如果需要支持拷贝，需要手动实现拷贝构造函数和拷贝赋值运算符，对Impl进行深拷贝。

Pimpl模式的优点：

1. 隐藏实现细节，减少头文件暴露的信息。

2. 减少编译依赖，提高编译速度。当头文件发生变化时，只有直接依赖它的文件需要重新编译。

3. 接口与实现分离，提高封装性。

缺点：

1. 代码变得复杂，需要额外的指针间接访问，可能带来性能上的微小开销。

2. 内存分配和释放开销（可以使用自定义分配器来优化）。

3. 调试可能变得更困难，因为实现细节被隐藏。

9 并发与内存模型

9.1 thread与async

std::thread是C++11引入的线程库的一部分，它代表一个单独的执行线程。创建std::thread对象时，会启动一个新的线程来执行给定的函数或可调用对象。

1. #include <iostream>
2. #include <thread>
4. void hello()
5. {
6. std::cout << "Hello from thread!" << std::endl;
7. }
9. int main()
10. {
11. std::thread t(hello);
12. t.join(); // 等待线程结束
13. return 0;
14. }

复制代码

1. #include <iostream>
2. #include <thread>
4. void compute(int& result)
5. {
6. result = 42;
7. }
9. int main()
10. {
11. int result = 0;
12. std::thread t(compute, std::ref(result));//通过引用传递来获取结果，并且需要手动同步（这里使用了join，所以没有问题）
13. t.join();
14. std::cout << "Result: " << result << std::endl;
15. return 0;
16. }

复制代码

特点：

• 直接管理线程的生命周期。

• 需要显式地决定是等待线程完成（join）还是分离线程（detach）。

• 如果既不join也不detach，在析构时会调用std::terminate。

• 线程间的数据共享需要手动同步（使用互斥锁等）

std::async是一个更高层次的抽象，它用于异步执行任务，并返回一个std::future对象，该对象最终将持有函数的返回值。std::async可以选择立即启动线程（异步执行）或者延迟执行（直到future被请求结果时才执行）

1. #include <iostream>
2. #include <future>
4. int compute()
5. {
6. return 42;
7. }
9. int main()
10. {
11. std::future<int> result = std::async(std::launch::async, compute);//通过future直接获取返回值，更加简洁安全
12. std::cout << "Result: " << result.get() << std::endl;
13. return 0;
14. }

复制代码

启动策略：

• std::launch::async：立即异步执行。

• std::launch::deferred：延迟执行，直到在future上调用get()或wait()。

• 默认策略（不指定）可能是两者的组合，由实现决定。

总结：

• 选择 std::thread 当需要直接控制线程，处理I/O密集型或长时间运行的任务

• 选择 std::async 当需要获取计算结果，处理计算密集型的短期任务，或想简化并发代码

注意：

1. 使用std::thread时，要确保线程在结束前被正确join或detach，否则程序会终止。

2. 使用std::async时，要注意默认启动策略可能不是立即异步执行，如果需要确保异步，显式指定std::launch::async。

3. std::async返回的future在析构时会阻塞等待任务完成（如果任务是异步执行的），这有时会导致意外的阻塞。如果不需要结果，可以存储future对象以避免阻塞。

9.2 互斥锁

互斥锁用于保护共享数据免受多个线程同时访问，从而避免数据竞争和不一致性。

互斥锁类型：

1. std::mutex：最基本的互斥锁，不可递归，即同一线程不可重复锁定。

2. std::recursive_mutex：递归互斥锁，同一线程可以多次锁定，但需要相同次数的解锁。

3. std::timed_mutex：带超时功能的互斥锁，允许尝试锁定一段时间或直到某个时间点。

4. std::recursive_timed_mutex：带超时功能的递归互斥锁。

锁定方法：

• lock()：锁定互斥锁，如果已被锁定则阻塞。

• try_lock()：尝试锁定互斥锁，如果已被锁定则立即返回false，否则锁定并返回true。

• unlock()：解锁互斥锁。

互斥锁管理类（RAII）：

为了避免忘记解锁互斥锁，C++提供了几种基于RAII的类，在构造时锁定互斥锁，在析构时自动解锁。

1. std::lock_guard：简单的RAII互斥锁包装器，构造时锁定，析构时解锁。不提供手动锁定和解锁接口。

2. std::unique_lock：更灵活的RAII互斥锁包装器，允许延迟锁定、提前解锁以及转移所有权。它还可以与条件变量一起使用。

1. #include <iostream>
2. #include <thread>
3. #include <mutex>
5. std::mutex mtx;
6. int shared_data = 0;
8. void increment()
9. {
10. for (int i = 0; i < 100000; ++i)
11. {
12. std::lock_guard<std::mutex> lock(mtx); // 构造时锁定，析构时解锁
13. ++shared_data;
14. }
15. }
17. int main()
18. {
19. std::thread t1(increment);
20. std::thread t2(increment);
22. t1.join();
23. t2.join();
25. std::cout << "shared_data = " << shared_data << std::endl;
26. return 0;
27. }

复制代码

1. #include <iostream>
2. #include <thread>
3. #include <mutex>
5. std::mutex mtx;
6. int shared_data = 0;
8. void increment()
9. {
10. for (int i = 0; i < 100000; ++i)
11. {
12. std::unique_lock<std::mutex> lock(mtx); // 类似于lock_guard，但更灵活
13. ++shared_data;
14. // 可以提前解锁
15. lock.unlock();
16. // 做一些不需要互斥锁的操作
17. }
18. }
20. int main()
21. {
22. std::thread t1(increment);
23. std::thread t2(increment);
25. t1.join();
26. t2.join();
28. std::cout << "shared_data = " << shared_data << std::endl;
29. return 0;
30. }

复制代码

1. #include <iostream>
2. #include <thread>
3. #include <mutex>
5. std::mutex mtx;
7. void try_lock_example(int id)
8. {
9. if (mtx.try_lock())
10. {
11. std::cout << "Thread " << id << " locked successfully.\n";
12. // 模拟一些工作
13. std::this_thread::sleep_for(std::chrono::milliseconds(100));
14. mtx.unlock();
15. }
16. else
17. {
18. std::cout << "Thread " << id << " failed to lock.\n";
19. }
20. }
22. int main()
23. {
24. std::thread t1(try_lock_example, 1);
25. std::thread t2(try_lock_example, 2);
27. t1.join();
28. t2.join();
30. return 0;
31. }

复制代码

1. #include <iostream>
2. #include <thread>
3. #include <mutex>
4. #include <chrono>
6. std::timed_mutex mtx;
8. void timed_lock_example(int id)
9. {
10. // 尝试锁定最多100毫秒
11. if (mtx.try_lock_for(std::chrono::milliseconds(100)))
12. {
13. std::cout << "Thread " << id << " locked successfully.\n";
14. std::this_thread::sleep_for(std::chrono::milliseconds(200));
15. mtx.unlock();
16. }
17. else
18. {
19. std::cout << "Thread " << id << " failed to lock within 100ms.\n";
20. }
21. }
23. int main()
24. {
25. std::thread t1(timed_lock_example, 1);
26. std::thread t2(timed_lock_example, 2);
28. t1.join();
29. t2.join();
31. return 0;
32. }

复制代码

互斥锁与条件变量（std::condition_variable）一起使用，条件变量允许线程等待某个条件成立。

1. #include <iostream>
2. #include <thread>
3. #include <mutex>
4. #include <condition_variable>
6. std::mutex mtx;
7. std::condition_variable cv;
8. bool ready = false;
10. void worker_thread()
11. {
12. std::unique_lock<std::mutex> lock(mtx);
13. cv.wait(lock, []{ return ready; }); // 等待ready为true
14. std::cout << "Worker thread is processing...\n";
15. }
17. int main()
18. {
19. std::thread worker(worker_thread);
21. // 模拟一些准备工作
22. std::this_thread::sleep_for(std::chrono::seconds(1));
23. {
24. std::lock_guard<std::mutex> lock(mtx);
25. ready = true;
26. }
27. cv.notify_one(); // 通知等待的线程
29. worker.join();
30. return 0;
31. }

复制代码

9.3 死锁预防

要发生死锁，必须同时满足以下四个条件：

1. 互斥条件：资源不能被共享，只能独占使用

2. 持有并等待：线程持有资源并等待其他资源

3. 不可抢占：资源不能被强制剥夺

4. 循环等待：存在线程的循环等待链

死锁预防是并发编程中的重要课题。在实际编程中，最常用且有效的方法是：

• 固定顺序加锁：简单有效，但有时难以维护顺序。

• 使用std::lock同时锁定：C++标准库提供的工具，非常方便。

• 使用超时锁：避免永久等待，但可能导致活锁（线程一直在重试）。

避免死锁的关键原则：关键原则：

1. 最少锁原则：只在必要时使用锁

2. 最短时间原则：持有锁的时间尽可能短

3. 固定顺序原则：始终按相同顺序获取锁

4. 单层锁定原则：避免嵌套锁

5. 超时退避原则：为锁操作设置超时

9.4 原子操作

原子操作是并发编程中的一个核心概念，它指的是一个或多个操作的执行是不可中断的，即这些操作要么全部执行完成，要么都不执行，并且不会出现部分执行的状态。原子操作在多线程环境中尤为重要，因为它们可以用于实现无锁数据结构、计数器等，避免使用互斥锁带来的开销和潜在的死锁问题。

创建原子对象：

1. #include <atomic>
3. // 基本整型原子类型
4. std::atomic<int> atomic_int;
5. std::atomic<long> atomic_long;
6. std::atomic<bool> atomic_bool;
7. std::atomic<char> atomic_char;
9. // 浮点型原子类型（C++20）
10. std::atomic<float> atomic_float;
11. std::atomic<double> atomic_double;
13. // 指针原子类型
14. std::atomic<int*> atomic_ptr;
16. // 用户自定义类型（需要满足一定条件）
17. struct Point
18. {
19. int x, y;
20. };
21. std::atomic<Point> atomic_point;

复制代码

基本操作接口：

1. std::atomic<int> value(0);
3. // 基本操作
4. value.store(42); // 原子存储
5. int x = value.load(); // 原子加载
6. int old = value.exchange(100); // 原子交换
8. // 算术运算
9. int prev = value.fetch_add(5); // 原子加
10. prev = value.fetch_sub(3); // 原子减
11. prev = value.fetch_and(0xFF); // 原子与
12. prev = value.fetch_or(0x01); // 原子或
13. prev = value.fetch_xor(0x0F); // 原子异或
15. // 比较交换操作（CAS - Compare And Swap）
16. int expected = 50;
17. bool success = value.compare_exchange_weak(expected, 60);
18. // 如果 value == expected，则设置为60，否则 expected 被更新为当前值

复制代码

9.4.1 内存顺序

宽松顺序：

在线程1中，操作A和操作B是两个独立的原子操作，它们之间没有依赖关系。在宽松内存顺序下，编译器和CPU可能会重排这两个操作，即先执行操作B，再执行操作A。

在线程2中，操作C和操作D也是两个独立的原子操作，但是操作C循环等待y变为1，所以操作D必须在操作C完成后执行。

1. std::atomic<int> x(0), y(0);
2. int r1, r2;
4. // 线程1
5. x.store(1, std::memory_order_relaxed);
6. y.store(1, std::memory_order_relaxed);
8. // 线程2
9. while (y.load(std::memory_order_relaxed) != 1) {}
10. r1 = x.load(std::memory_order_relaxed);
12. // 问题：r1 可能为0吗？是的！因为宽松顺序不保证可见性顺序

复制代码

获取-释放顺序：

获取-释放顺序用于在同一个原子变量上建立同步关系。一个线程使用 release 语义存储一个值，另一个线程使用 acquire 语义加载该值，那么第一个线程中在 store 之前的所有写操作，在第二个线程中 load 之后都是可见的。

1. std::atomic<int> flag(0);
2. int data = 0;
4. // 线程1：生产者
5. data = 42; // 1
6. flag.store(1, std::memory_order_release); // 2
8. // 线程2：消费者
9. while (flag.load(std::memory_order_acquire) == 0) {} // 3
10. int result = data; // 4，这里保证看到 data = 42
12. // 关键保证：1 happens-before 2 synchronizes-with 3 happens-before 4

复制代码

顺序一致性：

顺序一致性保证了所有线程看到的操作顺序是一致的，且与代码顺序一致。但是，它也是性能开销最大的一种。

1. std::atomic<int> x(0), y(0);
2. int r1, r2;
4. // 线程1
5. x.store(1, std::memory_order_seq_cst); // A
6. r1 = y.load(std::memory_order_seq_cst); // B
8. // 线程2
9. y.store(1, std::memory_order_seq_cst); // C
10. r2 = x.load(std::memory_order_seq_cst); // D
12. // 保证：不可能出现 r1 == 0 && r2 == 0
13. // 所有seq_cst操作构成一个全序

复制代码

9.4.2 比较交换（CAS）

比较并交换（Compare and Swap）是原子操作中非常重要的一种操作，它用于实现无锁数据结构。CAS 操作会检查原子对象的当前值是否等于期望值，如果相等，则将其设置为新值。

C++ 提供了两个版本的 CAS：compare_exchange_weak 和 compare_exchange_strong。

• compare_exchange_weak：可能会虚假失败（即即使当前值等于期望值，也可能返回 false），但性能可能更好。通常用在循环中。

• compare_exchange_strong：不会虚假失败，但可能性能稍差。

1. std::atomic<int> value(10);
2. int expected = 10;
3. bool success = value.compare_exchange_strong(expected, 20);
4. // 如果 value 当前为10，则将其设置为20，success 为 true，expected 不变（仍为10）
5. // 否则，将 expected 更新为 value 的当前值，success 为 false

复制代码