✍️ 八股文 @ C++

✍️ C++ 11 新特性大全：https://zhuanlan.zhihu.com/p/139515439

🔥 C++ 八股文 PDF：

• C++ 八股文｜GitHub
• C++ 八股文｜牛客
• C++ 八股文｜代码随想录
• C++ 11 新特性大全

1. gcc 编译流程

参考链接：https://developer.aliyun.com/article/1650283

一段高级语言代码经过四个阶段的处理形成可执行的目标二进制代码。

预处理器→编译器→汇编器→链接器：最难理解的是编译与汇编的区别。

这里采用《深入理解计算机系统》的说法。

预处理阶段：预处理阶段主要处理 #include 指令、宏替换、条件编译等，生成 .i 文件。

• 展开头文件：将 #include 指定的文件插入到源代码中
• 宏替换：替换所有 #define 定义的宏
• 条件编译：根据预处理指令（如 #ifdef）选择性地编译代码
• 去除注释：删除源代码中的注释内容

写好的高级语言的程序文本比如 hello.c，预处理器根据 # 开头的命令，修改原始的程序，如
#include<stdio.h> 将把系统中的头文件插入到程序文本中，通常是以 .i 结尾的文件。

1

gcc -E source.c -o source.i

编译阶段：编译阶段对源代码进行语法语义检查，生成汇编代码，产生 .s 文件。

编译器将 hello.i 文件翻译成汇编语言程序 hello.s，不同的高级语言翻译的汇编语言相同。

1

gcc -S source.i -o source.s

汇编阶段：汇编阶段将汇编代码翻译成机器码（机器可识别的目标代码），生成 .o 目标文件。

汇编器将汇编代码 hello.s 翻译成机器语言指令。把这些指令打包成可重定位目标程序，即 .o 文件。hello.o 是一个二进制文件，它的字节码是机器语言指令，不再是字符，前面两个阶段都还有字符。

1

gcc -c source.s -o source.o

链接阶段： 链接阶段将多个目标文件和库文件链接在一起，生成最终的可执行文件，链接过程还可能会调用外部的动态或静态库。

比如 hello 程序调用 printf 程序，它是每个 C 编译器都会提供的标准库 C 的函数。这个函数存在于一个名叫 printf.o 的单独编译好的目标文件中，这个文件将以某种方式合并到 hello.o 中。链接器就负责这种合并，得到的是可执行目标文件。

1

gcc source.o -o executable

关于编译优化：

GCC 和 G++ 提供了多种优化选项，开发者可以根据项目需求选择合适的优化级别

2. C 和 C++ 区别（函数/类/struct/class）

首先，C 和 C++ 在基本语句上没有过大的区别。

C++ 有新增的语法和关键字：

• 语法的区别有头文件的不同和命名空间的不同，C++ 允许我们自己定义自己的空间，C 中不可以。
• 关键字方面比如 C++ 与 C 动态管理内存的方式不同，C++ 中在 malloc 和 free 的基础上增加了 new和 delete，而且 C++ 中在指针的基础上增加了引用的概念，关键字例如 C++中还增加了 auto，explicit 体现显示转换和隐式转换上的概念要求，还有 dynamic_cast 增加类型安全方面的内容。

函数方面 C++ 中有重载和虚函数的概念：

• C++ 支持函数重载而 C 不支持，是因为 C++ 函数的名字修饰与 C 不同，C++ 函数名字的修饰会将参数加在后面，例如，int func(int, double) 经过名字修饰之后会变成 _func_int_double，而 C 中则会变成_func，所以 C++ 中会支持不同参数调用不同函数。
• C++ 还有虚函数概念，用以实现多态。

类方面，C 的 struct 和 C++ 的类也有很大不同：

• C++ 中的 struct 不仅可以有成员变量还可以成员函数，而且对于 struct 增加了权限访问的概念，struct 的默认成员访问权限和默认继承权限都是 public，C++ 中除了 struct 还有 class 表示类，struct 和 class 还有一点不同在于 class 的默认成员访问权限和默认继承权限都是 private。

C++ 中增加了模板来重用代码，提供了更加强大的 STL 标准库。

最后补充一点就是 C 是一种结构化的语言，重点在于算法和数据结构。C 程序的设计首先考虑的是如何通过一个代码，一个过程对输入进行运算处理输出。而 C++ 首先考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题领域，这样就能通过获取对象的状态信息得到输出。

C 的 struct 更适合看成是一个数据结构的实现体，而 C++ 的 class 更适合看成是一个对象的实现体。

3. C++ 和 Java 区别（语言特性、垃圾回收、应用场景等）

C++ 和 Java 都有染指

指针：Java 让程序员没法找到指针来直接访问内存，没有指针的概念，并且有自动内存管理功能，从而有效地防止了 C++ 语言中的指针操作失误的影响。但并非 Java 中没有指针，Java 虚拟机内部中还是使用了指针，保证了 Java 程序的安全性。

多重继承：C++ 支持多重继承但 Java 不支持，但支持一个类继承多个接口，实现 C++ 中多重继承的功能，又避免了 C++ 的多重继承带来的不便。

数据类型和类：Java 是完全面向对象的语言，所有的函数和变量必须是类的一部分。除了基本数据类型之外，其余的都作为类对象，对象将数据和方法结合起来，把他们封装在类中，这样每个对象都可以实现自己的特点和行为。Java 中取消了 C++ 中的 struct 和 union。

自动内存管理：Java 程序中所有对象都是用 new 操作符建立在内存堆栈上，Java 自动进行无用内存回收操作，不需要程序员进行手动删除。而 C++ 中必须由程序员释放内存资源，增加了程序设计者的负担。Java 中当一个对象不再被使用时，无用内存回收器将给他们加上标签，Java 里无用内存回收程序是以线程方式在后台运行，利用空闲时间工作来删除。

Java 不支持操作符重载，操作符重载是 C++ 的突出特性。

Java 不支持预处理功能，C++ 在编译过程中都有一个预编译阶段，Java 没有预处理器，但它提供了 import，与 C++ 预处理器具有类似功能。

类型转换：C++ 中有数据类型隐含转换的机制，Java 中需要显式强制类型转换。

字符串：C++ 中字符串是以 NULL 终止符代表字符串的结束，而 Java 的字符串是用类对象（string 和 stringBuffer）来实现的。

Java 中不提供 goto 语句，虽然指定 goto 为关键字，但不支持使用它。

Java 的异常机制用于捕获例外事件，增强系统容错能力。

4. C++ 中 const 和 static 关键字的作用

在 C++ 中，const 关键字用于定义常量，表示一个值在初始化后不可被修改，它可以修饰变量、函数参数、成员变量以及成员函数（表示该函数不会修改类的成员状态）。

而 static 关键字用于控制变量或函数的生命周期与作用域，修饰局部变量时使其在程序整个生命周期内存在且只初始化一次，修饰全局变量或函数时将其作用域限制在当前文件内，修饰类的成员时则实现共享（成员变量被所有对象共享，成员函数可不依赖对象直接调用）。

两者分别从不可变性与持久性/共享性两个维度提供不同的语义约束。

static

static 作用：控制变量的存储方式和可见性。

1️⃣ 局部静态变量

一般情况下，对于局部变量在程序中是存放在栈区的，并且局部的生命周期在包含语句块执行结束时便也结束了。但是如果用 static 关键字修饰，该变量会存放在静态数据区，作用域仍为局部作用域，但是当局部静态变量离开作用域后，并没有销毁，而是仍然驻留在内存当中，只不过我们不能再对它进行访问，直到该函数再次被调用，并且值不变。

2️⃣ 全局静态变量

即 static 限制了全局变量的作用域（本文件）

对于一个全局变量，它既可以在本文件中被访问到，也可以在同一个工程其它源文件被访问（添加 extern 进行声明即可）；而使用 static 对全局变量进行修饰改变了其作用域范围，由原来整个工程可见变成了本文件可见，同时也是存放在静态数据区，在整个程序运行期间一直存在。

3️⃣ 静态函数

函数的定义和声明在默认情况下都是 extern 的，但静态函数只是在声明它的文件当中可见（与全局静态变量类似）

4️⃣ 类的静态成员/函数

在类中，静态成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不会破坏隐藏的原则，即保证了安全性。因此静态成员/函数是类中所有对象共享的成员/函数，而不是某个对象的成员/函数。

• 在模块内的 static 全局变量可以被模块内所有函数访问，但不能被模块外其它函数访问；
• 在类中的 static 成员变量属于整个类所拥有，对类的所有对象只有一份拷⻉；
• 在类中的 static 成员函数属于整个类所拥有，这个函数不接收 this 指针，因而只能访问类的 static 成员变量；
• static 类对象必须要在类外进行初始化，static 修饰的变量先于对象存在，所以 static 修饰的变量要在类外初始化；
• 由于 static 修饰的类成员属于类，不属于对象，因此 static 类成员函数是没有 this 指针，this 指针是指向本对象的指针，正因为没有 this 指针，所以 static 类成员函数不能访问非 static 的类成员，只能访问 static 修饰的类成员；
• static 成员函数不能被 virtual 修饰，static 成员不属于任何对象或实例，所以加上 virtual 没有任何实际意义；静态成员函数没有 this 指针，虚函数的实现是为每一个对象分配一个 vptr 指针，而 vptr 是通过 this 指针调用的，所以不能为 virtual；虚函数的调用关系，this->vptr->ctable->virtual function。

const

1️⃣ const 修饰基本数据类型

修饰符 const 可以用在类型说明符前，也可以在类型说明符后，结果都是一样的，使用这些常量时，只要不改变这些常量的值即可。

2️⃣ const 修饰指针变量和引用变量

引用同理

如果 const 位于 const T* 左侧，则 const 就是用来修饰指针所指向的变量，即指针指向为常量。

如果 const 位于 T* const 右侧，则 const 就是修饰指针本身，即指针本身是常量。

3️⃣ const 应用到函数中

1. 作为参数的 const 修饰符：调用函数时，用相应的变量初始化 const 常量，则在函数体中，按照 const 所修饰的部分进行常量化，保护了原对象的属性。
2. 作为函数返回值的 const 修饰符：声明了返回值后，它意味着这个返回值是一个常量，不能被修改。

注意：参数 const 通常用于参数为指针或引用的情况。

4️⃣ const 在类中的用法

1. const 成员变量：只在某个对象生命周期内是常量，而对于整个类而言是可以改变的（因为类可以创建多个对象，不同对象其 const 数据成员值可以不同，所以不能在类的声明中初始化 const 数据成员，因为类对象在没有创建的时候，编译器不知道 const 数据成员的值是什么，const 数据成员的初始化只能在类的构造函数初始化列表中进行）
2. const 成员函数：防止成员函数修改对象的内容，要注意，const 和 static 对于成员函数来说是不能同时使用的，因为 static 关键字修饰静态成员函数不含有 this 指针，即不能实例化，const 成员函数又必须具体到某一个函数。

补充：

• const 成员函数如果实在想修改某个变量，可以使用 mutable 进行修饰；
• 成员变量中如果想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现或者 static const。

5️⃣ const 修饰类对象、定义常量函数

const 常量对象只能调用 const 常量函数，非 const 成员函数都不能调用。

原因：对象调用成员函数时，在形参列表的最前面加一个形参 this，但这是隐式的。this 指针是默认指向调用函数的当前对象的，所以很自然，this 是一个常量指针 test * const，因为不可以修改 this 指针代表的地址。但当成员函数的参数列表后加了 const 关键字（void print() const;），此成员函数为常量成员函数，此时它的隐式 this 形参为 const test * const，表示指向常量对象的常量指针，即不可以通过 this 指针来改变指向对象的值。

非常量对象可以调用类中的 const 成员函数，也可以调用非 const 成员函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <iostream>

class Test {
public:
    Test(int val) : value(val) {}

    // 常量成员函数
    void print() const {
        std::cout << "Value: " << value << std::endl;
    }

    // 非常量成员函数
    void setValue(int val) {
        value = val;
    }

private:
    int value;
};

int main() {
    const Test obj(10);
    obj.print(); // OK，调用常量成员函数
    // obj.setValue(20); // 错误，`const`对象不能调用非常量成员函数
    return 0;
}

⚠️ 注意区别 int print() const; 和 const int print();：

• 前者为常量成员函数，const 位于函数声明的末尾，只能由 const 常量对象来调用该 const 常量函数。
• 后者为普通成员函数，但是返回值为 const int（注意不能用 const 修饰 void，即 const void print() 会编译错误，所以这里用了 int）

5. 说一说 C++ 中四种 cast 转换

C++ 中四种类型转换是：static_cast、dynamic_cast、const_cast、reinterpret_cast

const_cast

用于将 const 变量转为非 const 变量：常量指针转换为⾮常量指针，并且仍然指向原来的对象；常量引⽤被转换为⾮常量引⽤，并且仍然指向原来的对象。const_cast 去掉类型的 const 或 volatile 属性。

static_cast

用于各种隐式转换，但是没有运行时类型检查来保证转换的安全性。

比如非 const 转 const，void* 转指针等，static_cast 还可以用于多态向上转换（如 Derived 转 Base，即子类转基类）

• 进行向上转换（把派生类指针或引用转换为基类）是安全的
• 进行向下转换（把基类指针或引用转换为派生类），由于没有运行时类型检查，所以是不安全的

1
2
3
4
5
6
7
8

// Base 是 Derived 的基类/父类
int main() {
    Derived* d;
    Base* base = static_cast<Base*>(d);    // 向上类型转换
    base->show();
    
    return 0;
}

dynamic_cast

在进行向下转换时，dynamic_cast 具有类型检查（信息在虚函数中）的功能，比 static_cast 更安全。

只能用于含有虚函数的类，用于类层次间的向上和向下转换（基类转子类），只能转指针或引用，向下转换时：

• 对于指针，转换失败则返回 nullptr
• 对于引用，转换失败则抛异常

1
2
3
4
5
6
7
8
9
10
11
12

int main() {
    Base* base = new Derived; // 不使用 static_cast 也可以隐式向上转换
    Derived* derive = dynamic_cast<Derived*>(base);    // 向下类型转换，使用 dynamic_cast
    if (derive) {
        derive->show();
    } else {
        std::cout << "Conversion failed!" << std::endl;
    }

    delete base;
    return 0;
}

reinterpret_cast

几乎什么都可以转，比如将 int 转指针，可能会出问题，尽量少用。

WARNING：reinterpret_cast 本质上依赖于机器，要想安全地使用 reinterpret_cast 必须对涉及的类型和编译器实现转换的过程都非常了解。

为什么不使用 C 的强制转换？

C 的强制转换表面上看起来功能强大什么都能转，但是转化不够明确，不能进行错误检查，容易出错。

static_cast 与 dynamic_cast 之间的区别？

dynamic_cast 和 static_cast 的主要区别在于类型检查的时间点和安全性：

• 类型检查时间点：static_cast在编译时进行类型检查，而dynamic_cast在运行时进行类型检查。
• 安全性：static_cast不执行运行时类型检查，因此如果在类层次结构中进行不安全的向下转换，可能导致未定义行为。相反，dynamic_cast 会在运行时检查转换的安全性，如果转换不安全，则返回nullptr或抛出异常，提供更高的安全性。

6. C/C++ 的四大内存分区和常量的存储位置

四大内存分区：栈、堆、静态存储区（全局变量 + 静态变量 + 常量）和代码区。

1️⃣ 栈区

由系统进行内存的管理。主要存放函数的参数以及局部变量。在函数完成执行，系统自动释放栈区内存，不需要用户管理，整个程序的栈区大小可以在编译器中由用户自行设定，VS 中默认的栈区大小为 1M，可以通过 VS 手动更改栈的大小。64 bits 的 Linux 默认栈大小为 10MB，可通过 ulimit -s 临时修改，可通过 ulimit -a 查看。

2️⃣ 堆区

由程序员手动申请，手动释放，若不手动释放，程序结束后由系统回收，生命周期是整个程序运行期间。使用 malloc 或者 new 进行堆的申请，堆的总大小为机器的虚拟内存的大小。

说明：new 操作符本质上是使用了 malloc 进行内存的申请，new 和 malloc 的区别如下：

1. malloc 是 C 语言中的函数，而 new 是 C++ 中的操作符。
2. malloc 申请之后返回的类型是 void*，而 new 返回的指针带有类型。
3. malloc 只负责内存的分配而不会调用类的构造函数，而 new 不仅会分配内存，而且会自动调用类的构造函数。

堆和栈的区别

申请方式不同：

• 栈是系统自动分配
• 堆是自己申请和释放的

申请大小限制不同：

• 栈空间默认 10 MB；栈顶和栈底是之前预设好的，栈是向栈底扩展，大小固定，可以通过 ulimit -a 查看，由 ulimit -s 修改
• 堆区一般是 1G~4G；堆向高地址扩展，是不连续的内存区域，大小可以灵活调整

申请效率不同：

• 栈由系统分配，速度快，不会有碎片
• 堆由程序员分配，速度慢，且会有碎片

栈快还是堆快？

毫无疑问是栈快一点。

因为操作系统会在底层对栈提供支持，会分配专门的寄存器存放栈的地址，栈的入栈出栈操作也十分简单，并且有专门的指令执行，所以栈的效率比较高也比较快。

而堆的操作是由 C/C++ 函数库提供的，在分配堆内存的时候需要一定的算法寻找合适大小的内存。并且获取堆的内容需要两次访问，第一次访问指针，第二次根据指针保存的地址访问内存，因此堆比较慢。

3️⃣ 静态存储区

静态存储区 = 全局数据区 + 常量区

全局数据区：全局变量 + 静态变量，该区域会被自动初始化

常量区：存放常量，不允许修改

静态存储区内的变量在程序编译阶段已经分配好内存空间并初始化。这块内存在程序的整个运行期间都存在，它主要存放 static 静态变量、全局变量和 const 常量。

区分：static 修饰「局部变量」在静态存储区中；const 修饰「局部变量」则是在栈区中。

注意：

1. 这里不区分初始化和未初始化的数据区，是因为静态存储区内的变量若不显示初始化，则编译器会自动以默认的方式进行初始化，即静态存储区内不存在未初始化的变量。
2. 静态存储区内的常量分为常变量和字符串常量，一经初始化，不可修改。静态存储内的常变量是全局变量，与局部常变量不同，区别在于局部常变量存放于栈，实际可间接通过指针或者引用进行修改，而全局常变量存放于静态常量区则不可以间接修改。
3. 字符串常量存储在静态存储区的常量区，字符串常量的名称即为它本身，属于常变量。
4. 数据区的具体划分，有利于我们对于变量类型的理解。不同类型的变量存放的区域不同。后面将以实例代码说明这四种数据区中具体对应的变量。

4️⃣ 代码区

存放程序体的二进制代码，比如我们写的函数都是在代码区。

1
2
3
4
5
6
7
8
9
10
11
12
13

int a = 0;//静态全局变量区
char *p1; //编译器默认初始化为NULL
void main()
{
    int b; //栈
    char s[] = "abc";//栈
    char *p2 = "123456";//123456在字符串常量区，p2在栈上
    static int c =0; //c在静态变量区，0为文字常量，在代码区
    const int d=0; //栈
    static const int d;//静态常量区
    p1 = (char *)malloc(10);//分配得来得10字节在堆区。
    strcpy(p1, "123456"); //123456放在字符串常量区，编译器可能会将它与p2所指向的"123456"优化成一个地方
}

7a. C++ 中 class 的大小由哪些因素决定？

在 C++ 中，类的大小由多个因素决定，主要包括：

1. 普通成员变量：类中定义的非静态成员变量会直接影响类的大小。每个成员变量都会占用相应的内存空间。
2. 虚函数：如果类包含虚函数，编译器会为该类添加一个虚函数表（vtable），并在每个对象中添加一个指向该表的指针（vptr），这会增加每个对象的大小。
3. 继承：类的继承关系也会影响其大小。
   • 单一继承：派生类会继承基类的成员变量和成员函数，但不会直接增加对象的大小。
   • 多重继承：派生类继承多个基类时，可能会导致对象中包含多个基类的子对象，从而增加对象的大小。
   • 虚拟继承：为了解决菱形继承问题，编译器可能会在派生类中引入虚拟基类指针，增加对象的大小。
4. 内存对齐：编译器通常会对类的成员变量进行内存对齐，以提高访问效率。这可能导致类的实际大小大于成员变量总和。
   • 分配内存的顺序是按照声明的顺序。
   • 每个变量相对于起始位置的偏移量必须是该变量类型大小的整数倍，不是整数倍空出内存，直到偏移量是整数倍为止。
   • 最后整个结构体的大小必须是里面变量类型最大值的整数倍。

⚠️ 需要注意的是，类的构造函数、析构函数、静态成员变量、静态成员函数和普通成员函数不会直接影响类的大小。

• 构造函数和析构函数：
  • 构造函数和析构函数是特殊的成员函数，用于对象的初始化和销毁。
  • 它们的存在不会增加类的实例大小，因为它们在对象创建和销毁时被调用，但并不占用对象的内存空间。
• 静态成员变量：
  • 静态成员变量属于类本身，而不是类的实例。
  • 它们在类的所有实例之间共享，只有一份存储空间（静态存储区）。
• 静态成员函数：
  • 静态成员函数也属于类本身，而不是类的实例。
  • 它们在类的所有实例之间共享，只有一份存储空间。
• 普通成员函数：
  • 普通成员函数是类的成员，但普通成员函数的代码通常存储在程序的代码段中，而不是对象的内存中。
  • 因此，普通成员函数不会影响类的实例大小。

7b. [7a 类似问题] C++ 的对象存储空间是怎么安排的？

C++ 中对象的存储取决于：

• 对象的类型（普通对象、继承对象、虚函数表等）
• 存储方式（栈、堆、静态存储区）
• 对齐方式

具体来说：

1️⃣ 普通对象

（1）非静态成员变量

• 普通对象的非静态成员变量按照 声明顺序 在内存中存储。
• 编译器会根据 CPU 架构和优化需求进行 内存对齐（alignment），可能会插入填充字节（padding）。
• 类的大小通常是 最大成员类型的对齐倍数。

示例：

1
2
3
4
5
6
7
8
9
10
11

#include <iostream>

struct A {
    char c;   // 1 字节
    int i;    // 4 字节
};

int main() {
    std::cout << sizeof(A) << std::endl;  // 输出可能是 8（对齐）
    return 0;
}

内存布局（假设 4 字节对齐）：

1

| c (1B) | padding (3B) | i (4B) |

（2）静态成员变量：不属于对象本身，放在静态存储区，在程序启动时分配。

2️⃣ 继承

（1）非虚继承：没有 virtual

派生类对象包括基类的成员变量，存储顺序是：

1. 基类子成员
2. 派生类新增成员
3. 对齐填充

1
2
3
4
5
6
7
8
9
10
11
12
13

struct Base {
    int a;
};

struct Derived : public Base {
    char b;
};

int main() {
    std::cout << sizeof(Derived) << std::endl;  // 可能是 8（对齐）
}

内存分布：| Base::a (4B) | Derived::b (1B) | padding (3B) |

（2）虚继承：基类含有 virtual 方法

• **虚基类**存储方式不同，编译器会创建虚基类指针 vptr 以及虚基类表 vtable 来管理它
• 可能会多一个指向虚基类表的指针，因此对象的大小会变大

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

struct Base {
    int a;
    virtual void func() {}  // 引入虚表
};

struct Derived : public Base {
    char b;
};

int main() {
    std::cout << sizeof(Derived) << std::endl;  // 可能是 16（虚表指针 + 对齐）
}

// 假设指针 8 字节
| vptr (8B) | Base::a (4B) | padding (3B) | Derived::b (1B) |

3️⃣ 多重继承

• 非虚多重继承：派生类按继承顺序依次存储多个基类的成员变量。
• 虚多重继承：对象中会存储多个虚表指针，可能引入 虚基类偏移表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

struct A {
    int a;
};

struct B {
    double b;
};

struct C : public A, public B {
    char c;
};

int main() {
    std::cout << sizeof(C) << std::endl;  // 可能是 24（对齐 + 多继承）
}

| A::a (4B) | padding (4B) | B::b (8B) | C::c (1B) | padding (7B) |

4️⃣ 对象存储方式

• 栈上对象：普通局部对象，生命周期受到作用域控制
• 堆上对象：使用 new 关键词分配的对象存储在堆区，需要手动 delete
• 静态存储区：static 变量存储在静态存储区

5️⃣ 虚函数和 vtable 虚表

• 如果类中有 虚函数，编译器会为该类生成 虚表（vtable），并在对象中存储 虚指针（vptr），指向该虚表。
• 虚表存储在静态区，而 vptr 存储在对象头部（通常是对象的第一个成员）。
• vptr 使得多态调用能够动态绑定。

⚠️ 虚指针存储在对象头部；虚表存储在静态存储区。

8. new/delete 和 malloc/free 有什么区别和联系？

更多内容（讲得很好）：C++ 种内存管理之 new/delete

联系：都可以用来在堆上分配和回收空间，new/delete 是操作符，malloc/free 是库函数。

执行 new 实际上执行两个过程：

1. 调用 malloc 分配未初始化的内存空间
2. 使用对象的构造函数对空间进行初始化，并返回空间的首地址

执行 delete 实际上也有两个过程：

1. 使用析构函数对对象进行析构
2. 调用 free 释放指针所指向空间的内存

二者区别：new 得到的是经过初始化的空间，而 malloc 得到的是未初始化的空间，所以 new 是 new 一个类型，而 malloc 则是 malloc 一个字节长度的空间。delete 和 free 同理，delete 不仅释放空间还析构对象，delete 一个类型，free 一个字节长度的空间。

对象的自动删除

通过之前的分析我们知道，new关键字创建对象并非一步完成，而是通过先分配未初始化内存和调用构造函数初始化两步实现的。那么在这个过程中如果是第一步出错，那么内存分配失败不会调用构造函数，这是没有问题的。但是如果第一步已经完成在堆中已经成功分配了内存之后，在第二步调用构造函数时异常导致创建对象失败（抛出 std::bad_alloc），那么就应该将第一步中申请的内存释放。C++中规定，如果一个对象无法完全构造，那么这个对象就是一个无效对象，也不会调用析构函数。因此为了保证对象的完整性，当通过 new 分配的堆内存对象在构造函数执行过程中出现异常时，就会停止构造函数的执行并且自动调用对应的 delete 运算符来对已经分配好的对内存执行销毁处理，即对象的自动删除技术。

🔥 为什么有了 malloc/free 还需要 new/delete

因为对于非内部数据类型而言，光用 malloc/free 无法满足动态对象的要求。对象在创建的同时需要自动执行构造函数，对象在消亡以前要自动执行析构函数。由于 malloc/free 是库函数而不是操作符，不在编译器控制权限之内，不能够把执行的构造函数和析构函数的任务强加于 malloc/free，所以在 C++ 中需要一个能完成动态内存分配和初始化工作的运算符 new，以及一个能完成清理和释放内存工作的运算符 delete。而且在对非基本数据类型的对象使用的时候，对象创建的时候还需要执行构造函数，销毁的时候要执行析构函数。而 malloc/free 是库函数，是已经编译的代码，所以不能把构造函数和析构函数的功能强加给 malloc/free，所以 new/delete 是必不可少的。

既然 new/delete 的功能完全覆盖了 malloc/free，为什么 C++ 不把 malloc/free 淘汰出局呢？这是因为 C++ 程序经常要调用 C 函数，而 C 程序只能用 malloc/free 管理动态内存。

🔥 malloc 与 free 的实现原理（brk()、mmap()）

1、在标准 C 库中，提供了 malloc/free 函数分配释放内存，这两个函数底层是由 brk、mmap、munmap 这些系统调用实现的;

• brk 是将「堆顶」指针向高地址移动，获得新的内存空间；
• mmap 是在进程的虚拟地址空间中（堆和栈中间，称为文件映射区域的地方）找一块空闲的虚拟内存。

这两种方式分配的都是虚拟内存，没有分配物理内存。在第一次访问已分配的虚拟地址空间的时候，发生缺页中断，操作系统负责分配物理内存，然后建立虚拟内存和物理内存之间的映射关系。

2、malloc 分配阈值

• malloc 小于 128k 的内存，使用 brk 分配内存，将「堆顶」指针往高地址推；
• malloc 大于 128k 的内存，使用 mmap 分配内存，在堆和栈之间找一块空闲内存分配；

brk 分配的内存需要等到高地址内存释放以后才能释放，而 mmap 分配的内存可以单独释放。当最高地址空间的空闲内存超过 128K（可由 M_TRIM_THRESHOLD 选项调节）时，执行内存紧缩操作（trim）。在上一个步骤 free 的时候，发现最高地址空闲内存超过 128K，于是内存紧缩。

3、空闲地址链表：malloc 是从堆里面申请内存，也就是说函数返回的指针是指向堆里面的一块内存。操作系统中有一个记录空闲内存地址的链表。当操作系统收到程序的申请时，就会遍历该链表，然后就寻找第一个空间大于所申请空间的堆结点，然后就将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。

🔥 被 free 回收的内存是立即返回给操作系统吗？

更详细的内容：

• 深入理解 glibc malloc: 内存分配器实现原理
• xiaolincoding

不一定。被 free 的内存不一定会立刻返回给操作系统，具体行为取决于操作系统的内存管理机制以及 C 语言运行时库（如 glibc）的实现方式。

对于 「malloc 申请的内存，free 释放内存会归还给操作系统吗？」这个问题，我们可以做个总结：

• malloc 通过 brk() 方式申请的内存，free 释放内存的时候，并不会把内存归还给操作系统，而是缓存在 malloc 的内存池中，待下次使用；
• malloc 通过 mmap() 方式申请的内存，free 释放内存的时候，会把内存归还给操作系统，内存得到真正的释放。

什么场景下 malloc() 会通过 brk() 分配内存？又是什么场景下通过 mmap() 分配内存？

malloc() 源码里默认定义了一个阈值：

• 如果用户分配的内存小于 128 KB，则通过 brk() 申请内存；
• 如果用户分配的内存大于 128 KB，则通过 mmap() 申请内存；

注意，不同的 glibc 版本定义的阈值也是不同的。

1. 内存释放流程

当你在 C/C++ 中使用 free(ptr) 释放一块内存时：

• 内存被标记为“空闲”，表示这块内存可以被后续的 malloc 或 calloc 重用。
• 但它通常不会立即归还给操作系统，而是由内存分配器（如 glibc 的 ptmalloc）保留在用户进程中，用于后续分配。

2. 什么时候会真正返回给操作系统？

• 如果释放的是堆顶的内存块（即堆的末端），且满足一定条件，glibc 可能会调用 brk 或 mmap 对应的释放机制（如 munmap）来将这部分内存返回给操作系统。
• 使用 mmap 分配的大块内存（通常大于一定阈值，比如 128KB），在被 free 时通常会直接使用 munmap 归还给操作系统。

3. glibc 的行为（以 Linux 为例）

glibc 的 malloc 有一套复杂的内存池机制，常见策略：

• 小块内存来自内部的 arena，free 后不会归还操作系统，而是缓存起来以便重用。
• 大块内存通过 mmap 分配，free 后可能会立即调用 munmap 释放给系统。

4. 查看内存是否释放

可以使用工具如：

• top 或 htop 查看内存使用趋势
• valgrind 检查内存泄漏
• pmap 查看进程的内存映射情况
• mallinfo()（旧）或 malloc_info()（新）来观察 glibc 的内存使用状况

🔥 malloc、realloc、calloc 的区别？

1️⃣ malloc 函数

1
2
3

void* malloc(unsigned int num_size);

int *p = malloc(20*sizeof(int)); // 申请 20 个 int 类型的空间；

2️⃣ calloc 函数：省去了人为空间计算；malloc 申请的空间的值是随机初始化的，calloc 申请的空间的值是初始化为 0 的；

1
2
3

void* calloc(size_t n,size_t size);

int *p = calloc(20, sizeof(int));

3️⃣ realloc 函数：给动态分配的空间分配额外的空间，用于扩充容量。

1

void realloc(void *p, size_t new_size);

9. 异常/错误处理有几种方法，为什么有些场合要禁用？

C++ 提供了多种错误处理机制，主要包括：

• 返回码：函数通过返回值指示成功或失败，调用者需要检查返回值以确定操作结果。
• 错误码：使用全局或静态变量存储错误码，调用者需要在每个步骤后检查错误码。
• 异常处理：使用 try、catch 和 throw 关键字捕获和处理异常，提供结构化的错误处理方式。

在某些场合，可能需要禁用异常处理，原因包括：

• 性能要求高的场合：异常处理可能引入性能开销，影响程序的执行效率。
• 嵌入式系统：资源有限，可能不支持异常处理。
• 编译器不支持：某些编译器可能不支持异常处理。

禁用异常处理可以通过编译器选项实现，例如在 Sun Studio 中使用 -features=no%except 来禁用异常处理。

10. C 相关的问题，什么是野指针，有哪些野指针？

野指针是指向「未初始化」或「已释放内存」的指针，使用野指针会导致未定义行为，常见野指针：

• 未初始化的指针：指针声明后未被初始化，默认值不确定，可能指向任意内存地址
• 悬垂指针：指向已释放内存的指针，释放内存后未将指针置为 NULL，导致指针仍指向已回收的内存地址
• 空指针：指针被初始化为 NULL，但在后续使用前未被赋予有效地址，导致解引用时发生错误

为避免野指针，应该在声明指针时进行初始化，并在释放内存后将指针置为 NULL。

在更多结构化的解决方案中，一种流行的避免悬垂指针的技术是使用智能指针，一个智能指针通常使用引用技术来收回对象。还有些技术包括 tombstones 方法和 locks-and-keys 方法。另一个方法是使用 Boehm 垃圾收集器，一种保守的垃圾收集器，取代 C 和 C++ 中的标准内存分配函数。此法通过禁止内存释放函数来完全消除悬垂指针引发的错误，通过收集垃圾来回收对象。

11. 你平常怎么调试代码，你能想到多少方法？

调试代码是开发过程中非常重要的一部分，尤其是当出现问题时。调试的方式有很多种，下面是我能想到的常见调试方法：

使用调试器 (Debugger)

调试器是一种强大的工具，可以让你在程序运行时暂停执行，检查变量的值、调用堆栈等信息，逐行执行代码来找出错误。常见的调试器包括：

• GDB (GNU Debugger)：适用于 C/C++ 等语言，通过命令行进行调试。
• Visual Studio Debugger：适用于 Windows 上的 C++ 和 .NET 程序。
• LLDB：用于 macOS 或 Linux 的调试器。
• Xcode Debugger：适用于 macOS 和 iOS 应用的调试器。

使用调试器，你可以：

• 设置断点：暂停程序执行，以检查变量状态和函数调用。
• 逐步执行代码：逐行执行，查看每一行代码的效果。
• 检查栈信息和变量的值：实时查看变量的值、函数调用栈、内存内容等。

例如，使用 GDB 调试 C++ 代码时，可以使用以下命令：

• gdb ./your_program 启动调试器。
• break main 在 main() 函数处设置断点。
• run 启动程序执行。
• step 或 next 逐步执行代码。

插入日志输出 (Logging)

在代码中添加日志输出是调试程序的常见方法。你可以在代码中插入 printf、std::cout 或日志库（如 log4cpp, spdlog, glog 等）来输出变量值、函数执行状态和程序流程。

常见做法包括：

• 输出函数进入与退出的日志。
• 打印变量值、数据结构的内容。
• 打印程序的状态和执行的分支。

例如：

1

std::cout << "Value of x: " << x << std::endl;

优点：

• 非常直接和简单。
• 可以在生产环境中使用（例如在开发版和发布版中配置不同的日志级别）。

缺点：

• 可能会遗漏某些地方，导致调试信息不够全面。
• 需要在最终代码中删除或关闭冗余的日志输出。

单元测试 (Unit Testing)

单元测试是一种自动化的方式，可以帮助你验证代码的正确性。使用框架如 Google Test（C++）、JUnit（Java）、pytest（Python）等，可以编写测试用例，自动运行测试，并在代码发生变化时及时捕捉错误。

单元测试的优点：

• 确保代码的每个模块都按预期工作。
• 能够提前发现潜在问题，特别是在修改代码时。

缺点：

• 测试用例需要编写和维护，可能需要额外的时间。
• 需要有较好的测试覆盖率，才能检测到更多的错误。

静态分析工具 (Static Analysis)

静态分析工具可以在代码运行之前，扫描代码并检查潜在的错误、内存泄漏、资源管理问题等。例如：

• Clang Static Analyzer
• CppCheck
• SonarQube
• Coverity

静态分析工具能够检测到：

• 未初始化的变量。
• 内存泄漏。
• 潜在的并发问题。
• 错误的代码模式等。

代码审查 (Code Review)

代码审查是与团队成员或同事一起查看和讨论代码的过程。其他开发者可以帮助你发现代码中的潜在问题或逻辑错误。

代码审查的优点：

• 多人的视角能够发现更多问题。
• 通过讨论，能够提升代码质量和团队合作。

集成测试 (Integration Testing)

集成测试是测试多个组件（或模块）一起工作时的行为。在多个模块组合工作时，问题可能不是单独模块内部，而是它们之间的交互。集成测试帮助你检查模块之间的接口和数据流。

集成测试通常用来发现：

• 模块之间的兼容性问题。
• 数据格式错误。
• 不正确的模块交互等。

内存泄漏检测工具

如果你的程序存在内存泄漏问题，可以使用专门的工具来检测内存的分配和释放：

• 🔥 Valgrind：广泛用于检测内存泄漏、内存错误等问题，适用于 C/C++ 程序。
• AddressSanitizer：现代编译器（如 Clang、GCC）提供的工具，可以检测内存相关的错误，包括越界访问、内存泄漏等。

这些工具帮助你找出内存泄漏和错误的内存访问问题，并给出详细的报告。

运行时分析工具

运行时分析工具通过收集程序运行时的信息来进行调试和优化。例如：

• gprof：用于性能分析，查看程序中哪些函数占用了最多的时间。
• perf：Linux 下的性能分析工具，帮助查看程序在系统层面的性能瓶颈。
• VisualVM：Java 应用程序的性能分析工具，能够分析内存、CPU 和线程使用情况。

条件断点和日志断点

在调试过程中，有时你希望仅在满足特定条件时暂停程序。这时可以使用条件断点或日志断点：

• 条件断点：只有当某个条件成立时，调试器才会停止程序执行。
• 日志断点：调试器在不停止程序执行的情况下，记录断点信息。

回滚与分支 (Git Bisect)

如果你无法确定错误是在哪次提交中引入的，使用 Git 提供的 git bisect 命令来回滚到历史提交并逐步测试，可以帮助定位问题的来源。

通过二分查找算法，git bisect 可以帮助你快速定位到错误引入的那一行代码。

故障注入 (Fault Injection)

故障注入是故意在程序中引入故障，以测试程序在面对错误时的反应。例如，可以通过随机生成异常、模拟网络延迟或中断等方式，检查系统的健壮性和错误处理能力。

动态分析与跟踪 (Dynamic Analysis)

使用跟踪工具（如 strace, ltrace, dtrace 等）来实时观察程序执行过程中的系统调用和函数调用。这种方式帮助你了解程序在运行时的行为，找出性能瓶颈或其他问题。

12. 什么是 C++ 多态？

C++ 多态即使用基类指针或引用来调用子类的重写方法，从而使得同一接口表现不同的行为。

多态优势：

• 代码复用：通过基类指针或引用，可以操作不同类型的派生类对象，实现代码复用
• 扩展性：新增派生类时，不需要修改依赖于基类的代码，只需要确保新类正确重写了虚函数
• 解耦：多态允许程序更加模块化，降低类之间的耦合度

🔥 面试一定要回答「静态多态」+「动态多态」

多态一般就是指继承 + 虚函数实现的多态，对于重载来说，实际原理是编译器为函数生成符号表时的不同规则，重载只是一种语言特性，与多态无关，与面向对象无关，所以如果非要说重载算是多态的一种，那 C++ 中多态可以分为「静态多态」和「动态多态」两种：

• 静态多态：在编译时期就决定了调用哪个函数，根据参数列表来决定，主要通过函数重载和模板实现
• 动态多态：通过子类重写父类的虚函数来实现，是运行期间决定调用的函数

动态多态的实现与虚函数表（V-Table），虚函数指针（V-Ptr）相关：

• 虚函数表（V-Table）：C++ 运行时使用虚函数表来实现多态，每个包含虚函数的类都有一个虚函数表，表中存储了指向类中所有虚函数的指针。
• 虚函数指针（V-Ptr）：对象中包含一个指向该类虚函数表的指针。

扩展：子类是否要重写父类的虚函数？子类继承父类时，父类的纯虚函数必须重写，否则子类也是一个虚类不可实例化。定义纯虚函数是为了实现一个接口，起到一个规范的作用，规范继承这个类的程序员必须实现这个函数。

13. 什么是虚函数与虚函数指针，C++ 虚函数的实现原理？

首先说一下 C++ 中多态的表象：在基类的函数前加上 virtual 关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数：

• 如果对象类型是派生类，就调用派生类的函数
• 如果是基类，就调用基类的函数

虚函数 vtable 与虚函数指针 vptr

实际上，当一个类中包含虚函数 virtual 时，编译器就会为该类生成一个虚函数表 vtable，保存该类中虚函数的地址。同样，派生类继承基类，派生类中自然一定有虚函数，所以编译器也会为派生类生成自己的虚函数表 vtable。当我们定义一个派生类对象时，编译器检测到该类型有虚函数，就会为这个派生类对象生成一个虚函数指针 vptr，指向该类型的虚函数表 vtable，虚函数指针 vptr 的初始化是在构造函数中完成的。后续如果有一个基类类型的指针指向派生类，那么当调用虚函数时，就会根据所指真正对象的虚函数表指针 vptr 去寻找虚函数的地址，也就可以调用派生类的虚函数表中虚函数以此实现多态。

补充：如果基类中没有定义成 virtual（只有继承），那么在这种情况调用的则是 Base 中的 func()。因为如果基类和派生类中都没有虚函数 virtual 的定义，那么编译器就会认为不用留给动态多态的机会，就事先进行函数地址的绑定（早绑定 —— 静态绑定），具体过程：

• 定义了派生类对象，首先构造基类的空间，然后构造派生类的自身内容，形成一个派生类对象
• 进行类型转换时，直接截取基类的部分内存，编译器认为类型就是基类，那么函数符号表（不同于虚函数表）绑定的函数地址也就是基类中的函数地址，执行的就是基类函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// 🌟只有 virtual 存在，编译器才会认为存在「多态」
class Base {
public:
    // virtual 不存在则只调用 ~Base()
    virtual ~Base() { // 虚析构函数
        // 释放 Base 的资源
        cout << "释放 Base 的资源" << endl;
    }

    // virtual 不存在则只调用 Base func()
    virtual void func() {
        cout << "Base_func()" << endl;
    }
};

class Derived : public Base {
public:
    // override 可加可不加，有助于编译器检查
    ~Derived() override {
        // 释放 Derived 的资源
        cout << "释放 Derived 的资源" << endl;
    }

    // override 可加可不加，有助于编译器检查
    void func() override {
        cout << "Derived_func()" << endl;
    }
};

int main() {
    Base* ptr = new Derived;
    ptr->func();
    delete ptr;  // 调用时，先执行 Derived::~Derived()，再执行 Base::~Base()
    return 0;
}

1
2
3

Derived_func()
释放 Derived 的资源
释放 Base 的资源

C++ 虚函数的内存分布 & 实现原理

以上简要介绍了「虚函数」相关内容（简要介绍了原理），接下来详细阐述实现原理

更多信息：C++ 虚函数的实现基本原理

1
2
3
4
5
6
7
8
9
10
11

class A {
  public:
    virtual void v_a(){}
    virtual ~A(){}
    int64_t _m_a;
};

int main(){
    A* a = new A();
    return 0;
}

如以上代码所示，在 C++ 中定义一个对象 A，那么在内存中的分布大概是如下图这个样子。

• 首先在主函数的栈帧上有一个 A 类型的指针指向堆里面分配好的对象 A 实例。
• 对象 A 实例的头部是一个 vtable 指针，紧接着是 A 对象按照声明顺序排列的成员变量（当我们创建一个对象时，便可以通过实例对象的地址，得到该实例的虚函数表，从而获取其函数指针）
• vptr 指针指向的是代码段中的 A 类型的虚函数表中的第一个虚函数起始地址。
• 虚函数表 vtable 的结构其实是有一个头部的，叫做 vtable_prefix ，紧接着是按照声明顺序排列的虚函数。
• 注意到这里有两个虚析构函数，因为对象有两种构造方式，栈构造和堆构造，所以对应的，对象会有两种析构方式，其中堆上对象的析构和栈上对象的析构不同之处在于，栈内存的析构不需要执行 delete 函数，会自动被回收。
• typeinfo 存储着 A 的类基础信息，包括父类与类名称，C++关键字 typeid 返回的就是这个对象。
• typeinfo 也是一个类，对于没有父类的 A 来说，当前 tinfo 是 class_type_info 类型的，从虚函数指针指向的 vtable 起始位置可以看出。

1️⃣ Example-1｜如果是多继承情况下，编译器如下处理虚函数表｜虚函数的实现原理

• 拷贝基类的虚函数表，多继承则拷贝每个虚函数基类的虚函数表
• 多继承会存在一个基类虚函数表和派生类自身虚函数表合并共用，该基类称为派生类的主基类
• 派生类重写基类虚函数，则替换重写后的虚函数地址
• 如果有自身虚函数，则追加自身虚函数到自身的虚函数表

其中 D 对象 vptr1 指向的虚函数表合并了「某个基类虚函数表」和「派生类自身虚函数表」，vptr2 则指向另一个基类的虚函数表

2️⃣ Example-2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class A{
private:
    uint64_t a;
public:
    virtual void A_a(){std::cout << __func__;}
};
class C{
private:
    uint64_t c;
public:
    virtual void C_a(){std::cout << __func__;}
};

class D : public A,public C{
private:
    uint64_t d;
public:
    virtual void D_a(){std::cout << __func__;}
};

class D 的虚函数表

14. 析构函数可以是虚函数吗？什么情况下析构函数必须是虚函数？

🪞镜像问题：

• 为什么需要虚析构？虚析构实现原理？
• 析构函数一般写成虚函数的原因？

析构函数可以是虚函数。将析构函数声明为 virtual 虚函数，确保在删除基类指针指向的派生类对象时，能够正确调用派生类的析构函数，避免内存泄漏。

举例来说，一个基类的指针指向一个派生类的对象，在使用完毕准备销毁时，如果基类的析构函数没有定义成 virtual 虚函数，那么编译器根据指针类型就会认为当前对象类型是基类，仅调用基类的析构函数（该对象的析构函数的函数地址早就被绑定为基类的析构函数——静态绑定 / 早绑定），派生类的自身内容将无法被析构，造成内存泄漏。如果基类的析构函数定义为虚函数，那么编译器就可以根据实际对象，执行派生类的析构函数，再执行基类的析构函数，成功释放内存。

注释助于理解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// 🌟只有 virtual 存在，编译器才会认为存在「多态」
class Base {
public:
    // virtual 不存在则只调用 ~Base()
    virtual ~Base() { // 虚析构函数
        // 释放 Base 的资源
        cout << "释放 Base 的资源" << endl;
    }

    // virtual 不存在则只调用 Base func()
    virtual void func() {
        cout << "Base_func()" << endl;
    }
};

class Derived : public Base {
public:
    ~Derived() {
        // 释放 Derived 的资源
        cout << "释放 Derived 的资源" << endl;
    }

    void func() {
        cout << "Derived_func()" << endl;
    }
};

int main() {
    Base* ptr = new Derived;
    ptr->func();
    delete ptr;  // 调用时，先执行 Derived::~Derived()，再执行 Base::~Base()
    return 0;
}

1
2
3

Derived_func()        // func() 没定义 virtual 则输出 Base_func()
释放 Derived 的资源     // ~Base() 没定义 virtual 则不输出
释放 Base 的资源

⚠️ C++ 默认的析构函数不是虚函数，是因为虚函数需要额外的虚函数表和虚表指针，占用额外的内存。

当类被设计为「基类」，并且可能被继承时，析构函数应当声明为虚函数。如果类不会被继承，则析构函数可以不声明为虚函数。然而，为了代码的健壮性和可维护性，通常建议将基类的析构函数声明为虚函数，即使该类当前不会被继承。

15. 构造函数为什么一般不定义为虚函数

1️⃣ 虚函数调用只需要知道“部分信息”，即只需要知道函数接口，而不需要知道对象的具体类型。但是创建对象时，是需要知道对象的完整信息，特别是需要知道创建对象的确切类型，因此构造函数不应该被定义为虚函数。

2️⃣ 从编译器实现虚函数进行多态的方式来看，虚函数调用时通过实例化之后对象的虚函数表指针 vptr 来找到虚函数地址进行调用的，如果说构造函数是虚的，那么虚函数表指针则不存在（因为虚函数指针 vptr 的初始化是在构造函数中完成的），无法找到对应的虚函数表 vtable 来调用虚函数，那么这个调用实际上也是违反了先实例化后调用的准则。

16. 构造函数的执行顺序？析构函数的执行顺序？

1️⃣ 构造函数顺序

• 基类构造函数：如果有多个基类，则构造函数调用顺序是某类在「类派生列表」中出现的顺序，而不是它们在成员初始化表中的顺序
• 成员类对象构造函数：如果有多个成员类对象，则构造函数的调用顺序是对象在类中被声明的顺序，而不是它们出现在成员初始化表中的顺序
• 派生类构造函数

类派生列表

1
2
3
4
5
6
7

class 派生类名:类派生列表 {
    成员列表
}

class Derived : public Base1, public Base2 {
    成员列表
}

2️⃣ 析构函数顺序

• 调用派生类的析构函数
• 调用成员类对象的析构函数
• 调用基类的析构函数

17. 静态绑定和动态绑定

我们首先要知道静态类型和动态类型：

• 静态类型：在程序中被声明时所采用的类型，在编译期间确定
• 动态类型：目前所指对象的实际类型，在运行期间确定

关于静态绑定和动态绑定：

• 静态绑定，又称早绑定，绑定的是静态类型，所对应的函数或属性依赖于对象的静态类型，发生在编译期间。
• 动态绑定，又称晚绑定，绑定的是动态类型，所对应的函数或属性依赖于动态类型，发生在运行期间。

比如说，virtual 函数是动态绑定的，非虚函数是静态绑定的，缺省参数值也是静态绑定的。

⚠️ 注意，我们不应该重新定义继承而来的缺省参数，因为即使我们重定义了，也不会起到效果。因为一个基类的指针指向一个派生类对象，在派生类的对象中针对虚函数的参数缺省值进行了重定义， 但是缺省参数值是静态绑定的，静态绑定绑定的是静态类型相关的内容。

18. 纯虚函数

纯虚函数是在基类中「声明但不实现」的虚函数，其声明方式是在函数声明的结尾处添加 = 0，类中如果至少包含一个纯虚函数，则该类称为抽象类，抽象类是不能实例化对象的。

纯虚函数的主要作用是定义接口规范，强制要求派生类必须实现这些函数，从而实现借口的统一和标准化。派生类中必须实现继承于基类的纯虚函数，否则含有纯虚函数的类又会是抽象类，无法实例化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Shape {
public:
    virtual void draw() = 0; // 纯虚函数
};

class Circle : public Shape {
public:
    // 必须实现，否则该派生类为抽象类，不能实例化
    void draw() override {
        cout << "Drawing a circle" << endl;
    }
};

int main() {
    Shape* shape = new Circle();
    shape->draw(); // 输出：Drawing a circle
    delete shape;
    return 0;
}

19. 深拷贝和浅拷贝的区别（举例说明深拷贝的安全性）

1️⃣ 浅拷贝：

• 当出现类的等号 = 赋值时，会调用拷贝构造函数，在未显式定义拷贝构造函数的情况下，系统会调用默认的拷贝函数 —— 即浅拷贝，它能够完成成员的复制，当数据成员中没有指针时，浅拷贝是可行的；
• 但当数据成员中有指针时，如果采用简单的浅拷贝，则两个类中的两个指针指向同一个地址，当对象快要结束时，会调用两次析构函数，从而导致野指针的问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class ShallowCopy {
private:
    int* data;
public:
    ShallowCopy(int d) : data(new int(d)) {}
    // 而且在对象结束时，会调用两次析构函数，从而导致野指针问题
    ~ShallowCopy() { delete data; }
    void setData(int d) { *data = d; }
    int getData() const { return *data; }

    // 默认拷贝构造函数（浅拷贝）
    ShallowCopy(const ShallowCopy& source) : data(source.data) {}
};

int main() {
    ShallowCopy obj1(10);
    ShallowCopy obj2 = obj1; // 使用默认拷贝构造函数

    cout << "obj1 data: " << obj1.getData() << endl;
    cout << "obj2 data: " << obj2.getData() << endl;

    obj1.setData(20); // 修改 obj1 的数据

    cout << "After modifying obj1" << endl;
    cout << "obj1 data: " << obj1.getData() << endl;
    cout << "obj2 data: " << obj2.getData() << endl; // obj2 数据也被修改了

    return 0;
}

2️⃣ 深拷贝：在数据成员含有指针时，必须采用深拷贝（自定义拷贝构造函数），在拷贝构造函数中创建一个全新对象，与原对象完全独立。深拷⻉与浅拷⻉之间的区别就在于，深拷⻉会在堆内存中另外申请空间来存储数据，从而解决来野指针的问题。简而言之，当数据成员中有指针时，必需要用深拷⻉更加安全。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class DeepCopy {
private:
    int *data;
public:
    DeepCopy(int d) : data(new int(d)) {}
    ~DeepCopy() { delete data; }
    void setData(int d) { *data = d; }
    int getData() const { return *data; }

    // 自定义拷贝构造函数（深拷贝）
    DeepCopy(const DeepCopy &source) : data(new int(*source.data)) {}
};

int main() {
    DeepCopy obj1(10);
    DeepCopy obj2 = obj1; // 使用自定义拷贝构造函数

    cout << "obj1 data: " << obj1.getData() << endl;
    cout << "obj2 data: " << obj2.getData() << endl;

    obj1.setData(20); // 修改 obj1 的数据

    cout << "After modifying obj1" << endl;
    cout << "obj1 data: " << obj1.getData() << endl;
    cout << "obj2 data: " << obj2.getData() << endl; // obj2 数据没有变化

    return 0;
}

20. 说一下你理解的 C++ 四种智能指针｜shared_ptr 的简易实现

更多信息：C++ 智能指针、知乎 C++ 智能指针

看这两篇，取取交集

在使用 C++ 开发过程中，最容易也是最麻烦的问题便是内存泄漏。相较于 Java、Python 或者 Go 语言都拥有垃圾回收机制，在对象没有引用时就会被系统自动回收而且基本上没有指针的概念，但是 C++ 则要求程序员自己管理内存，这一方面让程序员有更大的自由度但是也会很大影响程序员的开发效率。因此 C++11 标准中新推出了 shared_ptr、unique_ptr 和 weak_ptr 三个智能指针来帮助管理内存。

智能指针就是一个类，当超出了类的作用域时，类会自动调用析构函数，析构函数会自动释放资源，所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放。

1
2
3
4
5
6

T* get();
T& operator*();
T* operator->();
T& operator=(const T& val);
T* release();
void reset (T* ptr = nullptr);

常用接口：

• T 是模板参数，即传入的类型
• get() 用来获取 auto_ptr 封装在内部的指针，也就是获取原生指针
• operator*() 重载 *，operator->() 重载 ->，operator=() 重载 =
• release() 将 auto_ptr 封装在内部的指针置为 nullptr，但不会破坏指针所指向的内容，函数返回的是内部指针置空之前的值
• reset() 直接释放封装的内部指针所指向的内存，如果指定了 ptr 的值，则将内部指针初始化为该值

接下来说说哪四种智能指针：

• auto_ptr 为 C++98 的方案，C++11 已抛弃
• C++11 引入
  1. std::shared_ptr
  2. std::weak_ptr
  3. std::unique_ptr

0️⃣ auto_ptr

C++98 方案，C++11 已抛弃

1
2
3

auto_ptr<std::string> p1(new string("string"));
auto_ptr<std::string> p2;
p2 = p1;    // auto_ptr 不会报错

p2 剥夺了 p1 的所有权，但是当程序运行时访问 p1 将会报错，所以 auto_ptr 缺点就是存在潜在的内存崩溃问题。

1️⃣ shared_ptr 共享式智能指针

彻底理解：shared_ptr 是有两层析构：

• shared_ptr 本身析构会使得指向的共享对象的引用数 -1，当共享对象引用数为 0 时，则调用共享对象本身的析构函数
• 这样就可以理解循环引用了：共享对象引用还是 1，未调用共享对象本身的析构函数，其中成员 shared_ptr 的析构函数也不会被调用

shared_ptr 能够自动记录共享对象的引用次数，并且在引用计数降至零时自动删除对象，从而防止内存泄漏。每个 shared_ptr 的拷贝都指向相同的内存，在最后一个 shared_ptr 析构的时候其指向的内存资源才会被释放。

shared_ptr 初始化方式：

1. 构造函数
2. std::make_shared() 辅助函数
3. reset()

1
2
3
4
5
6

std::shared_ptr<int> p(new int(1));
std::shared_ptr<int> p2 = p;
std::shared_ptr<A> ap = std::make_shared<A>();

std::shared_ptr<int> ptr;
ptr.reset(new int(1));

不能将一个原始指针直接赋值给一个智能指针，如：std::shared_ptr<int> p = new int(1)。

对于一个未初始化的智能指针，可以通过调用 reset 方法初始化，当智能指针中有值的时候，调用 reset 方法会使引用计数减 1。当需要获取原指针的时候可以通过 get 方法返回原始指针：

1
2

std::shared_ptr<int> p(new int(1));
int *ptr = p.get();

智能指针初始化时也可以指定删除器，当其引用计数为 0 时将自动调用删除器来释放对象，删除器可以是一个函数对象。如当使用 shared_ptr 管理动态数组时，需要指定删除器，因为 shared_ptr 默认删除器不支持数组对象：

1
2

// lambda 表达式作为删除器
std::shared_ptr<int> p(new int[10], [](int *p) { delete []p; })

关于 shared_ptr 的注意事项：

• 不要用一个裸指针初始化多个 shared_ptr，会出现 double_free 导致程序崩溃
• 通过 shared_from_this() 返回 this 指针，不要把 this 指针作为 shared_ptr 返回出来，因为 this 指针本质就是裸指针，通过 this 返回可能会导致重复析构，不能把 this 指针交给智能指针管理。

1
2
3
4
5
6

class A {
      shared_ptr<A> GetSelf() {
        return shared_from_this();
          // return shared_ptr<A>(this); 错误，会导致 double free
    }  
};

• 尽量使用 std::make_shared<T>()，少用 new
• 不要 delete get() 返回的裸指针
• 不是 new 出来的空间要自定义删除器
• 要避免循环引用，循环引用导致内存永远不会被释放，造成内存泄漏

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class A;
class B;

class A {
public:
    std::shared_ptr<B> b;
};

class B {
public:
    std::shared_ptr<A> a;
};

int main() {
    std::shared_ptr<A> ap = std::make_shared<A>();
    std::shared_ptr<B> bp = std::make_shared<B>();
    ap->b = bp;
    bp->a = ap;
    // 此时，a 和 b 相互持有对方的 shared_ptr，形成循环引用
    // 程序结束时，a 和 b 的引用计数都不会降为零，导致内存泄漏
    return 0;
}

🌟 解释说明循环引用：

• 首先循环引用导致 shared_ptr 指向的共享对象 A 和 B 的引用计数都是 2；
• 在离开作用域后，根据栈后进先出的特点，首先 shared_ptr<B> bp 析构时只减少 B 的引用次数为 1（这里是对象 shared_ptr 析构而非对象 B 析构），由于此时对象 B 的引用次数仍为 1（减为 0 的 B 才会被释放），所以不会调用（对象 B）内部智能指针 a 的析构函数来减少引用，所以也就无法减少 A 的引用次数了。
• 接着 ap 析构时减少 A 的引用次数为 1，此时 A 的引用仍为 1 不会被析构，所以无法析构其成员对象 b；
• 最终导致指针永远不会析构，产生了内存泄漏（解决方案就是使用 weak_ptr）

2️⃣ weak_ptr 弱引用智能指针

weak_ptr 是一种不控制对象生命周期的智能指针，它指向一个 shared_ptr 管理的对象，它不管理 shared_ptr 内部指针，进行该对象的内存管理的是那个强引用的 shared_ptr。

weak_ptr 只是提供了对管理对象的一个访问手段。weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作，纯粹是作为一个旁观者监视 shared_ptr 中管理的资源是否存在，它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造，它的构造和析构不会引起引用记数的增加或减少。

weak_ptr 是用来解决 shared_ptr 相互引用时的死锁问题，如果说两个 shared_ptr 相互引用，那么这两个指针的引用计数永远不可能下降为 0，也就是资源永远不会释放。它是对对象的一种弱引用，不会增加对象的引用计数，和 shared_ptr 之间可以相互转化：

• shared_ptr 可以直接赋值给它
• 它也可以通过调用 lock 函数来获得 shared_ptr

循环引用是当两个智能指针都是 shared_ptr 类型的时候，析构时两个资源引用计数会减 1，但是两者引用计数还是为 1，导致跳出函数时资源没有被释放（析构函数没有被调用），解决办法就是把其中一个改为 weak_ptr 就可以。

总之 weak_ptr 可以用来返回 this 指针和解决循环引用问题。

• 作用 1：返回 this 指针，上面介绍的 shared_from_this() 其实就是通过 weak_ptr 返回的 this 指针

Q：shared_from_this() 是如何实现的？

A：使用 shared_from_this() 的类需要继承 enable_shared_from_this 类，enable_shared_from_this 类中持有一个类型为 weak_ptr 的成员 _M_weak_this，调用 shared_from_this() 就是将内部持有的 weak_ptr 转成了 shared_ptr。

1
2
3
4
5
6
7
8
9

class enable_shared_from_this
{
    shared_ptr<const _Tp> shared_from_this() const
    {
        return shared_ptr<const _Tp>(this->_M_weak_this);
    }

    mutable weak_ptr<_Tp> _M_weak_this;
};

• 作用 2：解决循环引用问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

class A {
    std::shared_ptr<B> bptr;
    
    ~A() {
        cout << "A delete" << endl;
    }
    
    void Print() {
        cout << "A" << endl;
    }
};

class B {
    std::weak_ptr<A> aptr;         // 这里改成 weak_ptr
    
    // B 对象销毁时才调用（即引用计数为 0 时）
    ~B() {
        cout << "B delete" << endl;
    }
    
    void PrintA() {
        if (!aptr.expired()) {     // 监视 shared_ptr 的生命周期
            auto ptr = aptr.lock();
            ptr->Print();
        }
    }
};

int main() {
    auto aaptr = std::make_shared<A>();
    auto bbptr = std::make_shared<B>();
    aaptr->bptr = bbptr;
    bbptr->aptr = aaptr;
    bbptr->PrintA();
    return 0;
}

// 输出：
// A
// A delete
// B delete

🔥 代码解释：尽管局部变量的析构顺序是按照后进先出的原则，但关键在于“对象的销毁时机”是由引用计数决定的，而不是直接由局部变量析构的顺序决定的：

1. 局部变量析构顺序：在 main 函数中，aaptr 先创建、bbptr 后创建，因此在退出作用域时，bbptr 会先析构，随后 aaptr 析构。
2. 引用计数的影响
   • 创建时，aaptr 持有 A 对象，bbptr 持有 B 对象。
   • A 对象内部的成员变量 bptr 又持有 B 对象的 shared_ptr，因此 B 对象的引用计数为 2。
   • B 对象内部的 weak_ptr 不会影响 A 对象的引用计数。
3. 析构过程
   • 当 bbptr 析构时，仅仅减少了 B 对象的引用计数，从 2 变为 1，但 B 对象并没有被销毁，因为 aaptr->bptr 仍然持有它。
   • 随后 aaptr 析构，导致 A 对象的引用计数从 1 变为 0，从而触发 A 的析构函数，输出 “A delete”。
   • 在 A 的析构过程中，其成员变量 bptr 被析构，从而使 B 对象的引用计数从 1 减为 0。此时，B 对象的析构函数被调用，输出 “B delete”。

3️⃣ unique_ptr 独占式智能指针（替换 auto_ptr）

unique_ptr 是一个独占型的智能指针，它不允许其他的智能指针共享其内部的指针：

• 不允许通过赋值将一个 unique_ptr 拷贝/赋值给另外一个 unique_ptr
• 但是允许通过函数返回给其他的 unique_ptr 或者通过 std::move 来转移到其他的 unique_ptr，这样的话它本身就不再拥有原指针的所有权了

与 shared_ptr 相比，unique_ptr 除了独占性的特点外，还能够指向一个数组：std::unique_ptr<int []> p(new int[10]);。

shared_ptr 与 unique_ptr 的使用需要根据场景决定，如果希望只有一个智能指针管理资源或者管理数组就使用 unique_ptr，如果希望使用多个智能指针管理同一个资源就使用 shared_ptr。

🔥 实现简易的 shared_ptr

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

#include <memory>

template<typename T>
class smartPtr {
private:
    T *_ptr;
    size_t* _count;

public:
    smartPtr(T *ptr = nullptr):_ptr(ptr) {
        if (_ptr) {
            _count = new size_t(1);
        } else {
            _count = new size_t(0);
        }
    }

    smartPtr(const smartPtr &ptr) {
        if (this != &ptr) {
            this->_ptr = ptr._ptr;
            this->_count = ptr._count;
            ++(*this->_count)   ;
        }
    }

    smartPtr& operator=(const smartPtr &ptr) {
        if (this->_ptr == ptr._ptr)
            return *this;

        if (this->_ptr) {
            --(*this->_count);
            if (this->_count == 0) {
                delete this->_ptr;
                delete this->_count;
            }
        }

        this->_ptr = ptr._ptr;
        this->_count = ptr._count;
        ++(*this->_count);

        return *this;
    }

    ~smartPtr() {
        --(*this->_count);
        if (0 == *this->_count) {
            delete this->_ptr;
            delete this->_count;
        }
    }

    size_t use_count() {
        return *this->_count;
    }

    T& operator*() {
        assert(this->_ptr == nullptr);
        return *(this->_ptr);
    }

    T* operator->() {
        assert(this->_ptr == nullptr);
        return this->_ptr;
    }
};

21. shared_ptr 的实现，shared_ptr 一定不会导致内存泄漏吗？

std::shared_ptr 的实现基于引用计数，每个 shared_ptr 实例持有一个指向控制块的指针，控制块中包含引用计数和所管理对象的指针。 当 shared_ptr 的引用计数降为零时，控制块会删除所管理的对象。 然而，shared_ptr 并非在所有情况下都能防止内存泄漏。 当存在循环引用时，shared_ptr 的引用计数永远不会降为零，导致内存无法被释放，从而引发内存泄漏。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <memory>

class A;
class B;

class A {
public:
    std::shared_ptr<B> b;
};

class B {
public:
    std::shared_ptr<A> a;
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    a->b = b;
    b->a = a;
    // 此时，a 和 b 相互持有对方的 shared_ptr，形成循环引用
    // 程序结束时，a 和 b 的引用计数都不会降为零，导致内存泄漏
    return 0;
}

为了解决循环引用问题，可以使用 std::weak_ptr，它是一种不增加引用计数的智能指针。 std::weak_ptr 用于打破循环引用，避免内存泄漏。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <memory>

class A;
class B;

class A {
public:
    std::weak_ptr<B> b; // 使用 weak_ptr 打破循环引用
};

class B {
public:
    std::shared_ptr<A> a;
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    a->b = b;
    b->a = a;
    // 此时，a 和 b 之间的循环引用被 weak_ptr 打破
    // 程序结束时，a 和 b 的引用计数会降为零，内存会被正确释放
    return 0;
}

或者如果在类之间的引用是单向的（即不会形成循环引用），可以考虑使用 std::unique_ptr。std::unique_ptr 不会引起引用计数问题，因为它是独占的，每个对象只有一个拥有者。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <memory>

class A;
class B;

class A {
public:
    std::unique_ptr<B> b; // 改为 unique_ptr
};

class B {
public:
    std::shared_ptr<A> a;
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    a->b = std::move(b); // 转移所有权
    // 使用 unique_ptr 的情况下，没有循环引用问题
    return 0;
}

22. STL 中 vector、list、map 的底层原理实现和适用场景？

关于 STL 库中所有的结构的底层实现原理：https://zhuanlan.zhihu.com/p/542115773

顺带了解了 set、map、unordered_map、unordered_set 之间区别：

• set、map：底层使用红黑树实现，有序，插入、查找、删除的时间复杂度为 $O(logn)$
  • 优点：有序性，内部实现红黑树使得很多操作都在 $O(logn)$ 时间复杂度下完成
  • 缺点：空间占用率高，需要额外保存父节点、孩子节点和红/黑性质
• unordered_set、unordered_map：底层使用哈希表实现，无序，查找的时间复杂度为 $O(1)$
  • 优点：因为内部实现了哈希表，因此其查找速度非常的快
  • 缺点：哈希表的建立比较费时

1️⃣ vector 动态数组

• vector 底层是动态数组，元素连续存储在堆上
• 自动扩容机制：
  • vector 采用几何增长策略（通常是 2 倍扩容）
  • 当 size() == capacity() 时，会申请更大的内存空间，然后拷贝旧数据到新空间
  • 由于 realloc 可能导致数据搬移，push_back() 的均摊时间复杂度为 $O(1)$，但最坏情况 $O(n)$（扩容时）
• ❓所以有可能 vector 的插入操作可能导致迭代器失效：因为 vector 动态增加大小时，并不是在原空间后增加新空间，而是以原大小两倍在开辟另外一片较大空间，然后将内容拷贝过来，并释放原有空间，所以迭代器失效。

适用场景：

✅ 高效的随机访问（O(1)）。
✅ 批量尾部插入/删除（push_back()）。
❌ 不适合频繁插入/删除中间元素（O(n)）。
❌ 扩容会导致数据搬移（不适合超大数据集）。

2️⃣ list 双向链表

• list 底层是双向链表，每个节点存储数据和两个指针
• 插入和删除操作非常高效，不影响其他元素
• 不支持随机访问，必须顺序遍历才能找到某个元素 $O(n)$
• 不会发生扩容问题，适合频繁插入/删除的场景

适用场景：

✅ 高效插入/删除（O(1)，特别是中间位置）。
✅ 不关心随机访问，仅需遍历。
❌ 不适合频繁随机访问（O(n)）。
❌ 额外的指针开销（内存占用比 vector 高）。

3️⃣ map 红黑树

• map 底层实现是红黑树（Red-Black Tree），一种自平衡二叉搜索树
• key 是有序的
• 插入、删除、查找 $O(logn)$，因为树的高度是 $O(logn)$
• 迭代遍历按照 key 顺序进行

适用场景：

✅ 需要有序存储的数据结构（默认按照 key 递增）。
✅ 需要高效查找、插入、删除（O(log n)）。
❌ 不适合频繁变更 key（因为 key 作为 BST 节点的一部分）。
❌ 遍历效率比 unordered_map 低（有序存储开销大）。

23. 菱形继承会出现二义性问题，C++ 中如何解决这个问题？

❓镜像问题：一个派生类继承两个父类，这两个父类同时有一个共同基类，如果你去调用两个父类的基类对象函数，会有问题吗？怎么解决？

注：在 Java 中，由于 Java 不支持多重继承，所以菱形继承问题也不存在。 Java 使用接口来替代多重继承，接口只定义了一些抽象的方法，而没有具体的实现。

这是 C++ 多重继承造成的菱形继承问题，如果一个派生类继承了两个拥有相同基类的父类，那么基类的成员会被继承两次，这会导致 “二义性问题” 和 “冗余存储”。

❌ 编译错误！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <iostream>

class Base {
public:
    void show() { std::cout << "Base::show()" << std::endl; }
};

class Parent1 : public Base {};  // 继承自 Base
class Parent2 : public Base {};  // 继承自 Base

// 多重继承
class Derived : public Parent1, public Parent2 {};

int main() {
    Derived d;
    d.show();  // ⚠️ 编译错误：二义性
    return 0;
}

1️⃣ 解决方案一：使用作用域解析符

缺点：Derived 仍然包含 两个 Base 实例，数据冗余，而且每次调用 show() 需要手动指定作用域，不优雅。

1
2
3
4
5
6

int main() {
    Derived d;
    d.Parent1::show();  // 访问 Parent1 继承的 Base
    d.Parent2::show();  // 访问 Parent2 继承的 Base
    return 0;
}

2️⃣ 使用虚继承｜最佳方案 ✅

虚继承是为了让某个类做出声明，承诺愿意共享它的基类，这个被共享的基类就是虚基类

多继承除了造成命名冲突，还有数据冗余等问题，为了解决这些问题，C++ 引进了「虚继承」

这样能够保证 Derived 只含有一个唯一的 Base 实例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <iostream>

class Base {
public:
    void show() { std::cout << "Base::show()" << std::endl; }
};

// 让 Parent1 和 Parent2 进行虚继承
class Parent1 : virtual public Base {};
class Parent2 : virtual public Base {};

// 继承 Parent1 和 Parent2
class Derived : public Parent1, public Parent2 {};

int main() {
    Derived d;
    d.show();  // ✅ 现在可以直接调用，不会有二义性
    return 0;
}

不使用 virtual 时

• Derived 会有两个 Base 对象，导致二义性问题。
• 内存浪费（两个 Base 子对象的冗余）。

使用 virtual 继承

• Parent1 和 Parent2 不会各自包含 Base 的副本，而是共享同一个 Base 实例。
• Derived 只会有一个 Base 实例，所以调用 show() 时不会有二义性。

🔥虚继承是为了让某个类做出声明，承诺愿意共享它的基类，这个被共享的基类就是虚基类！

使用虚继承解决菱形继承中的命名冲突问题

🔥 虚继承在 C++ 标准库中的实际应用

再看个虚继承的例子，彻底明白虚继承：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include <iostream>
using namespace std;

class Base0 {
public:
    int var0;
    void fun0() { cout << "Member of Base0" << endl; }
};

class Base1 : virtual public Base0 {
public:
    int var1;
};

class Base2 : virtual public Base0 {
public:
    int var2;
};

class Derived : public Base1, public Base2 {
    //定义派生类Derived 
public:
    int var;
    void fun() {
        cout << "Member of Derived" << endl;
    }
};

int main() {
    Derived d;
    d.var0 = 2; //直接访问虚基类的数据成员
    d.fun0();   //直接访问虚基类的函数成员
    return 0;
}

⁉️将 Base0 类作为它的直接派生类 Base1 和 Base2 的虚基类，即 Base1 虚继承 Base0，Base2 虚继承 Base0。之后 Derived 再继承 Base1 和 Base2，在 Derived 对象里面就不会存在 Base0 类的双份的成员。

Derived 对象包含着从 Base1 继承的成员和从 Base2 继承的成员，但是从 Base1 继承的 Base0 成员实际上这个地方放了一个指针，这个指针指向真正的 Base0 成员，Base2 的也是。所以实质上从最远的基类继承过来的成员，在最远派生类中只有一份。

24. 动态编译 vs 静态编译，动态链接 vs 静态链接？

在编译和链接过程中，我们可以分为以下几个阶段：

• 编译（Compilation）：将源代码 .cpp 转换为目标文件 .o。
• 链接（Linking）：将多个目标文件和库组合成一个可执行文件。

(1) 静态编译 vs 动态编译

• 静态编译（Static Compilation）：所有代码都在 编译时 确定，并编译成完整的 可执行文件。
• 动态编译（Dynamic Compilation）：代码可以在 运行时动态生成或加载，例如 JIT（Just-In-Time）编译。

(2) 静态链接 vs 动态链接

• 静态链接（Static Linking）：
  • 编译时 将所有 库的代码 直接复制到可执行文件中。
  • 生成的可执行文件 较大，但不依赖外部动态库。
• 动态链接（Dynamic Linking）：
  • 运行时按需加载动态库（.so/.dll）。
  • 可执行文件 更小，可以更新动态库而无需重新编译整个程序。

25. 拷贝构造函数与 operator=() 的区别？

在 C++ 中，拷贝构造函数 和 赋值运算符 (operator=) 主要区别在于 调用时机和行为。

(1) 拷贝构造函数

• 作用：用于创建新对象时，用已有对象进行初始化。
• 调用时机：
  1. 用已有对象初始化新对象
  2. 函数按值传递参数
  3. 函数返回对象（优化前的 NRVO）

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class MyClass {
public:
    int data;
    MyClass(int d) : data(d) {}
    
    // 拷贝构造函数
    MyClass(const MyClass& other) {
        data = other.data;
        std::cout << "Copy Constructor\n";
    }
};

int main() {
    MyClass obj1(10);
    MyClass obj2 = obj1;  // 拷贝构造
}

输出：

1
2

CopyEdit
Copy Constructor

(2) 赋值运算符 operator=

• 作用：用于 已有对象之间赋值，即一个对象的内容 被另一个对象替换。
• 调用时机：
  • 两个已存在对象进行赋值时
  • 🔥 a = b; 而不是 MyClass a = b;

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class MyClass {
public:
    int data;
    MyClass(int d) : data(d) {}

    // 赋值运算符
    MyClass& operator=(const MyClass& other) {
        if (this == &other) return *this;  // 防止自赋值
        data = other.data;
        std::cout << "Assignment Operator\n";
        return *this;
    }
};

int main() {
    MyClass obj1(10);
    MyClass obj2(20);
    obj2 = obj1;  // 赋值运算符调用
}

输出：

1

Assignment Operator

(3) 主要区别

(4) 特殊情况

避免自赋值

1

if (this == &other) return *this;

支持链式赋值

1
2
3
4
5
6

MyClass& operator=(const MyClass& other) {
    this->data = other.data;
    return *this;
}

obj1 = obj2 = obj3;  // 链式赋值

26. 右值引用的主要用途？

等价于问题：什么情况下会用到右值引用。

右值引用是 C++11 引入的新特性，用于实现移动语义和完美转发：

1️⃣ 实现移动语义

在传统 C++ 中，对象的赋值和传递通常涉及深拷贝，这会带来性能开销，通过右值引用，可以触发移动构造函数将资源所有权从一个对象转移到另一个对象（将资源从临时对象移动到新对象），无需深拷贝，避免了不必要的复制和销毁操作。

当一个临时对象或不再使用的资源，需要被高效地“移动”而不是拷贝时，就用到右值引用

1
2

std::vector<int> v1 = {1,2,3};
std::vector<int> v2 = std::move(v1); // 此时v1内容转移给v2，避免深拷贝

2️⃣ 完美转发

用于函数模板的完美转发，将参数以原始的形式传递给下一个函数，避免了不必要的复制和类型转换。

模板中利用万能引用（forwarding reference）配合std::forward实现任意类型参数的原始性质传递

1
2
3
4

template<typename T>
void wrapper(T&& arg) {
    func(std::forward<T>(arg));  // 原样传递arg（左值传左值，右值传右值）
}

针对「完美转发」，请看如下例子

假设我们有两个重载的函数 process，一个接收左值引用，另一个接收右值引用：

1
2
3
4
5
6
7

void process(int& i) {
    std::cout << "左值引用处理: " << i << std::endl;
}

void process(int&& i) {
    std::cout << "右值引用处理: " << i << std::endl;
}

现在，我们希望编写一个模板函数 forwarding，它能够将传入的参数完美地转发给 process，即保持参数的左值或右值属性不变。

• 不使用完美转发的情况：如果我们直接在模板函数中调用 process(param)，无论传入的是左值还是右值，param 在函数内部都是一个左值，这会导致总是调用接收左值引用的 process 函数：

1
2
3
4
5

template <typename T>
// void forwarding(T param) 也是如此，即右值无法传递进去导致参数不匹配
void forwarding(T&& param) {
    process(param); // param 被视为左值，即右值无法传递进去导致参数不匹配
}

• 使用完美转发的情况：为了实现完美转发，我们需要：
  • 使用万能引用：在模板参数中使用 T&&，使得函数能够同时接收左值和右值。
  • 为了解决这个问题，引入了 std::forward, 将模板函数改成如下形式就可以了, forward 被称为完美转发，根据参数的类型（左值或右值）进行条件转发，保持其原有的值类别。语义上：数据是左值就转发成左值，右值就转发成右值，哪怕在万能引用中也是如此。

实现如下：

1
2
3
4
5
6

#include <utility> // std::forward

template <typename T>
void forwarding(T&& param) {
    process(std::forward<T>(param));
}

测试代码：

1
2
3
4
5
6
7

int main() {
    int a = 10;
    forwarding(a);        // 传入左值
    forwarding(20);       // 传入右值
    forwarding(std::move(a)); // 将左值转换为右值
    return 0;
}

输出结果：

1
2
3

左值引用处理: 10
右值引用处理: 20
右值引用处理: 10

补充：左值引用（&）与右值引用（&&）

在 C++11 中提出了右值引用，作用是为了和左值引用区分开来，其作用是: 右值引用限制了其只能接收右值，可以利用这个特性从而提供重载，这是右值引用有且唯一的特性，限制了接收参数必为右值, 这点常用在 move construct 中，告诉别人这是一个即将消失的对象的引用，可以瓜分我的对象东西，除此之外，右值引用就没有别的特性了。

1
2
3
4
5

class Base{
public:
      Base(const Base& b){...} //copy construct 
      Base(Base&& b){...}      //move construct
};

然后，一个右值引用变量在使用上就变成了左值，已经不再携带其是右引用这样的信息，只是一个左值，这就是引用在c++中特殊而且复杂的一点，引用在 c++ 中是一个特别的类型，因为它的值类型和变量类型不一样, 左值/右值引用变量的值类型都是左值, 而不是左值引用或者右值引用。

1
2
3
4
5
6
7

int val = 0;
int& val_left_ref = val;      
int&& val_right_ref = 0;

// 引用必须在初始化时绑定到一个有效的对象，且绑定后无法更改
val_left_ref = 0;      // val_left_ref 此时是 int，而不是 int&
val_right_ref = 0;     // val_right_ref 此时是 int， 而不是 int&&

🔥 补充：万能引用（T&&）

模板中的 T&& 不同于普通的右值引用，而是万能引用，其既能接收左值又能接收右值。

1
2
3
4
5
6
7
8
9
10
11
12
13

template<typename T>
void emplace_back(T&& arg) {
}

Class Base {
};

int main() {
    Base a;
    emplace_back(a);      // ok
    emplace_back(Base()); // also ok
    return 0;
}

这种特性常用在容器元素的增加上，利用传参是左值还是右值进而在生成元素的时候调用 copy construct 还是 move construct，比如说 vector 的 emplace_back。

所以为什么需要 std::forwad？

模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，我们希望能够在传递过程中保持它的左值或者右值的属性, 如果不使用 forward，直接按照下面的方式写就会导致问题。

1
2
3
4
5

template <typename T>
// void forwarding(T param) 也是如此，即右值无法传递进去导致参数不匹配
void forwarding(T&& param) {
    process(param); // param 被视为左值，即右值无法传递进去导致参数不匹配
}

所以为了解决这个问题引入了 std::forward，将模板函数改成如下形式，即可实现完美转发：

1
2
3
4

template <typename T>
void forwarding(T&& param) {
    process(std::forward<T>(param));
}

27. C++ 中有哪些锁？

更多参考：如何避免死锁、介绍几种经典的锁

• 从种类上分：普通锁、读写锁、递归锁
• 从实现上分：互斥锁、自旋锁、信号量、条件变量

互斥锁（Mutex）

🌟互斥锁是在抢锁失败的情况下主动放弃 CPU 进入睡眠状态直到锁的状态改变时再唤醒，而操作系统负责线程调度，为了实现锁的状态发生改变时唤醒阻塞的线程或者进程，需要把锁交给操作系统管理，所以互斥锁在加锁操作时涉及上下文的切换。互斥锁实际的效率还是可以让人接受的，加锁的时间大概 100ns 左右，而实际上互斥锁的一种可能的实现是先自旋一段时间，当自旋的时间超过阀值之后再将线程投入睡眠中，因此在并发运算中使用互斥锁（每次占用锁的时间很短）的效果可能不亚于使用自旋锁。

• 互斥锁（Mutex）：用于保护共享资源，确保任一时刻只有一个线程访问资源。
• 信号量（Semaphore）：一种特殊的计数器，可以同时允许多个线程访问有限的共享资源。

互斥锁相当于信号量初值为 1 的特殊情况；信号量允许多个线程并发访问资源（初值 > 1）。

1
2
3
4
5
6

std::mutex mtx;

void foo() {
    std::lock_guard<std::mutex> lock(mtx);
    // 临界区操作
}

应用场景：

• 保护关键资源（如共享变量）
• 控制资源的访问量

条件锁/条件变量（Condition Variable）

🌟互斥锁一个明显的缺点是他只有两种状态：锁定和非锁定。而条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足，他常和互斥锁一起使用，以免出现竞态条件。当条件不满足时，线程往往解开相应的互斥锁并阻塞线程然后等待条件发生变化。一旦其他的某个线程改变了条件变量，他将通知相应的条件变量唤醒一个或多个正被此条件变量阻塞的线程。总的来说互斥锁是线程间互斥的机制，条件变量则是同步机制。

条件变量用于线程间通信，当某个条件满足后再唤醒等待线程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void wait_thread() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [](){ return ready; });  // 等待条件满足
    // 执行后续任务
}

void signal_thread() {
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;  // 修改条件
    }
    cv.notify_one();  // 通知等待线程
}

应用场景：

• 生产者-消费者模型
• 线程等待某条件满足才能执行

自旋锁（Spin Lock）

🌟如果线程无法取得锁，线程不会立刻放弃 CPU 时间片，而是一直循环尝试获取锁，直到获取为止。如果别的线程长时期占有锁那么自旋就是在浪费 CPU 做无用功，但是自旋锁一般应用于加锁时间很短的场景，这个时候效率比较高。

线程在等待资源时不会挂起或睡眠，而是不断循环检测锁状态（忙等待）

1
2
3
4
5
6
7
8
9
10
11
12

#include <atomic>

class SpinLock {
    std::atomic_flag lock_ = ATOMIC_FLAG_INIT;
public:
    void lock() {
        while (lock_.test_and_set(std::memory_order_acquire));
    }
    void unlock() {
        lock_.clear(std::memory_order_release);
    }
};

应用场景：

• 临界区非常短小
• 多核 CPU、短暂等待资源的情况

读写锁（Read-Write Lock）

允许多个线程同时进行读操作，但写操作必须独占访问。

特点：

• 读锁共享：多个读线程并发执行
• 写锁独占：写线程执行时不能有其他读、写线程存在

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// C++17 的 shared_mutex
#include <shared_mutex>

std::shared_mutex rw_mutex;
int shared_data = 0;

void reader() {
    std::shared_lock<std::shared_mutex> lock(rw_mutex);
    // 读取shared_data
}

void writer() {
    std::unique_lock<std::shared_mutex> lock(rw_mutex);
    shared_data++;  // 写操作
}

应用场景：大量读、少量写的场景（如配置文件读取，缓存数据等）

递归锁（Recursive Mutex）

同一线程可以多次获取同一个锁，但必须释放相同次数后才完全解锁。

特点：

• 避免了同一线程递归调用中因反复加锁而引起的死锁问题
• 相比普通锁，多了一些额外开销

1
2
3
4
5
6
7
8
9
10
11

#include <mutex>

std::recursive_mutex r_mutex;

void recursive_function(int n) {
    std::lock_guard<std::recursive_mutex> lock(r_mutex);
    if (n > 0) {
        recursive_function(n - 1); // 递归调用
    }
    // 临界区操作
}

应用场景：函数递归调用或函数间的相互调用都可能再次尝试获取同一锁

28. 如何用 C++ 实现一个读写锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

#include <mutex>
#include <condition_variable>

class RWLock {
private:
    std::mutex mtx_;
    std::condition_variable cv_;
    int readers_;          // 正在读取的线程数量
    int writers_waiting_;  // 等待写入的线程数量
    bool writing_;         // 当前是否有写线程

public:
    RWLock() : readers_(0), writers_waiting_(0), writing_(false) {}

    // 读锁定
    void lock_read() {
        std::unique_lock<std::mutex> lock(mtx_);
        // 当有写操作进行中或等待中的写操作时等待
        cv_.wait(lock, [this]() {
            return !writing_ && writers_waiting_ == 0;
        });
        ++readers_;
    }

    // 读解锁
    void unlock_read() {
        std::unique_lock<std::mutex> lock(mtx_);
        if (--readers_ == 0) {
            cv_.notify_all();
        }
    }

    // 写锁定
    void lock_write() {
        std::unique_lock<std::mutex> lock(mtx_);
        ++writers_waiting_;
        cv_.wait(lock, [this]() { return !writing_ && readers_ == 0; });
        --writers_waiting_;
        writing_ = true;
    }

    // 写解锁
    void unlock_write() {
        std::unique_lock<std::mutex> lock(mtx_);
        writing_ = false;
        cv_.notify_all();
    }
};

使用实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#include <iostream>
#include <thread>
#include <vector>
#include <chrono>

RWLock rwlock;
int shared_data = 0;

void reader(int id) {
    rwlock.lock_read();
    std::cout << "Reader " << id << " reads value: " << shared_data << "\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    rwlock.unlock_read();
}

void writer(int id) {
    rwlock.lock_write();
    ++shared_data;
    std::cout << "Writer " << id << " updated value to: " << shared_data << "\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(150));
    rwlock.unlock_write();
}

int main() {
    std::vector<std::thread> threads;

    // 启动读线程
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(reader, i);
    }

    // 启动写线程
    for (int i = 0; i < 3; ++i) {
        threads.emplace_back(writer, i);
    }

    for (auto &t : threads) {
        t.join();
    }

    return 0;
}

• 以上实现倾向于写优先（有写操作等待时，不允许新的读操作）。

• 可以通过修改逻辑实现读优先或公平性策略，例如：

  • 去除 writers_waiting_ == 0 的约束实现读优先。
  • 更复杂的公平策略则需要额外的数据结构管理等待顺序。

• 实际应用中，推荐使用现有的成熟实现，例如：

  • C++17 起的标准库提供的 std::shared_mutex（标准的读写锁实现）：

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <shared_mutex>

std::shared_mutex rw_mutex;

void reader() {
    std::shared_lock lock(rw_mutex); // 读锁
    // 读取数据
}

void writer() {
    std::unique_lock lock(rw_mutex); // 写锁
    // 修改数据
}

29. 引用和指针的区别，是否能加 const，作用是什么？

指针：存储变量的内存地址，可以为空（nullptr），需要通过解引用操作符*访问指针指向的值。指针可以在运行时重新指向不同的对象。指针可以有多级。

引用：是变量的别名，必须在初始化时绑定到一个有效的对象，且绑定后无法更改。引用不能为空，始终指向初始化时绑定的对象。引用只有一级。

const修饰：

• 指针：const可以修饰指针本身或指针指向的对象。
  • 指向常量的指针：const int* ptr / int const* ptr 表示指针指向的值是常量，不能通过该指针修改值，但可以改变指针本身的指向。
  • 常量指针：int* const ptr表示指针本身是常量，不能改变指针的指向，但可以通过指针修改指向的值。
  • 指向常量的常量指针：const int* const ptr表示指针本身和指针指向的值都是常量，既不能修改指针的指向，也不能修改指向的值。
• 引用：引用本身不能是常量，但可以引用一个常量对象。
  • 指向常量的引用：const int& ref表示引用绑定到一个常量值，不能通过该引用修改值。常量引用常用于函数参数，允许函数接受常量或非常量实参而不进行拷贝。

30. 哈希桶满了怎么办？

哈希表（如 unordered_map）在插入元素后，如果负载因子（load_factor，即元素个数/桶数量）超过阈值（通常是1.0左右），将触发扩容（rehash）：

• 重新分配更多的 bucket（一般是原来容量的2倍或更多）。
• 重新计算元素位置（rehash），将原有元素重新插入新的 bucket 中。
• 扩容时性能开销较大 $O(n)$。

因此，为了减少扩容次数，可以提前使用 reserve 或 rehash 提高效率。

1
2

unordered_map<int, int> umap;
umap.reserve(1000); // 提前预留空间，避免频繁扩容

31. AVL vs. 红黑树

AVL 树（严格平衡二叉树）：

• 左右子树高度差绝对不能超过1。
• 插入删除频繁时，旋转调整成本较高（严格的平衡限制）。
• 查询效率略优于红黑树（更平衡），但插入删除的开销稍高。
• 适用于对查询操作要求极高，但修改频率较低的场景。

红黑树（弱平衡二叉树）：

• 平衡规则相对宽松，允许一定的高度差异。
• 插入删除操作旋转调整较少，综合效率更高。
• 广泛应用于 C++ 中的 STL map、set 等数据结构中。
• 更适用于插入删除较频繁的场景。

如果场景读多写少，要求非常严格的平衡，AVL 树适合。

如果场景写操作频繁，对读写整体性能要求更均衡，红黑树更合适。

32. move() 底层原理

std::move() 的底层原理实际上非常简单，它本身并不真正执行移动，而是一个类型转换工具，用来将左值（lvalue）强制转换为右值引用（rvalue reference），从而允许移动语义发生。

一、源码分析（典型实现）

在C++标准库中，std::move() 一般可实现为如下模板函数：

1
2
3
4

template <typename T>
constexpr std::remove_reference_t<T>&& move(T&& arg) noexcept {
    return static_cast<std::remove_reference_t<T>&&>(arg);
}

上述代码可以解析为：

• T&& arg：这是一个万能引用（forwarding reference），能够绑定到左值或右值。
• remove_reference_t<T>：移除模板参数 T 可能带有的引用限定符，保证返回的确实是一个右值引用类型。
• static_cast<remove_reference_t<T>&&>：进行强制类型转换，将传入参数从左值转换为右值引用。

二、原理分析

std::move() 本身没有发生移动动作，它只是一个类型转换工具：

• 转换前：变量（对象）本身是左值，只能调用拷贝构造函数或拷贝赋值。
• 转换后：变量变为右值引用，具备调用移动构造函数或移动赋值的资格。

本质是告诉编译器：“这里的对象我不再需要了，可以放心进行资源的移动操作。”

例如：

1
2
3

std::string str1 = "Hello";
std::string str2 = std::move(str1);  
// str1 的内容被“窃取”，str2 可能直接接管内部缓冲区，而非复制

三、实际的“移动”如何发生？

实际的移动（资源转移）是通过被调用对象的移动构造函数或移动赋值运算符实现的，而不是通过std::move()实现：

例如，std::string 的移动构造函数的伪代码：

1
2
3
4
5
6
7

// 移动构造函数示意
string(string&& other) noexcept {
    data_ = other.data_;
    size_ = other.size_;
    other.data_ = nullptr;  // 原对象失去所有权
    other.size_ = 0;
}

std::move() 提供右值引用，而真正资源转移的逻辑，由类的移动构造或移动赋值完成。

四、注意事项

• std::move()不会清空对象：
  • 调用std::move()后的对象处于有效但未指定状态（valid but unspecified state），通常对象变为空或默认状态。
  • 你可以继续赋值或析构，但不应该继续访问对象原先的资源。
• 移动语义要求类本身支持移动构造或移动赋值：
  • 若类本身未定义移动构造或移动赋值，调用std::move() 仍然可能降级成拷贝。

std::move() 本身几乎没有开销，它只是一个编译期的类型转换工具，真正的开销和行为由类型本身的移动构造和赋值函数决定。

33. 可执行文件加载到内存里，其内存布局是怎样的？

当可执行文件（如Linux ELF格式）加载到内存中运行时，其典型内存布局为：

从低地址到高地址顺序：

• 代码段：函数指令
• 数据段：全局或静态变量（初值不为0）
• BSS段：全局或静态变量（初值为0或未初始化）
• 堆段：动态内存（malloc/new）
• 栈段：函数调用的局部变量、调用返回地址、临时变量等
• 文件映射段：包括动态库、共享内存等，从低地址开始向上增长（跟硬件和内核版本有关）

34. 宏定义与函数的区别？

• 宏在预处理阶段完成替换，之后被替换的文本参与编译，相当于直接插入了代码，运行时不存在函数调用，执行起来更快；函数调用在运行时需要跳转到具体调用函数。
• 宏定义属于在结构中插入代码，没有返回值；函数调用具有返回值。
• 宏定义参数没有类型，不进行类型检查；函数参数具有类型，需要检查类型。

35. 宏定义 define 与 typedef 的区别？

• 宏主要用于定义常量及书写复杂的内容；typedef 主要用于定义类型别名。
• 宏替换发生在编译阶段之前（预处理阶段），属于文本插入替换；typedef 是编译的一部分。
• 宏不检查类型；typedef 会检查数据类型。
• 注意对指针的操作，typedef char * p_char 和 #define p_char char * 区别巨大。

36. 变量声明与定义的区别？

• 声明仅仅是把变量的声明的位置及类型提供给编译器，并不分配内存空间
• 定义要在定义的地方为其分配存储空间

相同变量可以在多处声明（外部变量 extern），但只能在一处定义。

37. strlen 和 sizeof 的区别？

• sizeof 参数可以是任何数据的类型或者数据（sizeof 参数不退化）
• strlen 参数只能是字符指针且结尾是’\0’的字符串

1
2
3
4
5
6

int main() {
    const char* str = "Hello World";
    cout << sizeof(str) << endl;    // 指针字节：8
    cout << strlen(str) << endl;    // 字符串长度(不包含'\0')：11
    return 0;
}

38. final 和 override

• override：指定了子类的这个虚函数是重写的父类的，如果你名字不小心打错了的话，编译器是不会编译通过的
• final：当某个类不希望被继承，或者某个虚函数不希望被重写，那么可以在类名和虚函数后添加 final 关键字，添加 final 关键字后被继承或重写，编译器会报错

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Base {
    virtual void foo();
};
 
class A : public Base {
    void foo() final; // foo 被 override 并且是最后一个 override，在其子类中不可以重写
};

// 指明 B 是不可以被继承的
class B final : public A {
    void foo() override; // Error: 在 A 中已经被 final 了
};

// Error: B is final
class C : public B {
};

39. C 与 C++ 的类型安全

类型安全很大程度上可以等价于内存安全，类型安全的代码不会试图访问自己没被授权的内存区域。“类型安全”常被用来形容编程语言，其根据在于该门编程语言是否提供保障类型安全的机制；有的时候也用“类型安全”形容某个程序，判别的标准在于该程序是否隐含类型错误。

类型安全的编程语言与类型安全的程序之间，没有必然联系。好的程序员可以使用类型不那么安全的语言写出类型相当安全的程序，相反的，差一点儿的程序员可能使用类型相当安全的语言写出类型不太安全的程序。绝对类型安全的编程语言暂时还没有。

C 的类型安全

C 只在局部上下文中表现出类型安全，比如试图从一种结构体的指针转换成另一种结构体的指针时，编译器将会报告错误，除非使用显式类型转换。然而，C 中相当多的操作是不安全的。以下是两个十分常见的例子：

1️⃣ printf 格式输出：下述代码中，使用 %d 控制整型数字的输出，没有问题，但是改成 %f 时，明显输出错误，再改成 %s 时，运行直接报 segmentation fault 错误

1
2
3
4
5
6

#include <stdio.h>
int main() {
    printf("%d\n", 10);    // 10
    printf("%f\n", 10);    // 0.00
    return 0;
}

2️⃣ malloc 函数返回值：malloc 是 C 中进行内存分配的函数，它的返回类型是 void* 即空类型指针，常常有这样的用法 char* pStr = (char*)malloc(100 * sizeof(char))，这里明显做了显式的类型转换。类型匹配尚且没有问题，但是一旦出现 int* pInt = (int*)malloc(100 * sizeof(char)) 就很可能带来一些问题，而这样的转换 C 并不会提示错误。

C++ 类型安全

如果 C++ 使用得当，它将远比 C 更有类型安全性。相比于 C 语言，C++ 提供了一些新的机制保障类型安全：

• 操作符 new 返回的指针类型严格与对象匹配，而不是 void*
• C 中很多以 void* 为参数的函数可以改写为 C++ 模板函数，而模板是支持类型检查的
• 引入 const 关键字代替 #define constants，它是有类型、有作用域的，而 #define constants 只是简单的文本替换
• 一些 #define 宏可被改写为 inline 函数，结合函数的重载，可在类型安全的前提下支持多种类型，当然改写为模板也能保证类型安全
• C++ 提供了 dynamic_cast 关键字，使得转换过程更加安全，因为 dynamic_cast 比 static_cast 涉及更多具体的类型检查

40. 内联函数 inline 和宏定义 define 的区别？

• 在使用时，宏只做简单字符串替换（预处理，即编译前）；而内联函数可以进行参数类型检查（编译时），且具有返回值
• 内联函数在编译时直接将函数代码嵌入到目标代码中，省去函数调用的开销来提高执行效率，并且进行参数类型检查，具有返回值，可以实现重载
• 宏定义时要注意书写（参数要括起来）否则容易出现歧义，内联函数不会产生歧义
• 内联函数有类型检测、语法判断等功能，而宏没有

内联函数适用场景:

• 使用宏定义的地方都可以使用 inline 函数
• 作为类成员接口函数来读写类的私有成员或者保护成员，会提高效率

41. 什么是大小端存储，以及如何用代码判断大小端？

大端存储：字数据的高字节存储在低地址中

小端存储：字数据的低字节存储在低地址中

例如：32bit 的数字 0x12345678

所以在 Socket 编程中，往往需要将操作系统所用的小端存储的 IP 地址转换为大端存储，这样才能进行网络传输

小端模式中的存储方式为

大端模式中的存储方式为

了解了大小端存储的方式，如何在代码中进行判断呢？

1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>
using namespace std;
int main()
{
    int a = 0x1234;
    //由于 int 和 char 的长度不同，借助 int 型转换成 char 型，只会留下低地址的部分
    char c = (char)(a);
    if (c == 0x12)
        cout << "big endian" << endl;
    else if(c == 0x34)
        cout << "little endian" << endl;
}

42. C++ 中有几种类型的 new？

(1) plain new

言下之意就是普通的new，就是我们常用的new，在C++中定义如下：

1
2

void* operator new(std::size_t) throw(std::bad_alloc);
void operator delete(void *) throw();

因此 plain new 在空间分配失败的情况下，抛出异常 std::bad_alloc 而不是返回 NULL，因此通过判断返回值是否为 NULL 是徒劳的。

(2) nothrow new

nothrow new 在空间分配失败的情况下是不抛出异常，而是返回 NULL，定义如下：

1
2

void * operator new(std::size_t, const std::nothrow_t&) throw();
void operator delete(void*) throw();

(3) placement new

字节校招问题：placement new 是什么？

• 一般来说，使用 new 申请空间时，是从系统的“堆”中分配空间。申请所得的空间的位置是根据当时的内存的实际使用情况决定的。但是，在某些特殊情况下，可能需要在已分配的特定内存创建对象，这就是所谓的 “定位放置 new” （placement new）操作。 定位放置 new 操作的语法形式不同于普通的 new 操作。例如，一般都用如下语句 A* p = new A; 申请空间，而 placement new 操作则使用如下语句 A* p = new (ptr)A; 申请空间，其中 ptr 就是程序员指定的内存首地址。
• 用定位放置 new 操作，既可以在栈（stack）上生成对象，也可以在堆（heap）上生成对象，如本例就是在栈上生成一个对象。
• 优势：复用已有内存空间；
• 场景题：如果有这样一个场景，我们需要大量的申请一块类似的内存空间，然后又释放掉，比如在一个 Server 中对于客户端的请求，每个客户端的每一次上行数据我们都需要为此申请一块内存，当我们处理完请求给客户端下行回复时释放掉该内存，表面上看者符合 C++ 的内存管理要求，没有什么错误，但是仔细想想很不合理，为什么我们每个请求都要重新申请一块内存呢，要知道每一次内存的申请，系统都要在内存中找到一块合适大小的连续的内存空间，这个过程是很慢的（相对而言)，极端情况下，如果当前系统中有大量的内存碎片，并且我们申请的空间很大，甚至有可能失败。为什么我们不能共用一块我们事先准备好的内存呢？可以的，我们可以使用 placement new 来构造对象，那么就会在我们指定的内存空间中构造对象。

这种 new 允许在一块已经分配成功的内存上重新构造对象或对象数组。placement new 不用担心内存分配失败，因为它根本不分配内存，它做的唯一一件事情就是调用对象的构造函数。定义如下：

1
2

void* operator new(size_t, void*);
void operator delete(void*, void*);