C++-Primer-Plus：18 个重点笔记

1. C++的 const 比 C 语言#define 更好的原因？

在C++中，const 关键字相比于 C 语言中的 #define 预处理器指令，提供了更为强大、安全且易于维护的常量定义方式。以下是 const 比 #define 更好的几个主要原因：

类型安全：
- const 关键字可以指定常量的类型，这有助于编译器进行类型检查，从而减少因类型不匹配导致的错误。
- #define 只是简单的文本替换，不进行类型检查，容易导致类型错误。
作用域：
- const 常量具有块作用域（局部变量）、文件作用域（静态局部变量或全局变量，使用 static 修饰）或命名空间作用域，这有助于控制常量的可见性和生命周期。
- #define 指令定义的宏没有作用域的概念，一旦定义，在整个源文件中都有效，除非显式使用 #undef 取消定义，这可能会导致意外的名字冲突。
调试和可读性：
- 使用 const 可以让代码更加清晰，易于理解，因为 const 常量在调试器中可见，具有类型信息。
- #define 宏在预处理阶段就被替换为文本，调试时看不到宏的名称，只能看到替换后的结果，这增加了调试的难度。
存储方式：
- const 常量可能被编译器优化，例如，如果编译器能够确定 const 常量的值在编译时已知，它可能会将这个值直接嵌入到使用它的代码中，从而避免内存访问开销。
- #define 宏的替换结果完全取决于宏的定义和使用方式，编译器很难对其进行优化。
内联函数与模板参数：
- const 常量可以用作内联函数和模板的参数，而 #define 宏通常不用于这些目的，因为它们不遵循C++的类型系统和作用域规则。
内存占用：
- 对于简单的 const 变量，编译器可能会将其存储在只读数据段中，从而节省内存空间。
- #define 宏仅仅是文本替换，不直接涉及内存分配，但如果宏定义的是大型结构体或数组，可能会导致代码膨胀。

综上所述，const 关键字在C++中提供了比 #define 更为安全、高效和易于维护的常量定义方式，是现代C++编程中推荐使用的常量定义方法。

2. 不能简单地将整数赋给指针

在C++中，不能简单地将整数（如int类型的值）赋给指针，这是因为整数和指针在内存中的表示方式和用途有着本质的区别。下面我将详细解释这一点，并给出一些相关的上下文和例子。

整数与指针的区别

内存表示：
- 整数：在内存中直接存储数值，例如int类型可能占用4个字节（这取决于编译器和平台），并直接表示一个整数值。
- 指针：在内存中存储的是一个地址，这个地址指向另一个内存位置，该位置可以是变量的存储位置、函数的地址等。指针的大小（即地址的大小）也取决于平台和编译器，通常是4字节（32位系统）或8字节（64位系统）。
用途：
- 整数：用于算术运算、条件判断等，表示数量、索引等。
- 指针：用于间接访问内存中的数据或函数，允许程序动态地操作内存中的数据。

为什么不能将整数赋给指针

将整数直接赋给指针在C++中是类型不安全的，因为整数表示的是一个具体的数值，而不是内存地址。如果允许这样做，那么指针将会指向一个随机的内存位置，这可能导致未定义行为，包括但不限于访问违规、数据损坏或程序崩溃。

示例

int main() {
    int number = 42;
    int* ptr;

    // 错误：尝试将整数直接赋给指针
    // ptr = number; // 这会导致编译错误

    // 正确的做法是将整数的地址赋给指针
    ptr = &number; // 使用取地址符&获取number的地址，然后赋给ptr

    // 现在ptr指向了number的内存地址
    // 可以通过ptr来访问或修改number的值
    *ptr = 100; // 修改number的值为100

    return 0;
}

结论

因此，在C++中不能简单地将整数赋给指针，这是出于类型安全和内存保护的考虑。如果需要让指针指向某个具体的内存位置，应该使用该位置的地址（通常是通过取地址符&获得）。这样做可以确保指针的正确性和程序的稳定性。

3. 为什么说前缀++/–比后缀++/–的效率高？

在C++中，关于前缀递增/递减操作符（++x/--x）与后缀递增/递减操作符（x++/x--）的效率差异，实际上是一个复杂但有趣的话题。首先，需要明确的是，这种效率差异主要源自于操作符的语义和实现方式，而不是因为前缀操作符在语法上更简洁或更底层。

前缀++/– 操作符

语义：前缀递增/递减操作符直接作用于变量，并立即返回递增/递减后的新值。
实现：由于不需要保存操作前的值，编译器在实现时可以直接对变量进行修改，并立即返回新值。这种实现方式通常更为直接和高效。

后缀++/– 操作符

语义：后缀递增/递减操作符也是作用于变量，但返回的是递增/递减前的旧值。
实现：为了实现这个语义，编译器需要采取一些额外的步骤。一种常见的实现方式是，在递增/递减变量之前，先保存变量的当前值，然后递增/递减变量，最后返回之前保存的旧值。这种额外的步骤（即保存旧值）是后缀操作符相对于前缀操作符而言效率较低的主要原因。

效率差异的实际考量

现代编译器优化：值得注意的是，现代C++编译器（如GCC、Clang、MSVC等）非常智能，它们能够识别出许多情况下前缀和后缀操作符的使用不会对性能产生实际影响，并进行相应的优化。因此，在某些情况下，前缀和后缀操作符的效率差异可能并不明显，甚至不存在。
上下文依赖：效率差异是否显著还取决于具体的上下文。例如，在表达式求值中，如果后缀操作符的返回值没有被使用（即被丢弃了），那么编译器可能会进行优化，消除不必要的保存旧值的步骤。

总结

虽然从理论上讲，前缀递增/递减操作符由于不需要保存操作前的值而可能更高效，但这种差异在现代C++编程实践中往往被编译器的优化所掩盖。因此，在选择使用前缀还是后缀操作符时，更应该关注的是代码的清晰性和可读性，而不是微小的效率差异。在大多数情况下，遵循团队的编码规范或个人的编码习惯即可。

最后，对于C++ Primer这样的经典书籍来说，它可能更多地是从语言规范和实现原理的角度来讨论这个问题，而不是从实际应用中的性能差异出发。因此，在面试中回答这个问题时，可以结合上述分析，既展示对语言规范的理解，也表达对现代编译器优化能力的认识。

4. 逗号运算符

在C++中，逗号运算符（,）是一个二元运算符，它用来顺序执行两个表达式，并返回第二个表达式的值。逗号运算符的优先级是最低的，仅高于赋值运算符（=）。这意味着，如果在表达式中使用逗号运算符，并且没有括号明确指定运算顺序，逗号运算符会最后执行。

基本用法

逗号运算符的基本形式是：

expression1, expression2

这个表达式首先评估expression1，然后丢弃其结果（即使expression1有副作用，比如修改了某个变量的值），接着评估expression2，并返回expression2的结果。

示例

#include <iostream>

int main() {
    int a = 5, b = 10, c;
    c = (a++, a * 2, a + b); // 注意这里的括号，它们确保逗号运算符按预期顺序执行
    std::cout << "c = " << c << ", a = " << a << std::endl;
    // 输出：c = 16, a = 6
    // 因为 a++ 首先执行，a 变为 6，然后 a * 2（结果为 12，但被丢弃），最后 a + b（结果为 16，赋值给 c）
    return 0;
}

使用场景

逗号运算符在C++中的使用场景相对较少，因为大多数情况下，我们可以通过更清晰的方式（如分号分隔的语句、函数调用链等）来表达相同的逻辑。然而，在一些特定情况下，比如for循环的初始化部分，逗号运算符非常有用，因为它允许我们在循环开始前同时执行多个操作。

注意事项

逗号运算符的返回值是第二个表达式的值，而不是一个包含两个表达式值的某种特殊类型。
由于逗号运算符的优先级非常低，如果它与其他运算符混合使用，可能需要使用括号来明确指定运算顺序。
在编写代码时，应谨慎使用逗号运算符，以避免写出难以理解和维护的代码。在某些情况下，使用分号分隔的语句或函数调用可能更清晰。

结论

逗号运算符是C++中的一个基本但相对不常用的运算符。它允许开发者在单个表达式中顺序执行多个操作，并返回最后一个操作的结果。然而，由于其优先级较低且可能导致代码可读性下降，因此在日常编程中应谨慎使用。

5. 有用的字符函数库

在C++岗位面试中，当面试官提出关于“有用的字符函数库”的问题时，主要考察的是对C++标准库中与字符处理相关功能的了解。以下是一个准确、全面且深入的回答：

C++中的字符函数库

C++从C语言继承了一个非常有用的字符函数库，这些函数主要定义在头文件<cctype>（C++中也常通过<ctype.h>引入，但推荐使用C++风格的<cctype>）中。这些函数可以简化诸如判断字符类型（如大写字母、小写字母、数字、标点符号等）、字符转换（如大小写转换）等任务。

主要字符函数

类型判断函数
- isalnum(int c): 如果c是字母或数字，则返回非零值（true）。
- isalpha(int c): 如果c是字母，则返回非零值（true）。
- isdigit(int c): 如果c是数字（‘0’-‘9’），则返回非零值（true）。
- islower(int c): 如果c是小写字母，则返回非零值（true）。
- isupper(int c): 如果c是大写字母，则返回非零值（true）。
- isspace(int c): 如果c是空白字符（如空格、制表符、换行符等），则返回非零值（true）。
- ispunct(int c): 如果c是标点符号，则返回非零值（true）。
- iscntrl(int c): 如果c是控制字符（如回车、换行符等），则返回非零值（true）。
字符转换函数
- tolower(int c): 如果c是大写字母，则返回其小写形式；否则，返回c本身。
- toupper(int c): 如果c是小写字母，则返回其大写形式；否则，返回c本身。

使用示例

以下是一个简单的使用示例，展示了如何统计输入文本中的字母、数字、空格、标点符号以及其他字符的数量：

#include <iostream>
#include <cctype> // 包含字符处理函数

int main() {
    std::cout << "Enter text for analysis, and type @ to terminate input.\n";
    char ch;
    int whitespace = 0, digits = 0, chars = 0, punct = 0, others = 0;

    while (std::cin.get(ch) && ch != '@') {
        if (isalpha(ch)) {
            chars++;
        } else if (isspace(ch)) {
            whitespace++;
        } else if (isdigit(ch)) {
            digits++;
        } else if (ispunct(ch)) {
            punct++;
        } else {
            others++;
        }
    }

    std::cout << chars << " letters, "
              << whitespace << " whitespace, "
              << digits << " digits, "
              << punct << " punctuations, "
              << others << " others.\n";

    return 0;
}

面试建议

在面试中，除了展示对这些函数的了解外，还可以进一步讨论字符函数库在实际编程中的应用场景，比如文本处理、数据验证等。此外，也可以提及C++标准库中的其他与字符处理相关的部分，如<string>头文件中的std::string类及其成员函数，这些也是处理字符串数据时非常有用的工具。

综上所述，对C++中的字符函数库有深入的了解，并在面试中能够准确、全面地展示其用法和应用场景，将有助于提升面试的表现。

6. 快排中中值的选取

在C++或任何算法相关的面试中，关于快速排序（Quick Sort）中中值（median）或基准值（pivot）的选取是一个常见的问题。快速排序算法的效率很大程度上依赖于基准值的选择。理想情况下，基准值应该接近数据的中位数，这样可以使得划分后的两个子数组大小相近，从而达到最好的时间复杂度 $\log n)$ 。然而，找到中位数本身是一个相对昂贵的操作，特别是对于未排序的数组。因此，快速排序中通常采用一些启发式方法来选择基准值。

常见的基准值选取策略

固定位置选择：
- 最简单的方法是总是选择数组的第一个元素、最后一个元素或中间元素作为基准值。这种方法简单但不一定高效，特别是当数组已经接近排序状态（例如，几乎有序或完全逆序）时。
随机选择：
- 从数组中随机选择一个元素作为基准值。这种方法在平均情况下表现良好，因为它减少了特定输入模式（如已排序或逆序数组）对算法性能的影响。
三数中值分割法（Median-of-Three）：
- 选择数组的第一个元素、最后一个元素和中间元素，然后计算这三个数的中值作为基准值。这种方法比简单选择第一个或最后一个元素更健壮，因为它考虑了数组两端的元素。
五数中值分割法（Median-of-Five）：
- 类似于三数中值分割法，但选择更多的元素（如第一个、中间、最后一个，以及它们两侧的元素）来找到中值。这种方法进一步提高了基准值选择的健壮性，但增加了计算成本。
九数中值分割法（或其他更大的数）：
- 类似于五数中值分割法，但选择更多的元素来找到中值。这种方法在理论上可以提高基准值的代表性，但计算成本也更高。
使用外部算法：
- 在极端情况下，可以使用部分排序算法（如堆排序的变体）或选择算法（如快速选择算法）来找到数组中第k小的元素作为基准值。然而，这种方法通常过于昂贵，不适合作为快速排序的基准值选择策略。

面试中的回答策略

在面试中，你可以首先提到固定位置选择和随机选择这两种简单方法，并指出它们的优缺点。然后，重点介绍三数中值分割法，因为它是一个在效率和健壮性之间取得良好平衡的选择策略。你可以简要解释为什么选择这种方法，并给出它的实现思路（即先找到三个候选元素，然后比较它们以找到中值，最后将中值作为基准值进行分区）。

如果面试官对这个问题特别感兴趣，你还可以提到五数中值分割法或九数中值分割法，但强调这些方法的计算成本更高，通常只在特定场景下使用。

最后，记得强调快速排序的性能不仅取决于基准值的选择，还取决于分区的质量和递归调用的优化（如尾递归优化和小数组处理策略）。

7. C++存储方案

在C++中，存储方案主要涉及到数据的存储持续性、作用域和链接性。这些概念对于理解C++程序中变量的生命周期、可见性和可访问性至关重要。以下是关于C++存储方案的详细解答：

1. 存储持续性

C++提供了三种不同的存储持续性方案，它们决定了变量在程序中的生命周期：

自动存储持续性（Automatic Storage Duration）：在函数定义中声明的变量（包括函数参数）具有自动存储持续性。这些变量的生命周期从它们被创建时开始，到包含它们的块执行完毕时结束。它们通常存储在栈上。
静态存储持续性（Static Storage Duration）：在函数定义外定义的变量，以及使用static关键字声明的变量，具有静态存储持续性。这些变量的生命周期贯穿整个程序执行期间。它们可以存储在程序的静态数据区，对于未初始化的静态变量，其所有位都被设置为0。
动态存储持续性（Dynamic Storage Duration）：使用new操作符分配的内存具有动态存储持续性。这种内存会一直存在，直到使用delete操作符将其释放，或者程序结束。这种内存有时也被称为自由存储（free store）。

2. 作用域

作用域描述了名称在文件（或翻译单元）中的可见范围。C++中主要有以下几种作用域：

函数作用域：在函数内部声明的变量具有函数作用域，它们仅在该函数内部可见。
块作用域：在代码块（如大括号{}包围的区域）内声明的变量具有块作用域，它们仅在该块内部可见。
全局作用域：在函数定义外部声明的变量具有全局作用域，它们在程序的任何地方都可见（除非被更内层的作用域隐藏）。
命名空间作用域：在命名空间内声明的名称具有命名空间作用域，它们仅在该命名空间内部可见，但可以通过使用using声明或using编译指令在外部访问。

3. 链接性

链接性决定了变量或函数是否可以在不同的编译单元（如不同的源文件）之间共享。C++中的链接性主要分为以下几种：

外部链接性：默认情况下，全局变量和函数具有外部链接性，意味着它们可以在不同的编译单元之间共享。
内部链接性：使用static关键字声明的全局变量或函数具有内部链接性，意味着它们只能在定义它们的编译单元内部访问。
无链接性：具有自动存储持续性的变量和函数参数没有链接性，因为它们只存在于它们被声明的块或函数中。

4. 其他概念

寄存器变量：使用register关键字声明的变量（尽管在现代编译器中，register关键字更多地被视为一种提示而非强制要求）旨在存储在CPU的寄存器中，以提高访问速度。由于寄存器变量没有内存地址，因此不能将地址操作符用于它们。
作用域解析符：::作用域解析符用于指定特定的变量或函数，以避免名称冲突或访问全局变量。

综上所述，C++的存储方案涉及存储持续性、作用域和链接性等多个方面，它们共同决定了程序中变量的生命周期、可见性和可访问性。理解这些概念对于编写高效、可维护的C++程序至关重要。

8. 自己写 string 类注意事项

在C++岗位面试中，如果面试官要求你讨论自己编写一个string类时需要注意的事项，这实际上是在考察你对C++字符串处理、内存管理、异常安全、性能优化以及标准库std::string实现原理的理解。以下是一些关键注意事项：

1. 内存管理

动态内存分配：string类需要能够动态地增加或减少其内部字符数组的大小。这通常涉及到使用new和delete（或智能指针如std::unique_ptr，但在这里直接管理内存可能更合适以模拟标准string的行为）。
内存复制与移动：提供深拷贝构造函数、拷贝赋值运算符和移动构造函数、移动赋值运算符，确保资源正确管理，避免浅拷贝导致的重复释放或野指针问题。
小字符串优化（SSO）：考虑实现小字符串优化，即对于较短的字符串，直接在string对象内部存储字符，避免小字符串时频繁的内存分配和释放。

2. 性能优化

缓存局部性：尽量保持数据局部性，减少内存访问延迟。
避免不必要的内存重新分配：使用预留空间（reserve）机制，减少因字符串增长而导致的频繁内存分配。
常量时间复杂度操作：确保长度获取（length或size）等操作为常量时间复杂度。

3. 异常安全

异常规范（C++11之前）：虽然C++11及以后废弃了异常规范，但了解如何设计不抛出异常的函数，或在异常发生时能正确释放资源是很重要的。
RAII（Resource Acquisition Is Initialization）：利用RAII原则，确保在构造函数中分配的资源在析构函数中正确释放，即使发生异常也能保证资源不泄露。

4. 线程安全

非线程安全默认：标准库中的std::string不是线程安全的，除非明确说明（如C++17的std::pmr::string）。你的自定义string类也应该遵循这一原则，除非有特别的线程安全需求。
同步机制：如果需要在多线程环境下使用，考虑提供同步机制（如互斥锁）来保护共享数据。

5. 接口设计

与标准库兼容：尽可能模仿std::string的接口，如length(), size(), empty(), append(), substr(), find()等，这有助于用户迁移和代码复用。
异常与错误处理：明确哪些操作会抛出异常，哪些会返回错误码或进行错误处理。

6. 特殊字符处理

空字符串：确保能够正确处理空字符串。
特殊字符：如\0（字符串终结符），在你的string类中如何存储和表示。

7. 测试

单元测试：编写全面的单元测试，覆盖各种边界情况和异常场景。
性能测试：比较你的string类与标准std::string的性能，找出可能的优化点。

总之，编写一个自己的string类是一个复杂而富有挑战性的任务，需要对C++的多个方面有深入的理解。在面试中，展示你对上述问题的思考和理解，将有助于给面试官留下深刻印象。

9. 何时调用拷贝（复制）构造函数

在C++中，拷贝（复制）构造函数是一个特殊的构造函数，它在以下情况下被自动调用：

对象通过另一个同类型的对象初始化时：
当你使用一个已存在的对象来初始化一个新对象时，拷贝构造函数会被调用。这包括在函数参数传递、函数返回值以及对象赋值（使用赋值操作符之前，如果赋值操作导致了一个临时对象的创建和销毁，则可能间接涉及到拷贝构造函数的调用，但直接的赋值操作会调用赋值操作符）等场景中。
```
class MyClass {
public:
    MyClass(const MyClass& other) {
        // 拷贝构造函数的实现
    }
};

MyClass obj1;
MyClass obj2 = obj1; // 拷贝构造函数被调用
```

函数参数传递时：
当对象作为值参数传递给函数时，会调用拷贝构造函数来创建函数内部使用的对象副本。

void func(MyClass obj) {
    // 使用obj，这是传入参数的拷贝
}

MyClass obj;
func(obj); // 拷贝构造函数被调用

函数返回对象时：
当函数返回一个对象（而不是对象的引用或指针）时，会调用拷贝构造函数来构造返回的对象。不过，现代C++编译器经常通过返回值优化（RVO）或命名返回值优化（NRVO）来避免不必要的拷贝构造函数的调用。
```
MyClass func() {
    MyClass localObj;
    // 对localObj进行操作
    return localObj; // 通常情况下，这里会调用拷贝构造函数，但可能由于RVO/NRVO优化而避免
}

MyClass obj = func(); // 原本可能调用拷贝构造函数
```
通过赋值运算符间接涉及：
虽然赋值运算符本身不直接调用拷贝构造函数，但在某些情况下（特别是当赋值操作涉及到临时对象时），拷贝构造函数可能会间接被调用。然而，直接的赋值操作（将一个已存在的对象赋值给另一个同类型的对象）通常是通过赋值运算符（operator=）来处理的。
容器操作：
当对象被添加到需要复制元素的容器中时（如std::vector），容器的实现可能会调用拷贝构造函数来创建元素的副本。
```
std::vector<MyClass> vec;
MyClass obj;
vec.push_back(obj); // 拷贝构造函数被调用以添加obj的副本到vec中
```
动态内存分配：
虽然直接通过new操作符分配内存时不会直接调用拷贝构造函数（除非你在new表达式中显式地创建对象副本），但在处理动态分配的对象时，如果需要将一个动态分配的对象的内容复制到另一个动态分配的对象中，那么程序员需要显式地调用拷贝构造函数（或者更常见的是，使用赋值运算符或容器操作）。

重要的是要注意，现代C++编程中，为了避免不必要的拷贝和性能开销，通常会使用引用（&）和常量引用（const &）作为函数参数，以及移动语义（通过移动构造函数和移动赋值操作符）来处理大型对象或容器，从而减少拷贝构造函数的调用。

10. 何时调用赋值运算符

在C++中，赋值运算符（通常是operator=）在对象被赋予一个新值时被调用。这通常发生在以下几种情况：

显式赋值：
当你直接将一个对象的值赋给另一个同类型的对象时，赋值运算符会被调用。
```
MyClass obj1;
MyClass obj2;
obj1 = obj2; // 调用obj1的赋值运算符，将obj2的值赋给obj1
```
函数返回对象时的赋值：
虽然在现代C++中，编译器通常会通过返回值优化（RVO）或命名返回值优化（NRVO）来避免不必要的赋值操作，但在不支持这些优化的情况下，或者当返回的对象类型不支持移动语义时，函数返回的对象可能会被临时对象接收，然后再通过赋值运算符赋值给另一个对象。
```
MyClass func() {
    MyClass temp;
    // ... 对temp进行操作
    return temp; // 可能通过赋值运算符赋值给接收者
}

MyClass obj = func(); // 在不支持RVO/NRVO的情况下，这里可能调用赋值运算符
```
复合赋值操作：
虽然复合赋值操作符（如+=、-=等）在语义上看起来像是执行了某种操作后再赋值，但它们实际上是通过重载这些操作符来实现的，这些重载的操作符内部可能会调用赋值运算符（具体取决于它们的实现方式）。然而，从严格意义上讲，复合赋值操作并不直接等同于调用赋值运算符operator=。
链表、树等数据结构中的节点赋值：
在处理链表、树等数据结构时，如果你实现了节点的赋值操作，那么当链表的某个节点或树的某个子树被赋予新的值时，节点的赋值运算符也会被调用。

对象数组或容器中的元素赋值：
当你对数组或容器（如std::vector）中的元素进行赋值时，也会调用相应对象的赋值运算符。

std::vector<MyClass> vec;
MyClass obj;
vec.push_back(MyClass()); // 可能调用拷贝构造函数
vec[0] = obj; // 调用vec[0]的赋值运算符，将obj的值赋给vec的第一个元素

类成员对象的赋值：
如果类的成员是另一个类的对象，并且该成员对象被赋予了一个新值，那么该成员对象的赋值运算符也会被调用。
```
class A {
public:
    MyClass member;
    // ...
};

A a1, a2;
a1.member = a2.member; // 调用a1.member的赋值运算符
```

重要的是要注意，赋值运算符应该被设计为能够处理自赋值（即对象被赋予它自己的值）的情况，并且应该保证赋值操作后对象的状态是有效的。此外，为了避免不必要的拷贝和性能开销，现代C++编程中通常会使用移动语义（通过移动构造函数和移动赋值运算符）来优化对象的赋值操作。

11. 赋值运算符和拷贝构造函数在实现上的区别

在C++中，赋值运算符（operator=）和拷贝构造函数在功能上有相似之处，即它们都涉及到对象内容的复制，但它们在使用的上下文和实现方式上有着显著的区别。

拷贝构造函数（Copy Constructor）

定义：拷贝构造函数是一种特殊的构造函数，它用于创建一个新对象，该新对象是已存在对象的副本。其函数签名通常接受一个对同一类类型的常量引用作为参数。
使用场景：
- 当使用另一个同类型的对象来初始化新对象时。
- 当对象作为值参数传递给函数时（尽管现代编译器可能会通过RVO/NRVO优化来避免额外的拷贝）。
- 当函数返回对象时（同样，现代编译器可能会优化）。
- 当对象被添加到需要复制元素的容器中时。
实现要点：
- 必须显式定义（除非编译器生成的默认拷贝构造函数足够用）。
- 需要处理自赋值的情况（即源对象和目标对象是同一个对象）。
- 负责分配新资源（如动态内存）给新对象。
- 通常需要调用基类的拷贝构造函数（如果有的话）。

赋值运算符（Assignment Operator）

定义：赋值运算符用于将一个对象的值复制给另一个已存在的同类型对象。
使用场景：
- 当一个已存在的对象被赋予一个新值时（这个新值可以是另一个同类型对象的值）。
实现要点：
- 必须显式定义（如果类包含动态分配的内存、指向其他对象的指针等）。
- 需要处理自赋值的情况（即源对象和目标对象是同一个对象）。
- 首先释放目标对象当前持有的资源（如果有的话），然后再从源对象复制数据。
- 赋值运算符应该返回一个对目标对象的引用，以支持链式赋值。
- 通常不需要调用基类的赋值运算符（因为对象已经存在，只是其内容被替换）。

实现上的区别

目的不同：拷贝构造函数用于初始化新对象，而赋值运算符用于修改已存在对象的值。
参数不同：拷贝构造函数的参数是对另一个对象的常量引用，而赋值运算符的隐式第一个参数（即左侧对象）是对自身的引用（通常不显式写出）。
返回值不同：拷贝构造函数没有返回值（构造函数都不应该有返回值），而赋值运算符通常返回对自身的引用。
资源处理：拷贝构造函数需要为新对象分配资源，而赋值运算符需要先释放旧资源再分配新资源（如果对象包含动态分配的资源）。
自赋值处理：两者都需要处理自赋值的情况，但处理方式略有不同。拷贝构造函数可以通过参数比较来避免自赋值，而赋值运算符则需要在开始复制之前检查自赋值情况。然而，对于现代C++，自赋值检查通常不是必需的，因为编译器和库的实现已经足够智能来处理这种情况，但在某些情况下（如自定义内存管理）仍然需要注意。

12. 重载运算符最好声明为友元

在C++中，关于重载运算符是否应该声明为友元（friend）的问题，并没有一个绝对的答案，因为它取决于具体的情况和重载运算符的用途。然而，确实有一些情况下将重载运算符声明为友元是更合适或更常见的做法。下面我将详细解释这一点，并给出理由。

为什么重载运算符最好声明为友元？

访问私有和保护成员：
当你需要在一个类的外部重载一个运算符，并且这个运算符的实现需要访问类的私有（private）或保护（protected）成员时，将运算符重载函数声明为友元是必要的。这是因为非友元函数无法直接访问类的私有和保护成员。
语义清晰：
在某些情况下，将运算符重载为友元可以更清晰地表达该运算符的语义。特别是当运算符的左侧或右侧操作数需要是特定类型的对象，并且该运算符的实现需要访问这些对象的内部状态时，声明为友元可以明确这一点。
避免不必要的对象复制：
当运算符重载函数不是成员函数时（即，不是通过类的成员函数来重载），它可以接受两个参数（左侧和右侧操作数），而不是一个（对于成员函数，左侧操作数是隐式的*this）。这允许在函数内部直接对参数进行操作，而不需要创建额外的对象副本。虽然这不一定总是需要声明为友元（因为可以通过传递引用或指针来避免复制），但友元函数通常更自然地适应这种用法。
对称性和灵活性：
对于某些二元运算符（如==、!=、+、-等），将它们声明为友元可以使得左侧和右侧操作数都可以是对象，从而提高了运算符的对称性和灵活性。如果运算符重载函数是成员函数，那么左侧操作数必须是类的实例，这可能会限制运算符的使用。

注意事项

封装性：虽然将运算符重载为友元可以提高灵活性和效率，但它也牺牲了类的封装性。因此，在决定是否将运算符重载为友元时，需要权衡这些因素。
选择适当的访问级别：如果运算符重载函数不需要访问类的私有或保护成员，那么将其声明为非成员函数（但不一定是友元）可能是一个更好的选择。
考虑成员函数重载：在某些情况下，将运算符重载为成员函数（特别是当左侧操作数必须是类的实例时）可能更合适。

综上所述，将重载运算符声明为友元并不是一个绝对的选择，而是取决于具体的需求和上下文。然而，在需要访问私有成员或提高运算符的对称性和灵活性时，将运算符重载为友元通常是一个更好的选择。

13. 在重写 string 类时使用中括号访问字符时注意

在C++中，如果你打算重写或模拟一个类似于std::string的类，并在其中使用中括号[]来访问字符时，你需要注意几个关键点以确保你的实现既安全又高效。以下是几个主要的注意事项：

1. 运算符重载

你需要重载operator[]以支持使用中括号访问字符串中的字符。这个运算符应该返回一个对字符串内部字符的引用（char&），以允许通过返回的引用修改字符。同时，你可能还需要提供一个常量版本的operator[]（返回const char&），以便在字符串对象为常量时仍然可以安全地访问其字符。

2. 边界检查

在使用operator[]时，重要的是要执行边界检查，以防止访问超出字符串当前长度的位置。然而，标准库中的std::string::operator[]并不进行边界检查以提高性能。如果你的类是为了性能敏感的应用而设计的，并且你确信用户会正确使用它，那么你也可以选择不进行边界检查。但是，在许多情况下，提供一个安全的版本（可能通过另一个函数或方法）会更好，尤其是在开发库或API供其他开发者使用时。

3. 线程安全

如果你的类设计用于多线程环境，并且operator[]可能会在多线程中被同时访问，那么你需要考虑线程安全的问题。确保在多线程环境中对字符串的访问是安全的，可能需要使用互斥锁（mutexes）或其他同步机制。

4. 返回值类型

如前所述，operator[]应该返回一个对内部字符的引用。但是，如果你不希望允许通过该引用修改字符串（比如，你的类设计为不可变字符串），你可以返回const char&。此外，对于非常量版本，返回char&允许用户修改返回的字符，但这也可能带来风险，因为用户可能会通过返回的引用破坏字符串的内部状态（比如，写入一个空字符\0，从而截断字符串）。

5. 字符串修改后的处理

如果你的类支持通过operator[]修改字符串中的字符，并且你的类内部维护了字符串的长度或其他相关信息（如哈希值、缓存等），那么每次通过operator[]修改字符后，你可能需要更新这些信息。

6. 异常安全性

考虑你的类在抛出异常时的行为。如果你的类在访问或修改字符串时可能抛出异常（比如，由于内存不足），确保你的类在异常发生时能够保持一致的状态。

示例代码片段

class MyString {
private:
    char* data;
    size_t length;

public:
    // 构造函数、析构函数、拷贝构造函数、赋值运算符等...

    char& operator[](size_t index) {
        // 这里应该添加边界检查，但为了简洁而省略
        return data[index];
    }

    const char& operator[](size_t index) const {
        // 边界检查（可选，取决于设计决策）
        return data[index];
    }

    // 其他成员函数...
};

请注意，上面的代码示例没有包含边界检查，这是为了简洁。在实际应用中，你应该始终考虑添加适当的边界检查或其他安全措施。

14. 静态成员函数

在C++中，静态成员函数是类中的一个特殊成员函数，它与类的任何特定对象实例都不相关联。这意味着静态成员函数不能访问类的非静态成员变量（除非通过类的实例或对象），也不能被类的非静态成员函数中的this指针所访问。静态成员函数在类的所有对象之间共享，并且在没有创建类的任何对象的情况下也可以被调用。

静态成员函数的定义

静态成员函数通过在函数声明前加上static关键字来定义。例如：

class MyClass {
public:
    static void staticFunction() {
        // 静态成员函数体
    }
};

静态成员函数的特性

访问方式：
- 可以通过类名加作用域解析运算符（::）来直接调用静态成员函数，例如：MyClass::staticFunction();
- 也可以通过类的实例（对象）来调用静态成员函数，但这通常不推荐，因为它可能误导读者以为该函数与特定对象相关联，例如：MyClass obj; obj.staticFunction();
访问限制：
- 静态成员函数可以访问类的静态成员变量和其他静态成员函数。
- 它不能直接访问类的非静态成员变量和非静态成员函数，因为非静态成员是与特定对象实例相关联的。
内存分配：
- 静态成员函数在程序运行时只存在一份副本，并且它在程序的整个生命周期内都存在。
- 它不占用对象的内存空间，因为它不是对象的一部分。
用途：
- 静态成员函数常用于实现一些与类相关的工具性功能，这些功能不依赖于类的任何特定对象实例。
- 它们也可以用于访问和修改静态成员变量。
线程安全：
- 如果静态成员函数访问或修改共享资源（如静态成员变量），则需要注意线程安全问题。
- 在多线程环境下，可能需要使用同步机制（如互斥锁）来保护共享资源。

示例

下面是一个包含静态成员函数的类的示例：

#include <iostream>

class MyClass {
public:
    static int staticVar; // 静态成员变量

    // 静态成员函数
    static void printStaticVar() {
        std::cout << "Static variable value: " << staticVar << std::endl;
    }

    // 非静态成员函数
    void modifyStaticVar(int newValue) {
        staticVar = newValue; // 可以通过非静态成员函数修改静态成员变量
    }
};

// 静态成员变量需要在类外部进行初始化
int MyClass::staticVar = 0;

int main() {
    MyClass::printStaticVar(); // 直接通过类名调用静态成员函数

    MyClass obj;
    obj.modifyStaticVar(10); // 通过对象调用非静态成员函数来修改静态成员变量
    MyClass::printStaticVar(); // 再次打印静态成员变量的值

    return 0;
}

在这个例子中，staticVar是一个静态成员变量，它在所有MyClass对象之间共享。printStaticVar是一个静态成员函数，用于打印staticVar的值。modifyStaticVar是一个非静态成员函数，它接受一个整数参数并将其赋值给staticVar，展示了即使通过非静态成员函数也可以访问和修改静态成员变量。

15. 实现 has-a 关系的两种方法

在C++中，has-a（也称为“有一个”或组合）关系指的是一个类包含另一个类的对象作为其成员变量。这种关系通常用于表示一个类是由其他类的对象组合而成的。实现has-a关系主要有两种直接的方法，这些方法涉及在类中嵌入另一个类的对象作为成员：

1. 直接嵌入法

直接嵌入法是最直接的实现has-a关系的方法。在这种方法中，你直接在包含类（也称为组合类）中声明另一个类的对象作为成员变量。这种方法简单直接，但要求被嵌入的对象类是可访问的（即，其定义对包含类是可见的）。

示例代码：

class Engine {
public:
    void start() {
        // 启动引擎的逻辑
        std::cout << "Engine started." << std::endl;
    }
};

class Car {
private:
    Engine engine; // Car有一个Engine

public:
    void startEngine() {
        engine.start(); // 调用Engine的start方法
    }
};

int main() {
    Car myCar;
    myCar.startEngine(); // 输出: Engine started.
    return 0;
}

在这个例子中，Car类通过包含一个Engine类的对象来实现has-a关系。

2. 指针或引用嵌入法

在某些情况下，你可能想要在使用包含类时更灵活地管理被嵌入对象的生命周期，或者当你想要实现多态时（即，当包含类需要根据运行时信息决定包含哪个特定类型的对象时），你可以使用指针或引用（通常是智能指针，如std::unique_ptr或std::shared_ptr，以避免裸指针带来的管理问题）来嵌入对象。

示例代码（使用智能指针）：

#include <memory>

class Engine {
public:
    void start() {
        // 启动引擎的逻辑
        std::cout << "Engine started." << std::endl;
    }
};

class Car {
private:
    std::unique_ptr<Engine> engine; // Car通过指针拥有一个Engine

public:
    Car() : engine(std::make_unique<Engine>()) {} // 在构造函数中初始化engine

    void startEngine() {
        if (engine) {
            engine->start(); // 调用Engine的start方法
        }
    }
};

int main() {
    Car myCar;
    myCar.startEngine(); // 输出: Engine started.
    return 0;
}

在这个例子中，Car类通过包含一个指向Engine类对象的std::unique_ptr来实现has-a关系。这种方法提供了对Engine对象生命周期的更多控制，并允许在需要时使用多态（如果Engine是一个抽象基类的话）。

总结

实现has-a关系主要有两种方法：直接嵌入法和指针或引用嵌入法。选择哪种方法取决于你的具体需求，包括对象生命周期的管理、是否需要多态以及代码的可读性和可维护性等因素。在大多数情况下，如果不需要管理对象的生命周期或实现多态，直接嵌入法是一个简单且直接的选择。如果需要更灵活的生命周期管理或实现多态，则应该考虑使用指针或引用嵌入法。

16. 关于保护继承：保护继承是私有继承的变体，保护继承在列出基类时使用关键字 `protected`。

在C++中，保护继承（Protected Inheritance）是类继承机制中的一种特殊形式，它位于公有继承（Public Inheritance）和私有继承（Private Inheritance）之间，提供了一种介于两者之间的访问控制。保护继承通过使用protected关键字在派生类声明中指定基类来实现。

保护继承的特点

基类成员的访问权限：
- 在保护继承中，基类的公有成员和保护成员在派生类中变为保护成员（protected）。这意味着这些成员在派生类内部可以访问，但无法通过派生类的对象直接访问，同时也不能被派生类的子类所访问（除非它们再次被声明为公有或保护）。
- 基类的私有成员在派生类中仍然保持私有，无法被派生类直接访问。
用途：
- 保护继承通常用于实现一个接口（通过纯虚函数）或基类的一部分功能，同时希望这些功能或接口在派生类中是受保护的，而不是完全公有或完全私有的。这有助于隐藏实现细节，同时允许派生类内部扩展或修改这些功能。
与私有继承的区别：
- 私有继承中，基类的公有成员和保护成员在派生类中变为私有成员。这意味着它们既不能在派生类外部访问，也不能在派生类内部被派生类的成员函数之外的代码访问（比如，派生类的其他成员函数或友元函数可以访问，但派生类的对象不能）。
- 保护继承提供了更灵活的访问控制，允许派生类内部（包括派生类的成员函数和友元函数）访问这些成员，但不允许派生类的对象或派生类的子类直接访问。
使用场景：
- 当希望基类的某些成员在派生类内部是可用的，但又不希望这些成员暴露给派生类的用户或派生类的子类时，可以使用保护继承。
- 保护继承在实现一些特定的设计模式时非常有用，比如模板方法模式（Template Method Pattern），其中基类定义了一个算法的框架，并允许派生类通过重写某些保护成员来定制算法的一部分。

示例

class Base {
public:
    void publicFunc() {}
protected:
    void protectedFunc() {}
private:
    void privateFunc() {}
};

class Derived : protected Base {
public:
    void accessBase() {
        publicFunc();  // 可以访问，变为保护成员
        protectedFunc(); // 可以访问，本身就是保护成员
        // privateFunc(); // 错误，无法访问，保持私有
    }
};

int main() {
    Derived d;
    // d.publicFunc(); // 错误，publicFunc() 在 Derived 中是保护的
    // d.protectedFunc(); // 错误，同上
    return 0;
}

在这个例子中，Base类有公有、保护和私有成员函数。当Derived类通过保护继承继承Base时，Base的公有和保护成员函数在Derived中变为保护成员，因此它们只能在Derived内部被访问，而不能通过Derived的对象或派生自Derived的类的对象直接访问。

17. 智能指针相关：请参考：C++智能指针简单剖析，推荐必看。

在C++岗位面试中，智能指针是一个非常重要且常被提及的话题，因为它们在现代C++编程中扮演着至关重要的角色，特别是在管理动态分配的内存方面。智能指针通过自动管理资源的生命周期（主要是内存），帮助程序员避免内存泄漏和其他资源管理错误。下面是对C++中几种常见智能指针的深入剖析：

1. `std::unique_ptr`

所有权：std::unique_ptr表示对某个对象的独占所有权。同一时间内，只能有一个std::unique_ptr指向给定对象（通过复制或赋值会转移所有权）。
特性：
- 不可复制（但可移动），保证了资源的独占性。
- 自动释放所管理的资源（通常是内存）。
- 提供了自定义删除器的功能，允许在释放资源时执行特定操作。
用途：适用于需要独占资源所有权的场景，如工厂函数返回动态分配的对象。

2. `std::shared_ptr`

共享所有权：std::shared_ptr允许多个智能指针共享对同一个对象的所有权。当最后一个shared_ptr被销毁或重置时，所管理的对象才会被删除。
特性：
- 可复制和可赋值，每次复制或赋值都会增加内部计数器的值。
- 当内部计数器变为0时，自动释放资源。
- 提供了弱引用（std::weak_ptr）来避免循环引用问题。
用途：适用于需要多个所有者共享资源的场景，如多个组件需要访问同一个数据结构的实例。

3. `std::weak_ptr`

非拥有性智能指针：std::weak_ptr是对std::shared_ptr所管理对象的一种弱引用，它不会增加对象的共享所有权计数。
特性：
- 可以用来解决shared_ptr之间的循环引用问题。
- 不能直接访问对象，必须转换为shared_ptr后才能访问（如果对象仍然存在）。
- 提供了expired()和lock()成员函数来检查对象是否已被销毁以及尝试获取shared_ptr。
用途：主要用于解决shared_ptr之间的循环引用问题，以及在不拥有对象所有权但需要访问对象时的情况。

4. `std::auto_ptr`（已弃用）

注意：std::auto_ptr在C++11及以后的版本中已被弃用，因为它存在所有权转移时的潜在问题，特别是在容器和函数返回时。
特性：
- 类似于unique_ptr，但实现上不够安全。
- 复制时会转移所有权，而不是像unique_ptr那样禁止复制。
用途：不推荐使用，应使用std::unique_ptr作为替代。

总结

在C++中，智能指针是管理动态分配内存和其他资源的重要工具。它们通过自动管理资源的生命周期，减少了内存泄漏和其他资源管理错误的风险。在面试中，了解并掌握std::unique_ptr、std::shared_ptr和std::weak_ptr的使用场景和特性是非常重要的。同时，也应该了解std::auto_ptr的历史和为什么它不再被推荐使用。

18. C++中的容器种类

在C++标准模板库（STL）中，各种容器的具体实现细节可能会因编译器和STL实现的不同而有所差异，但以下是一些通用的实现细节概述：

顺序容器（Sequence Containers）

vector
- 内部实现：通常使用动态分配的连续内存数组来存储元素。当需要更多空间时，vector会分配一个新的、更大的数组，并将旧数组中的元素复制到新数组中（这可能导致迭代器、指针和引用的失效，除非使用特定的成员函数如std::vector::insert的某些重载版本）。
- 性能：随机访问非常快（O(1)时间复杂度），但在中间或开始位置插入或删除元素可能较慢（O(n)时间复杂度），因为需要移动其他元素。
deque
- 内部实现：由多个连续的、固定大小的数组（称为“块”或“段”）组成，这些数组通过指针相互连接。deque支持在两端快速插入和删除元素，因为它只需要调整指针和分配/释放一个块。
- 性能：在两端插入和删除元素是高效的（O(1)时间复杂度），但在中间位置插入或删除元素可能较慢（O(n)时间复杂度），因为可能需要移动多个块中的元素。
list
- 内部实现：使用双向链表，其中每个元素都是一个节点，包含数据、指向前一个节点的指针和指向后一个节点的指针。
- 性能：在任何位置插入和删除元素都是高效的（O(1)时间复杂度），但不支持随机访问（访问第n个元素需要O(n)时间复杂度）。
forward_list（C++11）
- 内部实现：使用单向链表，其中每个元素都是一个节点，包含数据和指向后一个节点的指针。
- 性能：与list类似，但在某些情况下由于减少了指针数量（没有指向前一个节点的指针），可能提供更好的性能。不支持反向遍历。
array（C++11）
- 内部实现：与内置的数组非常相似，但提供了更多的成员函数和类型安全性。array的大小在编译时是固定的，并且存储在连续的内存中。
- 性能：与内置数组相同，支持随机访问（O(1)时间复杂度）。

关联容器（Associative Containers）

set/multiset
- 内部实现：通常使用红黑树（或其他平衡二叉搜索树）来实现，以确保元素按排序顺序存储，并且插入、删除和查找操作具有对数时间复杂度。
- 性能：插入、删除和查找操作的时间复杂度为O(log n)。
map/multimap
- 内部实现：与set/multiset类似，但每个节点都存储一个键值对。键用于排序和快速查找，而值是与键相关联的数据。
- 性能：与set/multiset相同，插入、删除和基于键的查找操作的时间复杂度为O(log n)。
unordered_set/unordered_multiset/unordered_map/unordered_multimap（C++11）
- 内部实现：基于哈希表实现，使用桶（bucket）数组来存储元素。每个桶可以存储一个或多个具有相同哈希值的元素（通过链表或红黑树等数据结构解决哈希冲突）。
- 性能：平均情况下，插入、删除和查找操作的时间复杂度为O(1)，但在最坏情况下（所有元素都映射到同一个桶时）可能退化到O(n)。

容器适配器（Container Adaptors）

stack、queue、priority_queue
- 这些适配器不是独立的容器类型，而是对现有容器（如deque、list或vector）的封装，提供了特定的接口（如栈、队列或优先队列）。
- 它们的实现细节取决于它们所使用的底层容器。例如，std::stack和std::queue通常使用std::deque作为底层容器，而std::priority_queue则通常使用std::vector作为底层容器，并通过堆算法来管理元素。