阿Q技术站

深浅色

C++ 面试试题库 ​

1. C++ 基础 ​

1.1 指针与引用 ​

1.1.1 指针与引用的核心区别 ​

在 C++ 中，指针（Pointer）和引用（Reference）是两种用于间接访问变量的机制，但它们在语法、行为和安全性方面存在根本性的差异。理解这些差异对于编写高效且安全的 C++ 代码至关重要。首先，从定义上看，指针是一个变量，其存储的是另一个变量的内存地址。这意味着指针本身占用内存空间，并且可以被重新赋值，使其指向不同的内存地址，甚至可以被赋值为 nullptr（或 NULL），表示它不指向任何有效的内存地址。这种灵活性使得指针在动态内存管理、数组操作和实现复杂数据结构（如链表、树）时非常有用。然而，这种灵活性也带来了风险，例如，解引用一个空指针或野指针（未初始化的指针）会导致未定义行为，通常是程序崩溃。相比之下，引用是变量的别名，它在声明时必须被初始化，并且一旦绑定到一个对象，就不能再改变其绑定关系。引用本身不占用额外的内存（尽管在某些实现中，编译器可能会为引用分配存储空间，但这在语义上是不可见的），它仅仅是已存在变量的一个替代名称。因此，引用不能为空，必须始终引用一个有效的对象。这种特性使得引用在函数参数传递和返回值中非常安全，因为它避免了空指针检查的需要，并且语法上更简洁，更接近于直接操作变量本身 。

从语法层面来看，指针和引用的使用方式也不同。指针使用 * 符号进行声明和解引用，使用 & 符号获取变量的地址。例如，int* p = &x; 声明了一个指向 int 类型的指针 p，并将其初始化为变量 x 的地址。要访问 p 所指向的值，需要使用解引用操作符 *，如 *p = 10;。而引用则使用 & 符号进行声明，但在使用时与普通变量无异。例如，int& r = x; 声明了一个 int 类型的引用 r，并将其绑定到变量 x。此后，任何对 r 的操作都等同于对 x 的操作。这种语法上的简洁性使得代码更具可读性，尤其是在函数参数传递时。例如，一个接受 int& 类型参数的函数可以直接修改传入的变量，而无需使用指针的解引用语法。此外，指针可以进行算术运算（如 p++），这在处理数组时非常有用，而引用则不支持算术运算，因为它不是一个独立的内存地址，只是一个别名。

在安全性方面，引用通常被认为是比指针更安全的选项。由于引用不能为空且不能重新绑定，它有效地避免了许多与指针相关的常见错误，如空指针解引用、野指针访问和内存泄漏（当指针被重新赋值而忘记释放其原先指向的内存时）。引用的行为更像是一个“安全”的指针，它提供了指针的间接访问能力，同时限制了其潜在的危险操作。然而，这并不意味着引用可以完全替代指针。在某些场景下，指针的灵活性是不可或缺的。例如，当需要动态分配数组、实现数据结构或在函数中需要返回多个值时，指针仍然是首选。此外，指针可以与 const 关键字结合使用，以提供不同级别的保护，例如 const int* p 表示指针指向的内容是常量，而 int* const p 表示指针本身是常量。这种细粒度的控制是引用所不具备的。总而言之，指针和引用各有其优势和适用场景。指针提供了强大的灵活性和底层控制能力，但需要开发者承担更高的责任来确保其正确和安全的使用。引用则提供了一种更安全、更简洁的间接访问方式，适用于大多数需要传递大型对象或避免拷贝的场景，是现代 C++ 编程中更受推崇的选择。

1.1.2 指针与引用的使用场景 ​

指针和引用在 C++ 中虽然都用于间接访问对象，但它们的设计哲学和适用场景有着显著的不同。选择使用哪一个，通常取决于对性能、安全性和代码可读性的权衡。引用（Reference）的主要优势在于其安全性和简洁的语法。由于引用在初始化后不能改变其绑定的对象，并且不能为空，它有效地防止了空指针解引用和悬挂指针等常见错误。这使得引用成为函数参数传递的理想选择，特别是当函数需要修改传入的参数时。通过使用引用传递（pass-by-reference），可以避免对象的拷贝，从而提高性能，尤其是对于大型对象。例如，一个接受 std::string& 参数的函数可以直接修改原始字符串，而无需创建副本。此外，当函数不需要修改参数时，使用 const 引用（如 const std::string&）是一种非常好的实践，它既能避免拷贝，又能保证参数在函数内部不被意外修改，同时向调用者清晰地传达了函数的意图。在操作符重载中，返回引用也是常见的做法，例如，链式调用的赋值操作符 = 通常会返回 *this 的引用，以支持 a = b = c; 这样的表达式。

相比之下，指针（Pointer）提供了更大的灵活性和底层控制能力，这使得它在某些特定场景下是不可或缺的。首先，指针可以为 nullptr，这在表示“无对象”或“可选对象”时非常有用。例如，一个函数可以返回一个指针，如果操作成功则返回指向新创建对象的指针，如果失败则返回 nullptr。这种用法在 C++ 标准库中也很常见，如 dynamic_cast 在转型失败时会返回空指针。其次，指针支持算术运算，这使得它成为处理数组和动态内存块的强大工具。通过指针的递增和递减，可以高效地遍历数组元素。在实现动态数据结构（如链表、树、图）时，指针的灵活性更是至关重要，因为节点之间的关系需要在运行时动态地建立和修改。此外，当需要与 C 语言库进行交互时，指针是主要的接口，因为 C 语言中没有引用的概念。在这种情况下，必须使用指针来传递和接收数据。

在现代 C++ 编程中，随着智能指针（如 std::unique_ptr 和 std::shared_ptr）的引入，原始指针的使用场景进一步被压缩。智能指针通过 RAII（Resource Acquisition Is Initialization）机制，将资源的生命周期管理与对象的生命周期绑定，从而自动释放内存，有效防止了内存泄漏。std::unique_ptr 提供了独占所有权的语义，适用于那些需要明确唯一所有者的资源，而 std::shared_ptr 则通过引用计数实现了共享所有权，适用于多个对象需要共享同一资源的场景。这些智能指针在内部封装了原始指针，但提供了更安全、更易于管理的接口。因此，在现代 C++ 中，推荐优先使用引用和智能指针。只有在确实需要指针的特殊能力（如可为空、支持算术运算、与 C 接口交互）时，才应使用原始指针，并且在使用时要格外小心，确保资源被正确管理。总而言之，引用是默认的、更安全的选择，而指针则是在需要额外灵活性和底层控制时的工具。

1.2 const 关键字 ​

1.2.1 const 修饰变量 ​

在 C++ 中，const 关键字用于声明一个变量为常量，这意味着该变量的值在初始化后不能被修改。这是 const 最基本也是最直接的用法，它为代码提供了更强的类型安全性和可读性。当一个变量被声明为 const 时，编译器会确保任何试图修改该变量的操作都会导致编译错误。例如，const int maxSize = 100; 声明了一个名为 maxSize 的整型常量，其值为 100。在后续的代码中，任何像 maxSize = 200; 这样的赋值操作都会被编译器拒绝。这种机制有助于防止程序中的意外修改，尤其是在大型项目中，当一个值被多个模块共享时，使用 const 可以确保其值的一致性。此外，使用 const 常量替代宏定义（#define）是一种更好的编程实践。与宏定义不同，const 常量有类型信息，编译器可以进行类型检查，并且在调试时可以看到常量的符号名，而不是被替换后的值，这使得代码更易于调试和维护。

const 修饰变量的用法不仅限于基本数据类型，它同样可以用于修饰用户自定义的类型，如类对象。当一个类对象被声明为 const 时，该对象的所有非 const 成员函数都不能被调用。这是因为非 const 成员函数可能会修改对象的状态，而 const 对象的状态是不允许被改变的。例如，如果有一个 MyClass 类，并且创建了一个 const MyClass obj; 对象，那么只有那些被声明为 const 的成员函数（如 int getValue() const;）才能被 obj 调用。这种设计强制要求类的设计者明确区分哪些操作会修改对象，哪些不会，从而提高了代码的健壮性。此外，const 对象必须在构造时完成初始化，因为之后其成员变量就不能被修改了。这通常通过构造函数的初始化列表来完成。通过这种方式，const 不仅保护了基本数据类型的值，也保护了复杂对象的内部状态，是 C++ 中实现不可变性（Immutability）和线程安全的重要工具。

1.2.2 const 修饰指针与引用 ​

const 关键字与指针和引用的结合使用是 C++ 中一个非常重要且容易混淆的概念，它提供了对数据访问权限的精细控制。当 const 与指针结合时，其位置决定了“常量”的性质，主要有三种情况。第一种是 “指向常量的指针”（pointer to const） ，其声明形式为 const int* p; 或 int const* p;。在这种情况下，指针 p 本身是可以改变的（即可以指向不同的 int 变量），但是不能通过 p 来修改它所指向的变量的值。例如，int a = 10, b = 20; const int* p = &a; 是合法的，但 *p = 15; 是非法的，因为这试图修改 a 的值。然而，p = &b; 是合法的，因为指针 p 本身不是常量。这种用法常用于函数参数，当函数需要读取一个变量的值但不应修改它时，使用 const 指针可以保证函数内部不会意外地修改传入的数据。

第二种情况是 “常量指针”（const pointer） ，其声明形式为 int* const p = &a;。在这种情况下，指针 p 本身是一个常量，这意味着它在初始化后就不能再指向其他地址，即 p 的值是固定的。但是，可以通过 p 来修改它所指向的变量的值。例如，*p = 15; 是合法的，这会修改 a 的值。但是，p = &b; 是非法的，因为这试图改变指针 p 自身的值。这种用法适用于那些需要固定指向某个特定对象的指针，例如，在一个对象内部维护一个指向自身或其他固定对象的指针。第三种情况是 “指向常量的常量指针”（const pointer to const） ，其声明形式为 const int* const p = &a;。在这种情况下，指针 p 本身是常量，不能改变指向，同时也不能通过 p 来修改它所指向的变量的值。这提供了最高级别的保护，确保指针和它所指向的数据都不可被修改。

当 const 与引用结合时，其用法相对简单，主要是 “对常量的引用”（reference to const） ，其声明形式为 const int& r = a;。与指向常量的指针类似，不能通过引用 r 来修改它所绑定的变量 a 的值。例如，r = 15; 是非法的。这种用法在函数参数传递中非常普遍，因为它既能避免对象的拷贝（提高性能），又能保证函数不会修改传入的参数。例如，void print(const std::string& str); 这个函数承诺它只会读取 str 的内容，而不会修改它。此外，一个 const 引用可以绑定到一个临时对象或字面量上，例如 const int& r = 42; 是合法的，这是因为 C++ 会创建一个临时的 int 对象来存储 42，然后让 r 绑定到这个临时对象上。这种特性使得 const 引用在函数返回值和表达式求值中非常有用。总而言之，const 与指针和引用的结合，为 C++ 程序员提供了强大的工具，用于定义清晰的接口、保护数据不被意外修改，并提高代码的可读性和可维护性。

1.2.3 const 修饰函数参数与返回值 ​

在 C++ 中，使用 const 修饰函数参数和返回值是提高代码健壮性、可读性和性能的重要手段。当 const 用于修饰函数参数时，其主要目的是向函数的调用者保证，该函数不会修改传入的参数。这对于按值传递的参数意义不大，因为函数内部操作的是参数的副本，但对于按引用或按指针传递的参数则至关重要。例如，一个函数 void processData(const std::vector<int>& data); 通过使用 const 引用，明确告知调用者，processData 函数只会读取 data 的内容，而不会对其进行任何修改。这不仅是一种良好的编程契约，让代码的意图更加清晰，还能带来一些实际的好处。首先，它可以防止函数内部的意外修改，因为任何试图修改 data 的操作都会导致编译错误。其次，它允许函数接受 const 对象作为参数，因为 const 对象只能绑定到 const 引用或指针上。此外，对于按值传递的参数，使用 const 修饰（如 void func(const int x);）虽然没有实际效果（因为 x 是副本），但可以作为一种文档，表明函数内部不会修改这个值。

当 const 用于修饰函数的返回值时，其含义和作用则更为复杂，主要分为几种情况。如果函数返回一个基本数据类型（如 int、double），使用 const 修饰返回值（如 const int getValue();）通常没有实际意义，因为返回的是一个临时副本，调用者无法对其进行修改。然而，如果函数返回一个对象或引用，情况就不同了。当函数返回一个 const 对象时（如 const MyClass getObject();），这意味着返回的临时对象不能被修改。例如，调用者不能对返回值调用非 const 成员函数，如 getObject().modify(); 将是非法的。这在设计需要保持对象状态不变的接口时非常有用。更常见且更重要的是返回 const 引用。例如，const std::string& getName() const; 这样的函数通常用于提供一个对类内部成员的只读访问。返回 const 引用可以避免不必要的对象拷贝，从而提高性能，尤其是在返回大型对象时。同时，它保证了调用者只能读取该成员，而不能修改它，从而保护了类的内部状态。这种用法在类的 getter 函数中非常普遍，是实现封装原则的关键技术之一。总而言之，明智地使用 const 来修饰函数参数和返回值，可以创建出更安全、更高效、更易于理解和维护的 C++ 代码。

1.2.4 const 修饰成员函数 ​

在 C++ 中，将 const 关键字放在成员函数声明的末尾，用于修饰该成员函数本身，这是一种非常重要的语言特性，它直接关系到类的接口设计和对象的状态管理。一个被 const 修饰的成员函数被称为 “常成员函数”（const member function） 。其核心承诺是：这个函数不会修改调用它的对象的状态。换句话说，在常成员函数的内部，不能修改类的任何非 static 成员变量，也不能调用任何非 const 的成员函数。编译器会强制执行这一规则，任何违反这一规则的代码都会导致编译错误。例如，在一个 class MyClass 中，如果有一个成员函数 int getValue() const;，那么在 getValue 的实现中，任何试图修改 MyClass 的成员变量的操作都是不允许的。这种机制为类的使用者提供了强有力的保证，使得代码的意图更加清晰，也更容易进行推理和维护。

常成员函数的主要应用场景是提供对对象状态的只读访问。在设计一个类时，通常会将那些只读取对象数据而不修改其状态的函数声明为 const。例如，一个表示日期的 Date 类可能会有 int getYear() const;、int getMonth() const; 和 int getDay() const; 这样的 getter 函数。将这些函数声明为 const 可以向调用者明确表明，调用这些函数是安全的，不会改变 Date 对象的状态。更重要的是，只有 const 成员函数才能被 const 对象调用。如果一个对象被声明为 const，如 const Date today;，那么它只能调用 const 成员函数。如果 getYear 没有被声明为 const，那么 today.getYear(); 这样的调用将是非法的。因此，为了允许 const 对象也能使用类的接口，将所有不修改对象状态的成员函数都声明为 const 是一种必要的、良好的编程实践。

此外，const 成员函数还与函数重载有关。C++ 允许在同一个类中定义两个同名、同参数列表的成员函数，只要其中一个被声明为 const，而另一个没有。例如，可以定义 int& operator[](size_t index); 和 const int& operator[](size_t index) const;。当对一个非 const 对象使用 [] 操作符时，会调用非 const 版本，返回一个可修改的引用，允许进行写操作，如 obj[0] = 10;。而当对一个 const 对象使用 [] 操作符时，会调用 const 版本，返回一个 const 引用，只允许进行读操作，如 int val = const_obj[0];。这种基于 const 的重载机制，使得类可以为 const 和非 const 对象提供不同的行为，从而实现更精细的接口设计，既保证了 const 对象的不可变性，又为非 const 对象提供了必要的修改能力。总而言之，const 成员函数是 C++ 中实现封装、保证对象状态完整性和提供清晰接口的关键工具。

1.3 static 关键字 ​

1.3.1 static 修饰局部变量 ​

在 C++ 中，当 static 关键字用于修饰函数内部的局部变量时，它会改变该变量的生命周期和存储位置，但不会影响其作用域。一个普通的局部变量在每次函数调用时都会被创建，在函数返回时就会被销毁，其存储在栈（stack）上。然而，一个被 static 修饰的局部变量，其生命周期会延长到整个程序的运行期间，即从程序开始到程序结束。这意味着，该变量只会在第一次执行到其定义语句时被初始化一次，之后即使函数被多次调用，也不会再次初始化，而是会保留上一次函数调用结束时的值。这种特性使得 static 局部变量非常适合用于实现需要记住状态的函数，例如计数器或缓存。

从存储位置来看，static 局部变量被存储在全局/静态存储区（global/static storage area），而不是栈上。这与全局变量和 static 全局变量的存储位置相同。尽管其生命周期与全局变量类似，但其作用域仍然局限于定义它的函数内部。也就是说，在函数外部是无法直接访问这个 static 局部变量的。这种结合了全局生命周期和局部作用域的特性，使得 static 局部变量成为一种封装内部状态的有效手段。例如，一个函数可以使用 static 局部变量来记录自己被调用的次数，或者缓存一些计算结果，以便在后续调用中复用，从而提高性能。

需要注意的是，static 局部变量的初始化是线程安全的（在 C++11 及以后的标准中）。如果多个线程同时第一次调用包含 static 局部变量的函数，编译器会保证初始化过程只发生一次，并且是线程安全的。这避免了在多线程环境下可能出现的竞态条件。然而，对 static 局部变量的后续读写操作并不是线程安全的，如果多个线程需要并发地访问和修改同一个 static 局部变量，仍然需要使用互斥锁（mutex）等同步机制来保证数据的一致性。总之，static 局部变量是一种强大的语言特性，它提供了一种在函数调用之间保持状态的简洁而有效的方法。

1.3.2 static 修饰全局变量与函数 ​

在 C++ 中，当 static 关键字用于修饰全局变量或函数时，它的主要作用是改变其链接属性（linkage），将其从默认的外部链接（external linkage）变为内部链接（internal linkage）。这意味着，被 static 修饰的全局变量或函数只能在定义它的源文件（translation unit）内部被访问，而不能被其他源文件通过 extern 关键字来引用。这种特性对于实现信息隐藏和避免命名冲突非常有用。例如，在一个大型项目中，不同的源文件可能会定义同名的全局变量或函数，如果这些定义都具有外部链接，那么在链接阶段就会产生命名冲突的错误。通过将这些定义声明为 static，可以将它们的作用域限制在各自的源文件内，从而避免冲突。

对于全局变量，static 关键字除了改变链接属性外，还影响其生命周期和存储位置。static 全局变量的生命周期是整个程序的运行期间，其存储位置在全局/静态存储区。这与普通的全局变量是相同的。唯一的区别在于其可见性。例如，在一个名为 file1.cpp 的源文件中定义了一个 static int counter = 0;，那么在另一个名为 file2.cpp 的源文件中，即使使用 extern int counter; 也无法访问到这个变量。file2.cpp 中的 counter 会是一个未定义的符号，或者如果 file2.cpp 自己也定义了一个 counter，那么这两个 counter 是完全独立的两个变量。

对于函数，static 关键字的作用类似。一个被 static 修饰的函数只能在定义它的源文件中被调用。这通常用于实现一些只在本模块内部使用的辅助函数，而不希望它们暴露给其他模块。这种做法有助于提高代码的模块化程度和封装性。例如，一个模块可能有一些内部工具函数，这些函数不应该被外部代码直接调用，那么就可以将它们声明为 static。这样，即使其他模块中定义了同名的函数，也不会产生冲突。总之，static 关键字在修饰全局变量和函数时，提供了一种有效的机制来控制标识符的可见性，是实现模块化和信息隐藏的重要工具。

1.3.3 static 修饰类成员变量与函数 ​

在 C++ 中，static 关键字用于修饰类的成员时，会将这些成员与类本身关联，而不是与类的任何特定对象关联。这意味着，无论创建了多少个类的对象，static 成员都只有一份拷贝，被所有对象共享。static 成员变量和 static 成员函数在行为和使用上有一些独特的特点。首先，static 成员变量必须在类定义的外部进行定义和初始化（除非它是 constexpr 或 inline 变量）。这是因为 static 成员变量不属于任何对象，所以不能在对象的构造函数中进行初始化。例如，class MyClass { static int count; }; 在类定义中只是声明了 count，还需要在类外部进行定义：int MyClass::count = 0;。

static 成员函数是属于类的函数，而不是属于对象的函数。因此，它可以通过类名直接调用，例如 MyClass::staticFunction();，而不需要创建任何对象。static 成员函数的一个重要限制是，它不能访问类的非 static 成员变量和非 static 成员函数。这是因为非 static 成员是与特定对象关联的，而 static 成员函数没有 this 指针，无法知道应该访问哪个对象的成员。static 成员函数只能访问 static 成员变量和其他 static 成员函数。这种特性使得 static 成员函数非常适合作为工具函数或回调函数，它们执行的操作与任何特定对象的状态无关。

static 成员变量常用于实现需要在所有对象之间共享的数据，例如计数器。每次创建一个对象时，可以在构造函数中将 static 计数器加一，每次销毁一个对象时，在析构函数中将计数器减一，这样就可以随时知道当前存在多少个对象。static 成员函数则可以用于访问或操作这些 static 成员变量，或者执行一些与类相关但与对象状态无关的操作。例如，一个 Math 类可以有一个 static 成员函数 sqrt 用于计算平方根，这个操作与任何 Math 对象的状态都无关。总之，static 成员提供了一种在类的所有实例之间共享数据和行为的机制，是实现某些设计模式（如单例模式）和工具类的重要工具。

1.4 宏定义与内联函数 ​

1.4.1 宏定义的优缺点 ​

宏定义（Macro Definition）是 C/C++ 预处理器提供的一种功能，通过 #define 指令来定义。它在编译之前对源代码进行文本替换，将宏名替换为其定义的文本内容。宏定义的主要优点在于其简单和高效。首先，宏定义可以实现简单的代码复用，避免重复编写相同的代码片段。例如，可以定义一个宏来表示一个常量值，如 #define PI 3.14159，这样在代码中所有使用 PI 的地方都会在编译前被替换为 3.14159。这比使用变量更直接，并且不会占用运行时的内存空间。其次，宏定义可以实现一些简单的函数式操作，即“宏函数”，如 #define MAX(a, b) ((a) > (b) ? (a) : (b))。这种宏函数在形式上类似于函数调用，但它没有函数调用的开销（如参数压栈、跳转等），因为它在预处理阶段就被展开了，直接替换为对应的表达式，从而可能带来性能上的提升。

然而，宏定义的缺点也同样突出，这些缺点在现代 C++ 编程中促使开发者更多地转向使用 const、constexpr 和 inline 等语言特性。首先，宏定义缺乏类型检查。由于宏只是简单的文本替换，预处理器不会对其参数或返回值进行任何类型检查。这可能导致难以发现的类型错误。例如，如果 MAX 宏被用于比较两个不同类型的指针，预处理器不会报错，但编译器可能会发出警告或产生未定义的行为。其次，宏定义容易导致意外的副作用。由于宏参数在展开时可能会被多次求值，如果参数本身是一个带有副作用的表达式（如 i++），就可能导致意想不到的结果。例如，MAX(i++, j++) 这个调用在展开后会变成 ((i++) > (j++) ? (i++) : (j++))，这会导致 i 或 j 被递增两次，这通常不是程序员的本意。为了避免这种情况，宏定义中的参数通常需要用括号括起来，但这并不能完全解决问题。

最后，宏定义会污染全局命名空间，并且调试困难。宏定义在预处理阶段被展开，这意味着在编译器进行编译时，原始的宏名已经不存在了，取而代之的是其展开的文本。这使得在调试时很难追踪宏的定义和使用情况。此外，宏定义是全局有效的，除非使用 #undef 来取消定义，否则它会影响其定义之后的所有代码，这可能导致命名冲突。相比之下，const 变量和 inline 函数具有作用域和类型，可以被封装在命名空间或类中，从而避免了这些问题。因此，尽管宏定义在某些特定场景下（如条件编译）仍然有用，但在大多数情况下，现代 C++ 推荐使用更安全和强大的语言特性来替代宏定义 。

1.4.2 内联函数与宏的区别 ​

内联函数（Inline Functions）和宏定义（Macro Definitions）在 C++ 中都可以用来减少函数调用的开销，但它们在实现机制、类型安全、作用域和调试方面存在本质区别。宏定义是由预处理器在编译之前进行简单的文本替换，它没有类型检查，也没有作用域的概念。例如，#define SQUARE(x) ((x) * (x)) 在代码中遇到 SQUARE(5) 时，预处理器会将其直接替换为 ((5) * (5))。这种文本替换可能导致意想不到的副作用，例如，如果传入 SQUARE(a++)，宏展开后会变成 ((a++) * (a++))，导致 a 被递增两次。此外，宏无法访问类的成员，也不能进行调试，因为在编译后的代码中，宏已经不存在了。

相比之下，内联函数是真正的函数，它在编译阶段由编译器处理。当编译器决定内联一个函数时，它会将函数调用处替换为函数体的代码，从而避免了函数调用的开销（如压栈、跳转、返回等）。与宏不同，内联函数遵循正常的 C++ 类型检查规则，编译器会检查参数类型是否匹配，这大大提高了代码的类型安全性。内联函数也遵循 C++ 的作用域规则，可以定义在类的内部或命名空间中，并且可以访问类的成员。此外，内联函数可以被调试，因为它们在符号表中存在。然而，内联函数也有一些限制，例如，它不能是递归的，且函数体通常不能太大或太复杂，否则编译器可能会忽略内联请求。总的来说，内联函数在提供类似宏的性能优势的同时，保留了 C++ 的类型安全、作用域和调试能力，因此在现代 C++ 编程中，应优先使用内联函数而非宏 。

1.4.3 内联函数的使用限制 ​

尽管内联函数（inline）在提高程序性能和类型安全方面优于宏，但它的使用并非没有限制。编译器是否真正将一个函数内联展开，最终取决于编译器的判断，程序员使用 inline 关键字只是向编译器提出了一个建议，而非强制命令。因此，理解内联函数的使用限制对于编写高效的 C++ 代码至关重要。首先，内联函数的定义必须在调用点可见。这意味着内联函数的定义通常需要放在头文件中，而不是源文件中。因为当编译器在编译一个源文件时，如果遇到内联函数的调用，它必须能够立即看到该函数的定义，以便进行内联展开。如果内联函数的定义在另一个源文件中，编译器在编译当前源文件时就无法看到其定义，因此无法进行内联。这导致了内联函数的定义通常需要与声明一起放在头文件中，这与普通函数的定义通常放在源文件中的做法不同。

其次，并非所有函数都适合被声明为内联。一般来说，函数体较小、逻辑简单、不包含复杂控制结构（如循环、递归）的函数是内联的良好候选者。例如，简单的 getter 和 setter 函数、算术运算函数等。如果一个函数体很大，或者包含复杂的逻辑，将其内联展开可能会导致代码膨胀（code bloat） ，即生成的可执行文件体积显著增大。这是因为每次调用该内联函数，其整个函数体都会被复制到调用点。代码膨胀不仅会增加可执行文件的大小，还可能对指令缓存（instruction cache）的性能产生负面影响，反而降低程序的整体运行效率。因此，编译器通常会拒绝内联那些过于复杂或体积过大的函数，即使它们被标记为 inline。

此外，一些特定类型的函数不能被内联。例如，递归函数通常不能被内联，因为内联展开会导致无限循环的代码生成。同样，包含 switch 语句或 goto 语句的函数，或者函数体中包含静态变量的函数，也可能不适合内联。虚函数（virtual）在大多数情况下也不能被内联，因为虚函数的调用是在运行时通过虚函数表（vtable）动态绑定的，而内联是在编译时进行的静态展开。只有在编译器能够确定虚函数调用的具体目标（例如，通过对象而非指针或引用调用）时，才有可能进行内联。最后，构造函数和析构函数通常也不适合被内联，因为它们通常会执行一些复杂的初始化或清理工作，并且编译器可能会为它们生成额外的代码。因此，在使用 inline 关键字时，需要谨慎权衡其带来的性能提升和可能导致的代码膨胀问题，并遵循编译器的内联策略 。

2. 内存管理 ​

2.1 内存分区 ​

2.1.1 栈、堆、全局/静态存储区、常量区 ​

C++ 程序在运行时，其内存空间通常被划分为几个不同的区域，每个区域都有其特定的用途和生命周期。理解这些内存分区对于编写高效、安全的 C++ 程序至关重要。主要的内存分区包括栈（stack）、堆（heap）、全局/静态存储区（global/static storage area）和常量区（constant storage area）。

栈（Stack） ：栈是用于存储函数调用信息和局部变量的内存区域。当一个函数被调用时，系统会在栈上为其创建一个栈帧（stack frame），用于存储函数的参数、返回地址以及函数内部定义的局部变量。当函数执行完毕后，其栈帧会被自动销毁，所占用的内存也会被立即释放。栈内存的分配和释放由编译器自动管理，效率非常高。然而，栈的大小是有限的，通常在几兆字节左右，因此不适合在栈上分配过大的对象或数组。此外，栈上的变量生命周期与其作用域绑定，一旦离开作用域，变量就会被销毁。

堆（Heap） ：堆是用于动态内存分配的内存区域。程序员可以通过 new 或 malloc 等操作符在堆上申请任意大小的内存空间，并通过 delete 或 free 来手动释放。堆内存的生命周期由程序员控制，非常灵活，可以用于在函数调用之间传递数据，或者创建生命周期不确定的对象。然而，手动管理堆内存也带来了风险，如内存泄漏（忘记释放已分配的内存）和悬挂指针（使用已经释放的内存）。堆内存的分配和释放通常比栈内存慢，并且频繁的分配和释放可能会导致内存碎片。

全局/静态存储区（Global/Static Storage Area） ：这个区域用于存储全局变量和 static 修饰的变量。这些变量在程序启动时就被分配内存，直到程序结束时才被释放。全局变量是在所有函数之外定义的变量，而 static 变量可以是全局的，也可以是局部的。static 局部变量虽然作用域在函数内部，但其生命周期与全局变量相同。这个区域的内存由编译器在编译时分配，并在程序加载时初始化。

常量区（Constant Storage Area） ：这个区域用于存储程序中的常量，如字符串字面量和 const 修饰的全局变量。这些常量在程序运行期间是不可修改的。例如，const int max_size = 100; 和 const char* str = "hello"; 中的 "hello" 都存储在常量区。尝试修改常量区的数据会导致未定义行为，通常是程序崩溃。

2.1.2 各存储区的生命周期与作用域 ​

在 C++ 中，变量的生命周期（lifetime）和作用域（scope）是两个密切相关但又不同的概念。生命周期指的是变量从创建到销毁的时间段，而作用域指的是变量可以被访问的代码区域。不同的内存分区对应着不同的生命周期和作用域规则。

栈（Stack） ：栈上变量的生命周期与其作用域紧密绑定。当一个变量被定义在一个代码块（如函数体或 if 语句块）中时，它在进入该代码块时被创建，在离开该代码块时被销毁。因此，栈上变量的生命周期是自动管理的，由编译器负责。其作用域也仅限于定义它的代码块内部。例如，在一个函数内部定义的局部变量，只能在该函数内部被访问。

堆（Heap） ：堆上变量的生命周期完全由程序员手动控制。通过 new 或 malloc 创建的变量，其生命周期从创建开始，直到程序员显式调用 delete 或 free 来销毁它为止。如果程序员忘记释放，就会导致内存泄漏，该内存将一直被占用，直到程序结束。堆上变量的作用域则取决于指向它的指针的作用域。只要指针在作用域内，并且指向有效的堆内存，就可以通过该指针访问堆上的变量。

全局/静态存储区（Global/Static Storage Area） ：这个区域中的变量（包括全局变量和 static 变量）的生命周期是整个程序的运行期间。它们在程序启动时被创建，在程序结束时被销毁。全局变量的作用域是整个程序，可以在任何源文件中通过 extern 声明来访问（除非被 static 修饰，此时作用域仅限于定义它的源文件）。static 局部变量的作用域仅限于定义它的函数内部，但其生命周期却是全局的。

常量区（Constant Storage Area） ：常量区中的数据，如字符串字面量和 const 全局变量，其生命周期也是整个程序的运行期间。它们的作用域取决于其定义的位置。例如，一个 const 全局变量的作用域是整个程序，而一个在函数内部定义的 const 局部变量的作用域仅限于该函数内部。

理解这些生命周期和作用域的区别，对于避免悬挂指针、内存泄漏和未定义行为等问题至关重要。例如，返回一个指向局部变量的指针或引用是非常危险的，因为局部变量在函数返回后就会被销毁，返回的指针将指向无效的内存。

2.2 new/delete 与 malloc/free ​

2.2.1 两者的区别与联系 ​

new/delete 和 malloc/free 是 C++ 中用于动态内存管理的两组操作符/函数，它们在功能上相似，都用于在程序运行时从堆（heap）上分配和释放内存，但在行为、类型安全和设计理念上存在本质的区别。首先，最根本的区别在于 new 和 delete 是 C++ 的操作符，而 malloc 和 free 是 C 语言标准库中的函数。这一根本差异决定了它们与 C++ 核心特性（如构造函数和析构函数）的集成程度。当使用 new 为一个对象分配内存时，它不仅分配了足够的内存空间，还会自动调用该对象的构造函数来初始化这块内存。同样，当使用 delete 释放一个对象时，它会首先调用该对象的析构函数来执行清理工作（如释放资源），然后再释放内存。这个过程是自动且类型安全的。相比之下，malloc 和 free 仅仅是内存管理函数，它们对内存中的数据类型一无所知。malloc 只负责分配一块指定字节数的原始内存，并返回一个 void* 类型的指针，它不会调用任何构造函数。同样，free 只负责释放由 malloc 分配的内存块，它也不会调用任何析构函数。

其次，在类型安全和语法方面，new/delete 也优于 malloc/free。new 操作符在分配内存时会进行类型检查，并返回一个指向正确类型的指针，无需进行强制类型转换。例如，int* p = new int; 直接返回一个 int* 类型的指针。而 malloc 返回的是 void*，在 C++ 中必须显式地进行类型转换，如 int* p = (int*)malloc(sizeof(int));。这种强制类型转换不仅使代码变得冗长，也削弱了类型安全，因为程序员可能会错误地转换类型，导致未定义行为。此外，new 操作符在内存分配失败时会抛出 std::bad_alloc 异常（除非使用了 nothrow 版本），这使得错误处理更加结构化和健壮。而 malloc 在分配失败时仅返回 nullptr，需要程序员手动检查返回值，这很容易被忽略，从而导致后续的空指针解引用错误。

尽管存在这些显著差异，new/delete 和 malloc/free 之间也存在联系。new 和 delete 的底层实现通常会调用 malloc 和 free 来完成实际的内存分配和释放工作。然而，这并不意味着它们可以混用。在 C++ 中，一个至关重要的规则是：绝对不能混用 new/delete 和 malloc/free。用 new 分配的内存必须用 delete 释放，用 malloc 分配的内存必须用 free 释放。如果用 free 去释放 new 分配的内存，或者反过来，会导致未定义行为，因为 delete 会尝试调用析构函数，而 free 不会，这可能导致资源泄漏或程序崩溃。同样，用 delete 释放 malloc 分配的内存也会导致问题，因为 delete 会尝试调用析构函数，而 malloc 分配的内存中可能并没有一个有效的对象。因此，在 C++ 编程中，强烈建议优先使用 new 和 delete 来管理动态对象，因为它们与 C++ 的语言特性集成得更好，更安全，也更符合 RAII（资源获取即初始化）的设计原则。

2.2.2 为何 new/delete 更安全 ​

new 和 delete 在 C++ 中被认为是比 malloc 和 free 更安全的内存管理方式，这主要源于它们与 C++ 语言核心特性的深度集成，特别是构造函数、析构函数和异常处理机制。首先，也是最核心的安全优势在于 new 和 delete 会自动处理对象的构造和析构。当使用 new 创建一个对象时，例如 MyClass* obj = new MyClass(args);，new 不仅分配了足够的内存来存储 MyClass 对象，还会自动调用 MyClass 的构造函数，并传入 args 参数。这确保了对象在被使用之前已经被正确地初始化，处于一个有效的状态。同样，当使用 delete obj; 时，delete 会首先调用 obj 所指向对象的析构函数，允许对象执行必要的清理工作，比如关闭文件、释放网络连接或删除其内部动态分配的其他资源。只有在析构函数执行完毕后，delete 才会释放对象占用的内存。这个自动化的过程极大地减少了资源泄漏的风险，因为程序员不再需要手动调用析构函数。相比之下，malloc 和 free 仅仅是底层的内存分配和释放函数，它们对 C++ 对象的构造和析构一无所知。使用 malloc 分配的内存只是一块原始的、未初始化的字节序列，程序员必须手动调用构造函数（通过 placement new）来初始化对象，并在 free 之前手动调用析构函数，这个过程繁琐且容易出错。

其次，new 和 delete 提供了更好的类型安全和更简洁的语法。new 操作符在编译时会进行类型检查，并返回一个指向正确类型的指针，无需进行强制类型转换。例如，int* p = new int(5); 直接返回一个 int* 类型的指针，类型安全得到了保证。而 malloc 返回的是 void*，在 C++ 中必须显式地进行类型转换，如 int* p = (int*)malloc(sizeof(int));。这种强制类型转换不仅使代码变得冗长，也隐藏了潜在的类型不匹配错误。如果程序员错误地转换了类型，编译器无法发现，只有在运行时才会导致未定义行为。此外，new 操作符在内存分配失败时会抛出 std::bad_alloc 异常，这使得错误处理更加结构化和健壮。程序员可以使用 try-catch 块来捕获这个异常，并采取相应的恢复措施。而 malloc 在分配失败时仅返回 nullptr，需要程序员在每次调用 malloc 后都手动检查返回值，这不仅增加了代码的冗余，而且很容易被忽略，从而导致后续的空指针解引用，这是许多程序崩溃的常见原因。

最后，new 和 delete 与 C++ 的异常处理机制协同工作，能够更好地保证异常安全。考虑一个场景：在一个函数中，我们使用 new 创建多个对象。如果在创建过程中某个 new 操作抛出 std::bad_alloc 异常，那么在此之前已经成功创建的对象的析构函数会被自动调用，从而确保已经获取的资源能够被正确释放，避免了资源泄漏。这种机制被称为“栈展开”（stack unwinding），是 C++ 异常处理的核心部分。然而，如果使用 malloc 和 free，情况就复杂得多。如果在分配了多个内存块后发生错误，程序员必须手动编写复杂的清理代码来释放之前分配的所有内存，这个过程非常容易出错，尤其是在异常发生时，很容易导致内存泄漏。综上所述，new 和 delete 通过自动处理对象生命周期、提供类型安全和与异常处理机制的紧密集成，为 C++ 程序员提供了一种远比 malloc 和 free 更安全、更可靠的动态内存管理方式。

2.3 内存泄漏与野指针 ​

2.3.1 内存泄漏的产生原因与检测方法 ​

内存泄漏（Memory Leak）是指程序在堆上动态分配了内存，但在使用完毕后未能及时释放，导致这部分内存无法再被程序使用，也无法被操作系统回收。随着程序运行时间的增长，内存泄漏会逐渐耗尽系统可用内存，最终可能导致程序性能下降甚至崩溃。内存泄漏的产生原因主要有以下几种：

  1. 忘记释放内存：这是最常见的原因。程序员使用 new 或 malloc 分配了内存，但由于疏忽，在使用完毕后忘记调用 delete 或 free 来释放。例如，在一个函数中分配了内存，但在所有可能的返回路径上都没有释放它 。
  2. 指针丢失：当指向已分配内存的指针被重新赋值，指向了另一个地址，而原来内存的地址信息丢失，导致无法再释放原来的内存。例如，int* p = new int[10]; p = new int[20];，此时第一块内存就泄漏了。
  3. 异常安全问题：在函数执行过程中，如果在 new 之后、delete 之前抛出了异常，并且异常没有被捕获，那么 delete 语句将不会被执行，从而导致内存泄漏。例如，在一个构造函数中分配了多个资源，如果其中一个分配失败并抛出异常，之前已经成功分配的资源就可能无法被释放 。

为了检测和定位内存泄漏，可以使用多种工具和方法：

  • 静态分析工具：如 Clang Static Analyzer、Cppcheck 等，可以在编译阶段分析代码，发现潜在的内存泄漏问题。
  • 动态分析工具：如 Valgrind（Linux）、Dr. Memory（Windows）、AddressSanitizer（GCC/Clang 内置）等，可以在程序运行时监控内存的分配和释放，精确地报告内存泄漏的位置和大小。这些工具通过在程序运行时插入额外的检查代码来工作，能够检测到未释放的内存块以及访问已释放内存等错误 。
  • 智能指针：在现代 C++ 中，使用 std::unique_ptr 和 std::shared_ptr 等智能指针是防止内存泄漏的最佳实践。智能指针利用 RAII（资源获取即初始化）原则，将资源的生命周期与对象的生命周期绑定，当智能指针对象被销毁时，其析构函数会自动释放所管理的内存，从而避免了手动 delete 的繁琐和出错的可能 。

2.3.2 野指针与悬空指针的区别 ​

野指针（Wild Pointer）和悬空指针（Dangling Pointer）都是指向无效内存区域的指针，访问它们会导致未定义行为，是 C++ 中常见的内存错误。尽管它们都指向“坏”的内存，但其产生原因有所不同。

野指针是指一个未被初始化的指针。在 C++ 中，如果定义了一个指针变量但没有给它赋一个有效的地址，它的值是未定义的，可能指向内存中的任何一个随机位置。访问这个指针所指向的内存是极其危险的，因为它可能会破坏程序的数据或代码，甚至导致系统崩溃。例如：int* p; *p = 10; 这里的 p 就是一个野指针。避免野指针的最佳实践是在定义指针时立即将其初始化为 nullptr 或一个有效的地址。

悬空指针是指一个指针，它曾经指向一个有效的内存地址，但该内存已经被释放或销毁，而指针本身的值没有被修改，仍然保存着那个已经无效的地址。访问悬空指针同样会导致未定义行为。悬空指针的产生场景主要有：

  1. 内存被释放后未置空：使用 delete 或 free 释放了一块内存后，没有将指向该内存的指针设置为 nullptr。例如：int* p = new int(5); delete p; // p 现在是悬空指针 *p = 10; // 未定义行为。
  2. 对象被销毁后指针仍然存在：当一个对象被销毁（例如，离开了其作用域）后，任何指向该对象的指针都变成了悬空指针。例如，一个函数返回了一个指向其局部变量的指针，当函数返回后，局部变量被销毁，返回的指针就成了悬空指针。

总结来说，野指针是“天生”的，因为它从未被赋予一个有意义的生命；而悬空指针是“后天”的，它曾经拥有一个有效的生命，但在生命结束后，它的“墓碑”（指针值）还在，并被错误地当作了活物。两者都非常危险，现代 C++ 通过鼓励使用智能指针和 RAII 来从根本上避免这类问题。

2.4 智能指针 ​

2.4.1 std::unique_ptr 的原理与使用 ​

std::unique_ptr 是 C++11 引入的一种智能指针，其核心设计思想是独占所有权（Exclusive Ownership） 。这意味着在任何时刻，一个 std::unique_ptr 对象都唯一地拥有其所指向的动态分配对象的所有权。当这个 std::unique_ptr 对象被销毁时（例如，离开其作用域），它所管理的对象也会被自动删除。这种机制完美地体现了 RAII（Resource Acquisition Is Initialization）原则，将资源的生命周期与对象的生命周期绑定，从而有效地防止了内存泄漏。std::unique_ptr 的实现原理主要依赖于两个关键技术：一是禁止拷贝构造和拷贝赋值，二是支持移动语义。为了确保所有权的唯一性，std::unique_ptr 的拷贝构造函数和拷贝赋值运算符被显式地删除（= delete）。这意味着你不能将一个 unique_ptr 拷贝给另一个 unique_ptr，例如 std::unique_ptr<int> p2 = p1; 是非法的。这从根本上杜绝了多个 unique_ptr 同时管理同一个对象的可能性，避免了双重删除的风险。

然而，为了允许所有权的转移，std::unique_ptr 实现了移动构造函数和移动赋值运算符。通过使用 std::move，可以将一个 unique_ptr 的所有权转移给另一个 unique_ptr。例如，std::unique_ptr<int> p2 = std::move(p1); 是合法的。执行此操作后，p1 将不再拥有该对象，其内部指针变为 nullptr，而 p2 则成为该对象的新所有者。这种所有权的转移是显式的，需要程序员通过 std::move 来发起，这使得代码的意图非常清晰。std::unique_ptr 的使用非常广泛，尤其是在工厂函数中。一个工厂函数可以创建一个对象，并将其所有权以 std::unique_ptr 的形式返回给调用者。例如，std::unique_ptr<MyClass> createMyClass() { return std::make_unique<MyClass>(); }。调用者接收这个 unique_ptr，并负责其生命周期。当调用者的 unique_ptr 被销毁时，对象也随之被销毁。此外，std::unique_ptr 还可以与自定义的删除器（deleter）一起使用，以管理非内存资源，如文件句柄或网络连接。通过指定一个自定义的删除器，可以在 unique_ptr 被销毁时执行特定的清理操作，例如关闭文件。这使得 std::unique_ptr 成为一个通用的 RAII 包装器，适用于各种需要自动释放的资源。

2.4.2 std::shared_ptr 的原理与循环引用问题 ​

std::shared_ptr 是 C++11 引入的另一种智能指针，其设计目标是共享所有权（Shared Ownership） 。与 std::unique_ptr 的独占所有权不同，多个 std::shared_ptr 对象可以同时拥有同一个动态分配的对象。只有当最后一个拥有该对象的 std::shared_ptr 被销毁或重置时，它所管理的对象才会被自动删除。std::shared_ptr 实现共享所有权的机制是引用计数（Reference Counting） 。每个 std::shared_ptr 对象内部都包含一个指向控制块（control block）的指针，这个控制块中存储了引用计数器以及其他一些信息（如自定义删除器和分配器）。当一个 std::shared_ptr 被拷贝（例如，通过拷贝构造函数或拷贝赋值运算符）时，它所指向的控制块中的引用计数会原子地增加 1。当一个 std::shared_ptr 被销毁或重置时，引用计数会原子地减少 1。当引用计数变为 0 时，意味着没有任何 std::shared_ptr 再拥有这个对象，此时控制块会调用对象的析构函数，并释放其占用的内存。

std::shared_ptr 的使用场景非常广泛，尤其是在需要多个对象共享同一个资源的复杂数据结构中。例如，在实现一个图（Graph）数据结构时，一个节点（Node）可能被多个边（Edge）共享。在这种情况下，可以使用 std::shared_ptr<Node> 来管理节点的生命周期，确保只有当所有指向该节点的边都被销毁后，节点本身才会被删除。另一个常见的例子是在观察者模式（Observer Pattern）中，被观察的对象（Subject）需要维护一个观察者（Observer）的列表。如果使用 std::shared_ptr 来管理观察者的生命周期，可以确保只要被观察对象还存在，观察者就不会被意外删除。然而，std::shared_ptr 的引用计数机制也带来了一个著名的问题：循环引用（Circular Reference） 。当两个或多个 std::shared_ptr 对象相互引用，形成一个闭环时，它们的引用计数永远不会变为 0，即使它们已经脱离了程序的主逻辑，无法被访问。这会导致它们所管理的对象永远无法被释放，从而造成内存泄漏。

2.4.3 std::weak_ptr 的作用与使用场景 ​

std::weak_ptr 是 C++11 中与 std::shared_ptr 配套使用的智能指针，它的主要作用是解决 std::shared_ptr 的循环引用问题，并提供一种非拥有性（non-owning）的观察机制。weak_ptr 指向一个由 shared_ptr 管理的对象，但它不增加该对象的引用计数。这意味着 weak_ptr 的存在与否不会影响对象的生命周期。当最后一个 shared_ptr 被销毁后，即使还有 weak_ptr 指向该对象，对象本身仍然会被删除。weak_ptr 的这种特性使其成为打破循环引用的理想工具。例如，在一个双向链表中，如果每个节点都使用 std::shared_ptr 来指向前一个和后一个节点，就会形成一个循环引用，导致内存泄漏。为了解决这个问题，可以将其中一个方向的指针（例如，指向前一个节点的指针）改为 std::weak_ptr。这样，节点之间的引用关系就不再是纯粹的拥有关系，循环引用被打破，当所有外部 shared_ptr 都被销毁后，整个链表就能被正确地释放。

weak_ptr 的使用通常涉及两个步骤。首先，从一个 shared_ptr 创建一个 weak_ptr，例如 std::weak_ptr<MyClass> wp = sp;，其中 sp 是一个 std::shared_ptr<MyClass>。此时，wp 开始观察 sp 所管理的对象，但对象的引用计数保持不变。其次，为了访问 weak_ptr 所观察的对象，需要将其“锁定”（lock）为一个 shared_ptr。这可以通过调用 weak_ptr 的 lock() 成员函数来实现：std::shared_ptr<MyClass> sp2 = wp.lock();。lock() 函数会返回一个 shared_ptr，如果 weak_ptr 所观察的对象仍然存在（即至少有一个 shared_ptr 拥有它），则返回的 shared_ptr 会共享所有权，并增加引用计数。如果对象已经被销毁，lock() 会返回一个空的 shared_ptr。因此，在使用 lock() 返回的 shared_ptr 之前，必须检查它是否为空，以避免访问已经失效的内存。这种“尝试锁定”的机制是 weak_ptr 的核心用法，它允许程序员在不确定对象是否还存在的情况下，安全地尝试访问它。

除了打破循环引用，weak_ptr 还有其他一些重要的使用场景。例如，它可以用于实现缓存（cache）。一个缓存可以存储一些对象的 weak_ptr，这样当外部代码需要这些对象时，可以从缓存中获取。如果对象仍然存在，就可以直接使用；如果对象已经被销毁，缓存可以重新创建它。由于 weak_ptr 不增加引用计数，这避免了缓存本身阻止对象被销毁的问题。另一个例子是在观察者模式中，观察者可以持有被观察对象的 weak_ptr，而不是 shared_ptr。这样，当被观察对象被销毁时，观察者可以通过检查 weak_ptr 的状态来得知这一情况，并自动解除注册，从而避免了悬挂指针的问题。总而言之，std::weak_ptr 通过提供一种非拥有性的观察机制，有效地解决了 std::shared_ptr 的循环引用问题，并为实现更复杂、更健壮的资源管理和对象关系提供了强大的支持。

3. 面向对象编程 (OOP) ​

3.1 封装、继承与多态 ​

3.1.1 三大特性的基本概念 ​

面向对象编程（Object-Oriented Programming, OOP）是一种程序设计范式，它将数据和操作数据的方法捆绑在一起，形成“对象”，并通过对象之间的交互来完成程序的功能。C++ 是一种支持多种编程范式的语言，但其核心和强大之处在于对面向对象编程的全面支持。OOP 的三大基本特性是 封装（Encapsulation） 、继承（Inheritance） 和 多态（Polymorphism） 。理解这三大特性是掌握 C++ 面向对象编程的关键。

封装（Encapsulation） 是指将数据（属性）和操作这些数据的代码（方法）捆绑在一个独立的单元（即类）中，并对外部隐藏对象的内部状态和实现细节。外部代码只能通过类提供的公共接口（public interface）来与对象进行交互，而不能直接访问对象的私有（private）或受保护（protected）成员。封装的目的是实现信息隐藏，保护数据不被随意篡改，从而提高代码的安全性和可维护性。例如，一个 BankAccount 类可以将 balance（余额）属性设为私有，并提供 deposit()（存款）和 withdraw()（取款）等公共方法来操作余额，这样就确保了余额不会被非法修改。

继承（Inheritance） 是指一个类（派生类或子类）可以获取另一个类（基类或父类）的属性和方法。通过继承，派生类可以复用基类的代码，并在此基础上添加新的功能或重写（override）基类的方法。继承的主要目的是实现代码复用和建立类之间的层次关系（is-a 关系）。例如，可以定义一个基类 Animal，它包含 eat() 和 sleep() 等方法，然后让 Dog 类和 Cat 类继承自 Animal 类，并各自实现 bark() 和 meow() 等特有方法。C++ 支持单继承和多继承，并提供了 public、protected 和 private 三种继承方式来控制基类成员在派生类中的访问权限。

多态（Polymorphism） 是指允许不同类的对象对同一消息做出响应，即同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。多态性使得程序可以编写出更通用、更灵活的代码。在 C++ 中，多态主要通过虚函数（virtual functions）和继承来实现。当通过基类的指针或引用调用一个虚函数时，实际执行的是该指针或引用所指向的实际对象（派生类对象）的函数版本。这种在运行时确定调用哪个函数的能力被称为动态绑定（dynamic binding）或运行时多态。多态的主要目的是实现接口复用，让代码可以处理不同类型的对象，而无需关心它们的具体类型。

3.1.2 多态的实现原理（虚函数表） ​

C++ 中的运行时多态（dynamic polymorphism）是通过 虚函数表（Virtual Table, vtable） 和 虚函数指针（Virtual Pointer, vptr） 机制来实现的。这个机制是 C++ 实现多态的核心，它使得在运行时能够根据对象的实际类型来调用正确的函数版本。当一个类包含至少一个虚函数时，编译器会为该类创建一个虚函数表。这个表是一个函数指针数组，其中存储了该类所有虚函数的地址。对于派生类，如果它重写了基类的某个虚函数，那么它的虚函数表中对应位置的函数指针就会被更新为派生类重写后的函数地址。

每个包含虚函数的类的对象，在内存中都会额外包含一个隐藏的指针，即虚函数指针（vptr）。这个指针在对象构造时被初始化，指向该类对应的虚函数表。因此，当创建一个基类或派生类的对象时，其 vptr 会指向该类自己的 vtable。当通过基类的指针或引用调用一个虚函数时，程序的执行过程如下：

  1. 首先，通过指针或引用找到实际的对象。
  2. 然后，通过对象中的 vptr 找到对应的 vtable。
  3. 接着，根据函数在 vtable 中的索引（偏移量）找到对应的函数指针。
  4. 最后，通过该函数指针调用实际的函数。

由于派生类对象的 vptr 指向的是派生类的 vtable，而派生类的 vtable 中重写的虚函数地址已经被更新，所以即使通过基类指针调用，最终执行的也是派生类的函数版本。这就是动态绑定的实现原理。例如，假设有一个基类 Shape 和一个派生类 Circle，它们都有一个虚函数 draw()。当创建一个 Circle 对象，并用一个 Shape* 指针指向它时，调用 shapePtr->draw()，程序会通过 shapePtr 找到 Circle 对象的 vptr，然后通过 vptr 找到 Circle 类的 vtable，最终在 vtable 中找到 Circle::draw() 的地址并执行。

需要注意的是，虚函数机制会带来一些性能开销。每个包含虚函数的类的对象都需要额外的空间来存储 vptr，并且每次调用虚函数都需要一次额外的间接寻址操作（通过 vptr 找到 vtable）。然而，这种开销通常是微不足道的，相比于多态带来的代码灵活性和可扩展性，这种代价是值得的。此外，构造函数不能是虚函数，因为在调用构造函数时，对象的 vptr 尚未被正确初始化。而析构函数通常应该是虚函数，以确保在通过基类指针删除派生类对象时，能够正确地调用派生类的析构函数，避免资源泄漏。

3.2 类与对象 ​

3.2.1 构造函数与析构函数 ​

在 C++ 中，构造函数（Constructor）和析构函数（Destructor）是类的两个特殊成员函数，它们分别在对象创建和销毁时被自动调用，用于完成对象的初始化和清理工作。它们是 C++ 资源管理（特别是 RAII 思想）的核心。

构造函数 的名称与类名相同，没有返回类型（连 void 也没有）。它的主要任务是在创建对象时，为对象的成员变量赋初值，或者执行一些必要的初始化操作。一个类可以有多个构造函数，这被称为构造函数重载（Constructor Overloading）。通过提供不同参数列表的构造函数，可以以多种方式初始化对象。例如，一个 Point 类可以有一个无参构造函数 Point()，将坐标初始化为原点，也可以有一个带参数的构造函数 Point(int x, int y)，用于初始化指定的坐标。如果程序员没有为类定义任何构造函数，编译器会自动生成一个默认构造函数（default constructor），它不带任何参数，并且会调用所有成员变量的默认构造函数。然而，一旦程序员定义了任何构造函数，编译器就不会再自动生成默认构造函数。

析构函数 的名称是在类名前加上一个波浪号 ~，同样没有返回类型。它的主要任务是在对象生命周期结束时（例如，对象离开作用域或被 delete 时）被自动调用，用于执行清理工作，如释放对象占用的资源（动态分配的内存、打开的文件等）。一个类只能有一个析构函数。如果程序员没有定义析构函数，编译器会自动生成一个默认析构函数，它会调用所有成员变量的析构函数。对于简单的类，默认析构函数通常就足够了。但是，如果类中包含了需要手动释放的资源（例如，通过 new 分配的内存），那么就必须自定义析构函数来正确地释放这些资源，以避免内存泄漏。

构造函数和析构函数的调用顺序也值得关注。在创建派生类对象时，构造函数的调用顺序是：先调用基类的构造函数，再调用派生类成员变量的构造函数（按照它们在类中声明的顺序），最后调用派生类自己的构造函数。而在销毁派生类对象时，析构函数的调用顺序正好相反：先调用派生类的析构函数，然后调用派生类成员变量的析构函数（与声明顺序相反），最后调用基类的析构函数。这种顺序确保了对象在构造时从基类到派生类逐步构建，在析构时从派生类到基类逐步拆解，保证了对象状态的完整性和一致性。

3.2.2 拷贝构造函数与赋值运算符重载 ​

在 C++ 中，当一个类需要管理动态分配的资源时，仅仅依赖编译器生成的默认拷贝构造函数和赋值运算符通常是不够的，甚至会导致严重的问题，如浅拷贝（shallow copy）引起的双重释放（double free）错误。因此，理解并正确实现拷贝构造函数和赋值运算符重载是 C++ 面向对象编程中的一个重要课题。

拷贝构造函数 是一种特殊的构造函数，它以一个同类型对象的引用作为参数，用于创建一个新对象，并用参数对象的内容来初始化它。其标准形式为 ClassName(const ClassName& other);。当发生以下情况时，拷贝构造函数会被调用：

  1. 用一个对象去初始化另一个对象，如 MyClass obj2(obj1); 或 MyClass obj2 = obj1;。
  2. 将对象作为值参数传递给函数。
  3. 函数返回一个对象（尽管现代编译器通常会进行返回值优化 RVO 或移动语义来避免不必要的拷贝）。

如果类中没有定义拷贝构造函数，编译器会自动生成一个默认的拷贝构造函数。默认的拷贝构造函数会逐个成员地进行拷贝。对于基本类型成员，这没有问题。但对于指针成员，它只会拷贝指针的值（即地址），而不会拷贝指针所指向的内容。这就导致了所谓的“浅拷贝”，两个对象会拥有指向同一块内存的指针。当这两个对象被销毁时，它们的析构函数都会尝试释放同一块内存，从而导致双重释放错误。

赋值运算符重载 函数定义了当一个已存在的对象被赋予另一个同类型对象的值时应该执行的操作。其标准形式为 ClassName& operator=(const ClassName& other);。当发生 obj1 = obj2; 这样的操作时，赋值运算符重载函数会被调用。与拷贝构造函数类似，如果没有自定义，编译器会生成一个默认的赋值运算符，它同样执行浅拷贝，存在与默认拷贝构造函数相同的风险。

为了解决这个问题，需要实现“深拷贝”（deep copy）。在自定义的拷贝构造函数和赋值运算符中，需要为新对象分配新的内存，并将原对象的数据复制到新的内存中。对于赋值运算符，还需要处理自赋值（obj = obj）的情况，并确保在分配新内存之前，先释放掉对象原来持有的资源，以避免内存泄漏。一个健壮的赋值运算符通常遵循“拷贝并交换”（copy-and-swap）惯用法，它利用拷贝构造函数和 swap 函数来简化实现并保证异常安全。

3.2.3 深拷贝与浅拷贝 ​

在 C++ 中，当一个类包含指针成员，并且该指针指向动态分配的内存时，拷贝行为就变得至关重要。浅拷贝（Shallow Copy）和深拷贝（Deep Copy）是描述对象拷贝行为的两种不同方式，它们之间的区别直接关系到程序的正确性和稳定性。

浅拷贝是指仅仅复制对象中所有成员的值。对于基本数据类型（如 int, double），这没有问题。但对于指针成员，浅拷贝只会复制指针本身的值（即内存地址），而不会复制指针所指向的内存区域。这意味着，拷贝后的新对象和原对象将共享同一块动态分配的内存。这会带来严重的问题：当其中一个对象被销毁时，其析构函数会释放这块共享的内存，导致另一个对象的指针成员变成悬空指针（Dangling Pointer）。当第二个对象随后被销毁时，其析构函数会再次尝试释放同一块内存，导致双重释放（Double Free） 错误，这是典型的未定义行为，通常会导致程序崩溃。编译器自动生成的拷贝构造函数和赋值运算符执行的就是浅拷贝。

深拷贝则是为了解决浅拷贝带来的问题而提出的。在深拷贝中，不仅复制对象的所有成员，还会为指针成员所指向的数据分配一块新的内存，并将原对象指针所指向的内容完整地复制到这块新的内存中。这样，拷贝后的新对象和原对象将拥有各自独立的内存副本，它们之间互不干扰。当任何一个对象被销毁时，其析构函数只会释放自己所拥有的内存，不会影响到另一个对象，从而保证了程序的正确性。要实现深拷贝，程序员必须自定义类的拷贝构造函数和赋值运算符，在其中手动管理内存的分配和复制。

总结来说，浅拷贝是“值”的拷贝，而深拷贝是“内容”的拷贝。对于不包含动态分配资源的类，浅拷贝通常就足够了。但对于任何管理着动态资源（如通过 new 分配的内存、文件句柄等）的类，都必须实现深拷贝，以确保资源的独立性和正确释放。在现代 C++ 中，一个更好的实践是遵循 Rule of Zero，即通过使用标准库容器（如 std::vector, std::string）和智能指针（如 std::unique_ptr, std::shared_ptr）来管理资源，这些组件已经正确地实现了深拷贝或移动语义，从而避免了手动编写拷贝构造函数和赋值运算符的复杂性和潜在错误。

3.3 继承 ​

3.3.1 三种继承方式（public, protected, private） ​

在 C++ 中，继承是面向对象编程的核心特性之一，它允许一个类（派生类）从另一个类（基类）获取其属性和方法。C++ 提供了三种继承方式：public（公有继承）、protected（保护继承）和 private（私有继承）。这三种方式的主要区别在于它们如何改变从基类继承而来的成员的访问权限。这个访问权限的控制是理解继承机制的关键。

公有继承（public inheritance） 是最常用的一种继承方式。当使用 public 继承时，基类的 public 成员在派生类中仍然是 public 的，基类的 protected 成员在派生类中仍然是 protected 的，而基类的 private 成员在派生类中是不可访问的。这种继承方式建立了一种 "is-a" 的关系，即派生类对象也是一个基类对象。例如，class Dog : public Animal { ... }; 表示“狗是一种动物”。通过公有继承，派生类对象可以被当作基类对象来使用，这是实现多态的基础。

保护继承（protected inheritance） 使用 protected 关键字。在这种继承方式下，基类的 public 和 protected 成员在派生类中都变成 protected 的，而基类的 private 成员仍然不可访问。这意味着，从派生类外部来看，基类的 public 成员不再是 public 的，它们只能被派生类及其子类访问。保护继承建立了一种 "has-a" 或 "is-implemented-in-terms-of" 的关系，它更多地用于实现细节的复用，而不是为了建立清晰的“is-a”层次结构。

私有继承（private inheritance） 使用 private 关键字。在这种继承方式下，基类的 public 和 protected 成员在派生类中都变成 private 的，而基类的 private 成员仍然不可访问。这意味着，从派生类外部无法访问任何从基类继承而来的成员。私有继承也建立了一种 "is-implemented-in-terms-of" 的关系，它强制将基类的接口完全隐藏起来，只将其作为实现工具。派生类对象不能被当作基类对象来使用。

下表总结了三种继承方式对基类成员访问权限的影响：

基类成员访问权限public 继承protected 继承private 继承
publicpublicprotectedprivate
protectedprotectedprotectedprivate
private不可访问不可访问不可访问

选择哪种继承方式取决于设计意图。如果是为了建立多态的“is-a”关系，应使用 public 继承。如果只是为了复用基类的实现细节，并且不希望暴露基类的接口，那么 private 继承是更合适的选择。protected 继承则介于两者之间，使用场景相对较少。

3.3.2 虚继承与菱形继承问题 ​

在 C++ 的多继承体系中，菱形继承（Diamond Inheritance） 是一个经典的问题。它发生在一个派生类通过两条不同的路径继承自同一个基类时，形成一个菱形的继承结构。例如，一个 Animal 类被 Bird 和 Horse 类继承，然后一个 Pegasus（飞马）类同时继承自 Bird 和 Horse。在这种情况下，Pegasus 对象中将包含两份 Animal 类的子对象，一份来自 Bird，一份来自 Horse。这会导致数据冗余和二义性问题。例如，如果 Animal 有一个 age 成员，那么 Pegasus 对象将有两个 age，访问 pegasus.age 时编译器会报错，因为它不知道应该访问哪一个。

为了解决这个问题，C++ 引入了虚继承（Virtual Inheritance） 。通过在继承声明中使用 virtual 关键字，可以确保在最终的派生类中只存在一份共享的基类子对象。例如，class Bird : virtual public Animal { ... }; 和 class Horse : virtual public Animal { ... };。当 Pegasus 继承自 Bird 和 Horse 时，编译器会确保 Pegasus 对象中只有一个 Animal 子对象，这个子对象由 Bird 和 Horse 共享。这样就消除了数据冗余和二义性。

虚继承的实现原理相对复杂。当使用虚继承时，编译器会为每个虚继承的类生成一个额外的指针（vbptr），指向一个虚基类表（vbtable）。这个表记录了虚基类子对象在派生类对象中的偏移量。当访问虚基类的成员时，程序会通过这个指针和表来找到唯一的基类子对象。虽然虚继承解决了菱形继承的问题，但它也带来了一些性能开销，因为访问虚基类的成员需要一次额外的间接寻址。因此，在设计类层次结构时，应尽量避免出现菱形继承。如果无法避免，使用虚继承是唯一的解决方案。

3.4 多态 ​

3.4.1 静态多态与动态多态 ​

多态（Polymorphism）是面向对象编程的三大核心特性之一，它指的是“一个接口，多种实现”的能力，即允许不同类的对象对同一消息做出响应。在 C++ 中，多态主要分为两种形式：静态多态（Static Polymorphism） 和 动态多态（Dynamic Polymorphism） 。这两种多态的实现机制、绑定时间和适用场景都有着本质的区别。静态多态，也称为编译期多态或早绑定（Early Binding），是指在编译阶段就确定了要调用的函数。它的实现主要依赖于函数重载（Function Overloading） 和模板（Templates） 。函数重载允许在同一个作用域内定义多个同名函数，只要它们的参数列表不同（参数的类型、数量或顺序不同）。当调用一个重载函数时，编译器会根据传入的实参类型和数量，在编译期就确定并绑定到最合适的函数版本上。例如，可以定义 int add(int a, int b) 和 double add(double a, double b)，当调用 add(3, 4) 时，编译器会绑定到 int 版本；当调用 add(3.5, 4.5) 时，会绑定到 double 版本。这种决策是在编译时完成的，因此称为静态多态。模板则提供了更强大的静态多态能力，它允许编写与类型无关的代码，编译器会在实例化模板时根据具体的类型生成相应的函数或类。

与静态多态相对的是动态多态，也称为运行期多态或晚绑定（Late Binding）。动态多态的实现依赖于虚函数（Virtual Functions） 和继承（Inheritance） 。当基类中定义了一个虚函数，并且派生类对该虚函数进行了重写（override）时，通过基类指针或引用调用该虚函数，具体执行哪个版本的函数将在运行时根据指针或引用所指向的实际对象类型来决定。例如，有一个基类 Shape 和一个派生类 Circle，Shape 中定义了虚函数 virtual void draw();，Circle 中重写了该函数。当有一个 Shape* ptr = new Circle(); 时，调用 ptr->draw();，程序会在运行时判断 ptr 实际指向的是一个 Circle 对象，因此会调用 Circle::draw()。这种在运行时根据对象实际类型进行函数绑定的机制，就是动态多态的核心。动态多态是实现“一个接口，多种实现”的关键，它使得程序可以编写出更通用、更灵活的代码，能够处理不同类型的对象，而无需在编译时知道它们的具体类型。

静态多态和动态多态各有其优缺点和适用场景。静态多态的优点是效率高，因为函数调用的决策在编译期就已经完成，没有运行时的开销。它适用于那些函数版本在编译时就能确定的情况。动态多态的优点是灵活性和可扩展性，它允许在运行时动态地改变程序的行为，非常适合处理具有继承关系的对象集合。然而，动态多态也带来了一定的运行时开销，因为每次调用虚函数都需要通过虚函数表（vtable）进行间接寻址。在现代 C++ 编程中，通常会优先使用静态多态（特别是模板），因为它能提供更好的性能和类型安全。动态多态则主要用于那些确实需要在运行时进行类型区分的场景，如插件系统、图形用户界面框架等。理解这两种多态的区别和联系，是掌握 C++ 面向对象编程的关键。

3.4.2 虚函数、纯虚函数与抽象类 ​

虚函数（Virtual Function）是 C++ 中实现动态多态的基石。通过在基类的成员函数声明前加上 virtual 关键字，该函数就被声明为虚函数。虚函数的主要作用是允许在派生类中对其进行重写（override），并且当通过基类指针或引用调用该函数时，会根据指针或引用所指向的实际对象类型来决定调用哪个版本的函数。这种机制使得程序可以在运行时动态地选择要执行的函数，从而实现多态行为。例如，一个基类 Animal 可以有一个虚函数 virtual void makeSound();，其派生类 Dog 和 Cat 可以分别重写这个函数，发出不同的声音。当有一个 Animal* 指针指向一个 Dog 对象时，调用 makeSound() 会执行 Dog 的实现。虚函数的实现通常依赖于虚函数表（vtable）机制。每个包含虚函数的类都有一个虚函数表，表中存储了该类所有虚函数的地址。每个对象内部都有一个指向其类虚函数表的指针（vptr）。当调用虚函数时，程序会通过 vptr 找到 vtable，然后根据函数在 vtable 中的偏移量来调用正确的函数版本。

纯虚函数（Pure Virtual Function）是一种特殊的虚函数，它在基类中没有函数体，其声明形式为 virtual ReturnType FunctionName() = 0;。纯虚函数的存在表明该函数在基类中只是一个接口，其具体实现必须由派生类来提供。包含至少一个纯虚函数的类被称为抽象类（Abstract Class） 。抽象类不能被实例化，也就是说，你不能创建一个抽象类的对象。它的主要作用是作为一个基类，为派生类提供一个公共的接口框架。抽象类定义了一组派生类必须实现的行为，从而强制实现了接口的统一性。例如，Shape 类可以被设计成一个抽象类，它包含纯虚函数 virtual double area() const = 0; 和 virtual void draw() const = 0;。任何从 Shape 派生的具体类，如 Circle、Rectangle 等，都必须实现 area() 和 draw() 函数，否则它们自己也将成为抽象类。通过这种方式，抽象类为一系列相关的类定义了一个清晰的、强制性的接口，使得程序可以以统一的方式处理不同类型的对象，这正是多态的核心价值所在。

虚函数、纯虚函数和抽象类共同构成了 C++ 中强大的面向对象编程模型。虚函数提供了运行时的多态能力，使得代码更加灵活和可扩展。纯虚函数和抽象类则提供了一种定义接口和实现代码重用的机制，它们强制派生类遵循统一的接口规范，从而提高了代码的可维护性和可读性。在设计一个类层次结构时，合理地使用这些特性，可以创建出既健壮又灵活的软件系统。例如，在设计一个图形编辑器时，可以使用一个抽象基类 Tool 来定义所有绘图工具的公共接口（如 onClick(), onDrag()），然后为每种具体的工具（如 PenTool, BrushTool）创建派生类并实现这些接口。这样，主程序就可以通过一个 Tool* 指针来统一处理所有工具的操作，而无需关心当前具体是哪种工具，这正是动态多态和抽象类的经典应用。

3.4.3 函数重载、重写与隐藏的区别 ​

在 C++ 中，函数重载（Overloading）、重写（Overriding）和隐藏（Hiding）是三个与函数名相关但含义和行为截然不同的概念，它们分别作用于不同的作用域和继承层次，理解它们的区别对于编写正确的面向对象代码至关重要。

函数重载发生在同一个作用域内（例如，同一个类中或同一个命名空间中）。它指的是定义多个同名函数，但它们的参数列表必须不同。参数列表的不同可以体现在参数的类型、数量或顺序上。函数重载是编译期多态（静态多态）的一种表现形式。当调用一个重载函数时，编译器会根据传入的实参类型和数量，在编译阶段就确定并选择最匹配的函数版本。例如，在一个类中可以定义 void print(int i) 和 void print(double d)。当调用 print(5) 时，编译器会选择 print(int) 版本；当调用 print(3.14) 时，会选择 print(double) 版本。需要注意的是，函数重载与函数的返回类型无关，仅通过返回类型不同是无法实现函数重载的。

函数重写（也称为覆盖）发生在继承层次中，涉及基类和派生类。它指的是派生类中定义了一个与基类中某个虚函数具有完全相同签名的函数。这里的“完全相同签名”指的是函数名、参数列表（包括类型、数量和顺序）以及返回类型（或协变返回类型）都必须一致。函数重写是实现运行期多态（动态多态）的关键。当通过基类指针或引用调用一个被重写的虚函数时，程序会在运行时根据指针或引用所指向的实际对象类型来决定调用基类的版本还是派生类的版本。例如，基类 Base 有虚函数 virtual void foo(int x);，派生类 Derived 定义了 void foo(int x) override;（override 关键字是 C++11 引入的，用于显式表明这是一个重写，可以帮助编译器检查错误），那么当 Base* ptr = new Derived(); 时，调用 ptr->foo(10); 将会执行 Derived::foo()。

函数隐藏（也称为名字隐藏）同样发生在继承层次中。它指的是派生类中定义了一个与基类中某个非虚函数同名（无论参数列表是否相同）的函数，或者定义了一个与基类虚函数同名但参数列表不同的函数。在这种情况下，派生类的函数会“隐藏”掉基类中所有同名的函数。这意味着，通过派生类对象直接调用该函数名时，只会找到派生类中定义的版本，而无法访问到被隐藏的基类版本。例如，基类 Base 有 void bar(int x);，派生类 Derived 定义了 void bar(double d);，那么 Derived 对象调用 bar(5); 会报错，因为 int 版本被隐藏了，编译器只会找到 double 版本，而 5 无法隐式转换为 double。如果想在派生类中访问被隐藏的基类函数，需要使用作用域解析运算符 ::，如 derived_obj.Base::bar(5);。

总结如下表：

特性函数重载 (Overloading)函数重写 (Overriding)函数隐藏 (Hiding)
作用域同一个类或命名空间基类和派生类之间基类和派生类之间
函数签名同名，参数列表必须不同同名，参数列表必须相同，且基类函数为虚函数同名，参数列表可以相同或不同
绑定时间编译期 (静态多态)运行期 (动态多态)编译期
关键字无virtual (基类), override (派生类, 可选)无
目的提供多种实现，提高代码可读性实现多态，允许派生类提供特定实现派生类提供新的实现，屏蔽基类版本

理解这三者的区别，特别是重写和隐藏的区别，对于避免在继承体系中出现的意外行为和难以调试的错误至关重要。

4. 标准模板库 (STL) ​

4.1 容器 ​

4.1.1 顺序容器：vector, list, deque ​

C++ 标准模板库（STL）提供了一系列功能强大且高效的容器，用于存储和管理数据。顺序容器（Sequence Containers）是其中最基本的一类，它们按照线性顺序存储元素，并允许在特定位置进行插入和删除操作。vector、list 和 deque 是三种最常用的顺序容器，它们在内部实现、性能特点和适用场景上各有不同。

std::vector 是一个动态数组，它在内存中分配一块连续的存储空间来存放元素。vector 的核心特点是支持快速的随机访问，即可以通过下标运算符 [] 或 at() 方法在常数时间 O(1) 内访问任意位置的元素。这使得 vector 非常适合需要频繁通过索引访问元素的场景。在 vector 的末尾进行插入和删除操作（push_back, pop_back）的平均时间复杂度也是 O(1)。然而，在 vector 的中间位置插入或删除元素效率较低，因为这需要移动该位置之后的所有元素，时间复杂度为 O(n)。当 vector 的容量不足以容纳新元素时，它会重新分配一块更大的内存（通常是当前容量的两倍），并将所有元素拷贝或移动到新内存中，这个过程可能会导致性能开销。

std::list 是一个双向链表，它由一系列节点组成，每个节点包含一个元素以及指向前一个和后一个节点的指针。list 的主要优势在于它支持在任意位置进行快速的插入和删除操作（时间复杂度为 O(1)），只要已经获得了指向该位置的迭代器。然而，list 不支持快速的随机访问，访问第 n 个元素需要从头或尾开始遍历，时间复杂度为 O(n)。此外，list 的元素在内存中是非连续存储的，因此它的内存开销比 vector 更大，并且缓存局部性较差，可能导致性能下降。

std::deque（double-ended queue，双端队列）是一个结合了 vector 和 list 部分特性的容器。它支持在头部和末尾进行快速的插入和删除操作（时间复杂度为 O(1)），并且也支持快速的随机访问（时间复杂度为 O(1)）。deque 的内部实现通常是一个分段连续的内存块（一个指针数组，每个指针指向一个固定大小的数据块），这使得它在两端操作时非常高效，同时又保留了随机访问的能力。deque 适用于需要在序列两端频繁进行插入和删除操作的场景，例如实现一个队列或栈。

选择哪种顺序容器取决于具体的应用需求。如果需要高效的随机访问和在末尾操作，vector 是首选。如果需要在序列中间频繁插入和删除，list 更合适。如果需要在两端都进行高效操作，deque 是一个不错的选择。

4.1.2 关联容器：map, set, unordered_map ​

关联容器（Associative Containers）是 STL 中用于存储键值对或键的集合，并根据键进行快速查找的数据结构。它们主要分为基于排序的关联容器和基于哈希的关联容器。

std::map 和 std::set 是基于红黑树（Red-Black Tree） 实现的。红黑树是一种自平衡的二叉搜索树，它能保证在最坏情况下，插入、删除和查找操作的时间复杂度都是 O(log n)。

  • std::map 存储的是键值对（std::pair<const Key, T>），其中键是唯一的，并且会根据键的排序规则自动排序。它提供了通过键来快速查找、插入和删除值的能力。
  • std::set 则只存储键，并且键也是唯一的和有序的。它主要用于快速判断一个元素是否存在于集合中。

由于 map 和 set 是有序的，它们支持范围查询（例如，查找所有在某个区间内的键），并且可以对元素进行有序的遍历。

std::unordered_map 和 std::unordered_set 是基于哈希表（Hash Table） 实现的。

  • std::unordered_map 存储的是键值对，而 std::unordered_set 只存储键。与 map 和 set 不同，它们不会对元素进行排序，元素的存储顺序是随机的。
  • 哈希表通过哈希函数将键映射到桶（bucket）中。在理想情况下（没有或很少有哈希冲突），插入、删除和查找操作的平均时间复杂度可以达到 O(1)。然而，在最坏情况下（例如发生大量哈希冲突），其性能可能会退化到 O(n)。

unordered_map 和 unordered_set 适用于对元素的顺序没有要求，但需要极高查找效率的场景。选择哪种关联容器取决于具体需求：如果需要元素有序或进行范围查询，应选择 map 或 set。如果对元素的顺序不关心，只追求最快的查找速度，那么 unordered_map 或 unordered_set 是更好的选择。

4.1.3 容器适配器：stack, queue ​

容器适配器（Container Adapters）是 STL 提供的一种特殊类型的容器，它们本身不是独立的容器，而是基于其他容器（如 deque, vector, list）来提供特定的接口和行为。容器适配器通过封装底层容器，限制其操作，从而实现了特定的数据结构。主要的容器适配器包括 stack、queue 和 priority_queue。

std::stack 实现了后进先出（LIFO, Last-In-First-Out） 的数据结构，即栈。它只允许在一端（栈顶）进行元素的插入（push）和删除（pop）操作。stack 默认使用 std::deque 作为其底层容器，但也可以指定使用 std::vector 或 std::list。stack 提供了 push(), pop(), top() 等接口，但没有提供迭代器，因为它不允许对除栈顶之外的任何元素进行访问。

std::queue 实现了先进先出（FIFO, First-In-First-Out） 的数据结构，即队列。它允许在一端（队尾）进行插入操作（push），在另一端（队头）进行删除操作（pop）。queue 默认也使用 std::deque 作为其底层容器。它提供了 push(), pop(), front(), back() 等接口，同样不提供迭代器。

std::priority_queue 实现了优先队列，它允许用户以任意顺序插入元素，但删除操作（pop）总是移除优先级最高的元素（默认是最大的元素）。priority_queue 默认使用 std::vector 作为底层容器，并使用 std::less 作为比较函数，因此它是一个大顶堆。用户可以自定义比较函数来改变优先级的定义。

容器适配器提供了一种简洁、安全的方式来实现常用的数据结构，它们隐藏了底层容器的复杂性，只暴露必要的接口，使得代码更加清晰和易于维护。

4.2 迭代器 ​

4.2.1 迭代器的种类与失效问题 ​

迭代器（Iterator）是 C++ STL 中的一个核心概念，它提供了一种统一的方式来访问和遍历容器中的元素，而无需关心容器的底层实现。迭代器的行为类似于指针，它指向容器中的某个元素，并支持解引用（*）、递增（++）、递减（--）等操作。根据功能的不同，STL 迭代器被分为五种类型，形成了一个层次结构：

  1. 输入迭代器（Input Iterator） ：只读，单向移动。支持 ==, !=, *, ++。例如，std::istream_iterator。
  2. 输出迭代器（Output Iterator） ：只写，单向移动。支持 *, ++。例如，std::ostream_iterator。
  3. 前向迭代器（Forward Iterator） ：可读写，单向移动。支持输入和输出迭代器的所有操作。例如，std::forward_list 的迭代器。
  4. 双向迭代器（Bidirectional Iterator） ：可读写，双向移动。支持前向迭代器的所有操作，并额外支持 --。例如，std::list, std::set, std::map 的迭代器。
  5. 随机访问迭代器（Random Access Iterator） ：可读写，双向移动，并支持随机访问。支持双向迭代器的所有操作，并额外支持 +, -, +=, -=, [], <, >, <=, >=。例如，std::vector, std::deque 的迭代器。

迭代器失效（Iterator Invalidation） 是一个非常重要且容易出错的问题。它指的是在容器被修改（如插入、删除元素）后，原本指向容器中元素的迭代器可能不再有效，继续使用它会导致未定义行为。迭代器失效的规则因容器类型而异：

  • vector: 在任意位置插入或删除元素，都会导致指向该位置及其之后的所有迭代器失效。如果插入操作导致 vector 重新分配内存，那么所有迭代器都会失效。
  • deque: 在首尾插入元素，只会使指向首尾元素的迭代器失效。在中间插入或删除元素，会使所有迭代器失效。
  • list: 插入操作不会使任何迭代器失效。删除操作只会使指向被删除元素的迭代器失效。
  • 关联容器 (map, set, unordered_map 等): 插入操作不会使任何迭代器失效。删除操作只会使指向被删除元素的迭代器失效。

为了避免迭代器失效带来的问题，程序员需要了解所用容器的失效规则，并在修改容器后及时更新或重新获取迭代器。例如，在循环中删除 vector 的元素时，应该使用 erase 的返回值来获取下一个有效的迭代器。

4.2.2 迭代器与指针的关系 ​

迭代器和指针在 C++ 中有着密切的关系，可以说迭代器是泛化的指针。指针是 C++ 语言内置的一种数据类型，它直接表示内存地址，可以进行算术运算和解引用等操作。而迭代器则是一个更抽象的概念，它定义了一组操作（如 *, ++, --, == 等），用于遍历容器中的元素，而无需暴露容器的内部结构。

从功能上看，指针满足随机访问迭代器的所有要求，因此指针本身就是一种迭代器。例如，在 C++ 中，可以使用指针来遍历 C 风格的数组，就像使用迭代器遍历 STL 容器一样。std::vector 的迭代器在大多数实现中就是原始指针的封装，因此 vector 的迭代器可以提供与指针几乎相同的性能。

然而，迭代器比指针更通用、更安全。首先，迭代器是与特定容器类型相关联的，它知道如何正确地遍历该容器。例如，std::list 的迭代器在递增时会自动跳转到下一个节点，而指针的递增只是简单地增加一个固定的字节数。其次，迭代器可以提供额外的类型安全和边界检查。例如，一些调试版本的 STL 实现会在迭代器解引用时检查是否越界。最后，迭代器提供了一种统一的接口，使得算法可以与任何提供相应迭代器的容器协同工作，这正是 STL 设计的核心思想——算法与数据结构的分离。

总而言之，指针是迭代器的一种具体实现，而迭代器是更抽象、更通用的概念。在 STL 中，我们优先使用迭代器，因为它提供了更好的封装性、通用性和安全性，使得代码更易于编写、阅读和维护。

4.3 算法 ​

4.3.1 常用算法：sort, find, for_each ​

C++ 标准模板库（STL）提供了一个功能强大的算法库，其中包含了许多用于操作容器中元素的通用算法。这些算法通过迭代器与容器进行交互，从而实现了算法与数据结构的分离，提高了代码的复用性。

std::sort 是最常用的排序算法之一，它通常实现为内省排序（introsort），结合了快速排序、堆排序和插入排序的优点，在大多数情况下具有 O(N log N) 的时间复杂度。sort 算法可以对指定范围内的元素进行排序，默认使用 < 运算符进行比较，也可以接受一个自定义的比较函数对象。例如，std::sort(vec.begin(), vec.end()); 会对 vec 进行升序排序。

std::find 是一个线性查找算法，它在指定范围内顺序查找与给定值相等的第一个元素，并返回指向该元素的迭代器。如果未找到，则返回指向范围末尾的迭代器。find 算法的时间复杂度为 O(N)。例如，auto it = std::find(vec.begin(), vec.end(), 42); 会在 vec 中查找值为 42 的元素。

std::for_each 是一个遍历算法，它对指定范围内的每个元素执行一个给定的操作（通常是一个函数对象或 Lambda 表达式）。for_each 算法常用于对容器中的元素进行统一的处理，例如打印、修改等。例如，std::for_each(vec.begin(), vec.end(), [](int& n) { n *= 2; }); 会将 vec 中的每个元素都乘以 2。

除了这些，STL 算法库还提供了许多其他有用的算法，如 binary_search（二分查找）、accumulate（累加）、copy（复制）、replace（替换）等，它们极大地简化了日常的编程任务 。

4.3.2 函数对象（仿函数）与 Lambda 表达式 ​

函数对象（Function Objects），也称为仿函数（Functors） ，是 C++ STL 中一个强大的概念。它是一个重载了函数调用运算符 operator() 的类的对象。由于这个特性，函数对象可以像普通函数一样被调用，即 obj()。与普通函数相比，函数对象具有两大优势：首先，它可以拥有状态，因为它是一个类的实例，可以包含成员变量来存储信息。其次，它可以被作为参数传递给 STL 算法，从而使算法的行为更加灵活和可定制。例如，可以定义一个 AddValue 类，其构造函数接受一个值，其 operator() 将传入的参数与这个值相加。然后，可以将 AddValue 的对象传递给 std::for_each 算法，以对容器中的每个元素执行加值操作。

Lambda 表达式是 C++11 引入的一项新特性，它提供了一种更简洁、更方便的方式来创建匿名函数对象。Lambda 表达式的基本语法是 [capture](parameters) -> return_type { body }。其中，capture 是捕获列表，用于指定如何从外部作用域捕获变量；parameters 是参数列表；return_type 是返回类型（可以省略，由编译器自动推导）；body 是函数体。Lambda 表达式极大地简化了代码，尤其是在需要将简单函数作为参数传递给算法时。例如，使用 Lambda 表达式可以轻松地实现对容器的排序：

cpp
std::sort(vec.begin(), vec.end(), [](const int& a, const int& b) {
    return a > b; // 降序排序
});

在这个例子中，[](const int& a, const int& b) { return a > b; } 就是一个 Lambda 表达式，它创建了一个临时的函数对象，并将其传递给 std::sort 算法作为比较准则。

Lambda 表达式和函数对象在功能上是等价的，编译器会将 Lambda 表达式转换为一个匿名的函数对象类。然而，Lambda 表达式在语法上更加简洁，尤其是在捕获变量时，无需手动定义一个类并声明成员变量。因此，在现代 C++ 中，Lambda 表达式已经成为编写 STL 算法回调的首选方式，而传统的函数对象则更多地用于需要复用、具有复杂状态或需要多个重载的 operator() 的场景 。

4.4 函数对象与 Lambda 表达式 ​

4.4.1 函数对象的定义与使用 ​

函数对象（Function Object），通常被称为仿函数（Functor） ，是 C++ 中一个强大的编程技巧，它指的是任何一个可以像函数一样被调用的对象。在 C++ 中，这通常通过定义一个类或结构体，并在其中重载函数调用运算符 operator() 来实现。一旦一个类重载了 operator()，它的实例就可以像函数一样使用，即在对象名后面加上括号 () 并传入参数。

函数对象相比于普通函数，其核心优势在于它可以拥有状态。因为函数对象本质上是一个类的实例，所以它可以在其成员变量中存储信息。这个状态可以在构造函数中初始化，并在多次调用 operator() 之间保持不变。这使得函数对象非常灵活，可以创建出行为可定制的“函数”。例如，可以创建一个 Multiplier 类，它在构造函数中接受一个乘数，然后在 operator() 中将传入的参数与这个乘数相乘。

函数对象在 STL 中扮演着至关重要的角色。STL 算法（如 std::sort, std::for_each, std::find_if 等）通常接受一个函数对象作为参数，用于定义算法的具体行为，如比较准则、操作逻辑或判断条件。通过传递不同的函数对象，可以极大地提高 STL 算法的通用性和灵活性。例如，std::sort 可以接受一个比较函数对象来决定元素的排序方式。

4.4.2 Lambda 表达式的语法与捕获列表 ​

Lambda 表达式是 C++11 引入的一项革命性特性，它提供了一种更简洁、更方便的方式来创建匿名函数对象。Lambda 表达式的语法非常灵活，其基本形式如下：

[capture_list](parameter_list) mutable noexcept -> return_type { function_body }

其中，只有捕获列表 [] 和函数体 {} 是必需的，其他部分都可以省略。

  • 捕获列表 [capture_list] ：这是 Lambda 表达式最独特的部分，它定义了如何从 Lambda 表达式所在的外部作用域捕获变量，以便在函数体中使用。捕获方式有多种：

    • []：不捕获任何外部变量。
    • [=]：以值的方式捕获所有外部变量。
    • [&]：以引用的方式捕获所有外部变量。
    • [x]：仅以值的方式捕获变量 x。
    • [&x]：仅以引用的方式捕获变量 x。
    • [=, &x]：以值的方式捕获所有外部变量，但 x 以引用方式捕获。
    • [&, x]：以引用的方式捕获所有外部变量，但 x 以值方式捕获。 默认情况下，以值方式捕获的变量在 Lambda 函数体中是只读的。如果需要在函数体中修改以值方式捕获的变量的副本，需要使用 mutable 关键字。

  • 参数列表 (parameter_list) ：与普通函数的参数列表类似，定义了 Lambda 表达式的输入参数。在 C++14 中，可以使用 auto 作为参数类型，实现泛型 Lambda。

  • mutable 关键字：当 Lambda 表达式以值方式捕获变量时，默认情况下这些变量在函数体中是 const 的，不能被修改。使用 mutable 关键字可以取消这种 const 限制，允许修改捕获的变量的副本。

  • noexcept 关键字：用于指定 Lambda 表达式是否会抛出异常。

  • 返回类型 -> return_type：用于显式指定 Lambda 表达式的返回类型。如果省略，编译器会根据函数体中的 return 语句自动推导返回类型。

  • 函数体 { function_body }：包含 Lambda 表达式要执行的代码。

Lambda 表达式的引入极大地提高了代码的简洁性和可读性，尤其是在与 STL 算法结合使用时，可以避免编写大量繁琐的函数对象类，使代码更加紧凑和直观 。

5. 模板编程 ​

5.1 函数模板与类模板 ​

5.1.1 模板的定义与实例化 ​

模板（Templates）是 C++ 中实现泛型编程（Generic Programming） 的核心机制，它允许程序员编写与类型无关的通用代码。模板可以分为函数模板和类模板两种。函数模板用于定义一个可以处理多种数据类型的函数，而类模板则用于定义一个可以存储和操作多种数据类型的类。模板的定义使用 template 关键字，后跟一个模板参数列表，该列表用尖括号 < > 括起来。模板参数通常使用 typename 或 class 关键字来声明，表示一个类型参数。例如，一个交换两个变量值的函数模板可以定义为：template <typename T> void swap(T& a, T& b) { T temp = a; a = b; b = temp; } 。当编译器遇到一个函数模板的调用时，例如 swap(x, y)，它会根据实参 x 和 y 的类型来推断模板参数 T 的具体类型，并生成一个针对该类型的函数实例，这个过程称为模板实例化。同样，类模板的定义也类似，例如 template <typename T> class MyContainer { ... };。在使用类模板时，必须显式地指定模板参数的类型，例如 MyContainer<int> myIntContainer;，编译器会根据指定的类型生成一个具体的类。模板编程极大地提高了代码的复用性，避免了为每种数据类型都编写重复代码的繁琐工作 。

5.1.2 模板参数推导 ​

模板参数推导（Template Argument Deduction）是 C++ 编译器在实例化函数模板时的一个关键过程。当调用一个函数模板时，如果模板参数没有显式指定，编译器会根据函数调用时提供的实参类型来自动推断出模板参数的具体类型。这个过程使得函数模板的使用更加简洁和方便。

例如，对于一个函数模板 template<typename T> void foo(T param);，当调用 foo(42); 时，编译器会推断出 T 的类型是 int。当调用 foo(3.14); 时，T 的类型被推断为 double。

然而，模板参数推导也有一些复杂的规则和需要注意的地方：

  • 引用折叠（Reference Collapsing） ：当模板参数 T 被推导为引用类型时，会发生引用折叠。T& & 会折叠为 T&，T& && 会折叠为 T&，T&& & 会折叠为 T&，而 T&& && 会折叠为 T&&。这在实现完美转发时非常重要。
  • 值传递与引用传递：当函数模板的参数是按值传递时（如 T param），推导出的 T 会忽略实参的 const 和 volatile 限定符。例如，对于 const int x = 10; foo(x);，T 被推断为 int，而不是 const int。但如果参数是按引用传递（如 T& param），const 和 volatile 限定符会被保留。
  • 数组和函数到指针的退化：当传递一个数组或函数作为实参时，它们会退化为指针。例如，对于一个 int arr[10];，传递给 template<typename T> void foo(T param); 时，T 会被推断为 int*，而不是 int[10]。

理解模板参数推导的规则对于编写正确、高效的泛型代码至关重要，尤其是在处理复杂类型和引用时。

5.2 模板特化与偏特化 ​

5.2.1 全特化与偏特化的概念 ​

模板特化（Template Specialization）是 C++ 模板编程中的一个重要特性，它允许程序员为特定的模板参数提供一个专门的实现，以替代通用的模板定义。模板特化分为全特化（Full Specialization）和偏特化（Partial Specialization）两种。全特化是指为模板的所有参数都指定了具体的类型或值。例如，对于一个通用的 template <typename T> class MyClass { ... };，我们可以为 int 类型提供一个全特化版本：template <> class MyClass<int> { ... };。当 MyClass 被实例化为 MyClass<int> 时，编译器会选择使用这个特化版本，而不是通用的模板。偏特化（也称为部分特化）是指只为模板的部分参数指定了具体的类型或值，或者对模板参数施加了额外的约束。偏特化只能用于类模板，不能用于函数模板。例如，对于一个 template <typename T, typename U> class MyPair { ... };，我们可以为第一个参数是 int 的情况提供一个偏特化版本：template <typename U> class MyPair<int, U> { ... };。偏特化使得模板能够处理更复杂的情况，为不同的类型组合提供定制化的实现，从而提高了模板的灵活性和表达能力 。

5.2.2 特化的应用场景 ​

模板特化在 C++ 编程中有着广泛的应用，它允许程序员针对特定类型或类型组合提供优化的或完全不同的实现，从而提高代码的性能和灵活性。

全特化最常见的应用场景是为特定类型提供高度优化的实现。例如，一个通用的矩阵乘法模板可能对任何类型都适用，但对于 float 或 double 类型，可以使用 SIMD 指令集（如 SSE, AVX）来编写一个高度优化的特化版本，以获得数倍的性能提升。另一个例子是为 bool 类型特化 std::vector，因为 bool 在内存中通常以位（bit）为单位存储，而不是字节，所以需要一个特殊的实现来管理这些位。

偏特化的应用场景则更加灵活。一个常见的用法是为指针类型提供一个通用的特化版本。例如，可以为一个智能指针模板提供一个偏特化，当模板参数是指针类型时，启用特殊的引用计数逻辑。另一个例子是实现类型萃取（Type Traits），如 std::is_pointer<T>。这可以通过偏特化来实现：一个通用的模板定义 is_pointer<T> 为 false，然后为 T* 提供一个偏特化，将其定义为 true。这使得可以在编译期判断一个类型是否为指针。

此外，偏特化还可以用于实现策略模式（Strategy Pattern）的编译期版本。通过为不同的策略（类型）提供不同的特化实现，可以在编译期选择最优的算法或行为，而无需运行时的多态开销。例如，一个排序算法模板可以根据元素类型是否为 POD（Plain Old Data）类型，在编译期选择使用 std::memcpy 的快速拷贝策略还是逐个元素的拷贝策略。

5.3 模板元编程 (TMP) ​

5.3.1 编译期计算 ​

模板元编程（Template Metaprogramming, TMP）是 C++ 中一种利用模板在编译期执行计算的技术。它的核心思想是将计算从运行时转移到编译时，从而生成高度优化、无运行时开销的代码。TMP 的执行“引擎”是 C++ 的模板实例化机制。通过递归地实例化模板，可以在编译期完成复杂的逻辑判断、循环和数值计算。

TMP 的基本工具包括：

  • 模板特化：用于实现条件判断（if-else）。一个通用的模板定义代表 if 的 false 分支，而一个特化版本代表 true 分支。
  • 递归模板实例化：用于实现循环。一个模板在其实现中实例化自身，直到达到一个基本情况（通过特化定义），从而终止递归。
  • 枚举常量或 static const 成员：用于在编译期存储和返回计算结果。

一个经典的 TMP 例子是计算阶乘：

cpp
// 基本情况：0! = 1
template<int N>
struct Factorial {
    static const int value = N * Factorial<N - 1>::value;
};

template<>
struct Factorial<0> {
    static const int value = 1;
};

// 使用
int main() {
    int result = Factorial<5>::value; // result 在编译期被计算为 120
}

在这个例子中，Factorial<5>::value 的求值过程会触发一系列的模板实例化，最终在编译期计算出结果 120，运行时没有任何计算开销。

TMP 可以用于实现许多高级功能，如类型萃取（Type Traits）、策略选择、表达式模板（用于优化数值计算）等。然而，TMP 的语法通常比较复杂，代码可读性较差，编译错误信息也难以理解。因此，它应该被谨慎使用，主要用于那些对性能有极致要求或需要强大类型操作的库开发中。

5.3.2 SFINAE 与 enable_if ​

SFINAE（Substitution Failure Is Not An Error，替换失败不是错误）是 C++ 模板元编程中的一个核心原则。它规定，在函数模板的重载决议过程中，如果替换模板参数导致一个无效的代码构造，那么这个函数模板会被从重载集中移除，而不是导致编译错误。这个原则使得可以根据类型特征在编译期选择性地启用或禁用某些函数模板。

std::enable_if 是一个利用 SFINAE 原则的工具，它通常与函数模板的返回类型或额外模板参数结合使用，来根据一个编译期布尔条件来控制函数模板是否参与重载决议。std::enable_if<condition, T>::type 的定义是：如果 condition 为 true，则 type 被定义为 T；如果 condition 为 false，则 type 不存在，导致替换失败。

enable_if 的典型用法是在函数模板的返回类型中：

cpp
// 只有当 T 是整数类型时，这个模板才有效
template<typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
process(T value) {
    return value * 2;
}

// 只有当 T 是浮点类型时，这个模板才有效
template<typename T>
typename std::enable_if<std::is_floating_point<T>::value, T>::type
process(T value) {
    return value * 3.14;
}

在这个例子中，当调用 process(42) 时，std::is_integral<int>::value 为 true，第一个模板被启用。当调用 process(3.14) 时，std::is_floating_point<double>::value 为 true，第二个模板被启用。如果传入一个既不是整数也不是浮点的类型，两个模板都会被 SFINAE 排除，导致编译错误（找不到匹配的重载）。

enable_if 是实现编译期多态和类型约束的强大工具，它在现代 C++ 中被广泛用于库的设计中，以实现更灵活、更安全的泛型接口。

6. 异常处理 ​

6.1 异常的抛出与捕获 ​

6.1.1 try, catch, throw 的用法 ​

C++ 的异常处理机制提供了一种结构化的方式来处理程序运行时可能出现的错误。它主要由三个关键字构成：try、catch 和 throw。throw 用于抛出一个异常。当程序遇到一个错误或异常情况时，可以使用 throw 语句抛出一个异常对象。这个对象可以是任何类型，例如一个整数、一个字符串，或者一个自定义的异常类对象。例如，throw std::runtime_error("Something went wrong");。try 块用于包围可能