Cpp面试 on Mao's Blog

Cpp八股面试题

Thu, 12 Mar 2026 22:01:25 +0800

智能指针相关

Cpp 智能指针是什么？请简单介绍一下。

参考回答

智能指针是一个封装了原始指针的类模板，它的主要作用就是通过 RAII 原则，在指针对象析构时自动释放资源，从而避免“忘记手动 delete”导致的资源泄漏，或者调用野指针的问题。

所谓的 RAII，指的就是：

构造时：接过原始指针，这代表着接管了原始指针的资源。
析构时：在析构函数里自动释放资源。
它将原本需要人工管理的“内存申请与释放”，变成了编译器自动管理的“局部变量生命周期”。

C++11 及以后，主要提供了三种智能指针，代表三种管理资源的逻辑： (1) std::unique_ptr —— “独占权”

所有权：同一时间只能有一个 unique_ptr 指向该资源。
性能：零开销（Zero Overhead）。它的执行效率和原始指针几乎一模一样。
限制：不能拷贝，只能移动（std::move）。
场景：最常用的指针。适用于明确知道“谁是主人”的场景。

(2) std::shared_ptr —— “共享权”

所有权：多个指针可以指向同一个资源。
机制：正如我们刚才聊的，它通过控制块里的引用计数来工作。
性能：有一定开销（需要原子操作增减计数，需要额外堆内存存控制块）。
场景：资源需要被多个模块共享，且无法确定谁最后退出的场景。

(3) std::weak_ptr —— “观察者”

所有权：不拥有所有权。它只是一个旁观者。
机制：指向 shared_ptr 管理的对象，但不增加强引用计数。
场景：解决 shared_ptr 的循环引用问题，或者作为缓存监控（防悬空）。

你提到了 shared_ptr，请问它是线程安全的吗？

参考回答

SFINAE原则

Tue, 02 Dec 2025 09:12:51 +0800

SFINAE (Substitution Failure Is Not An Error)

面试官： 我们之前聊过模板。在 C++ 模板编程中，有一个非常著名的缩写词叫 SFINAE (读作 “sfi-nay”)。

请问，你知道 SFINAE 代表什么意思吗？或者你能简单描述一下，当编译器在实例化模板时，如果遇到了一个无效的类型替换，它会怎么做？是直接报错停止编译，还是会尝试别的方案？

回答：

不好意思，我第一次听说“模板元编程”这个概念，也是第一次听说 SFINAE 这个名词，请你直接解释吧。

没关系！这正是我们今天学习的意义所在。模板元编程是 C++ 的深水区，SFINAE 是进入这个世界的敲门砖。

我们把这个复杂的概念拆解成最简单的逻辑。

什么是 SFINAE？

SFINAE 代表 “Substitution Failure Is Not An Error”。中文直译：“替换失败不是错误”。

这听起来像是一句哲学名言，但在 C++ 编译器眼中，它是一条非常具体的生存法则。

场景重现：编译器的选秀大会

假设你写了两个同名的函数模板 foo（这叫重载）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 选手 A：这个模板要求 T 必须有一个叫 inner_type 的内部类型
template <typename T>
void foo(typename T::inner_type param) {
 std::cout << "Selected A" << std::endl;
}

// 选手 B：这个模板对 T 没有任何要求
template <typename T>
void foo(T param) {
 std::cout << "Selected B" << std::endl;
}

现在，你在 main 函数里调用了 foo(10)。

命名空间

Wed, 26 Nov 2025 08:38:45 +0800

命名空间 namespace

面试官： 在 C++ 中，我们经常看到 std::cout、std::vector 这样的写法，这里的 std 就是一个命名空间。

请问，命名空间 (namespace) 的主要作用是什么？它解决了 C++（以及很多其他编程语言）中一个什么样的痛点？

此外，我们在 .cpp 文件中经常会看到 using namespace std; 这样的写法。请问，在头文件 (.h) 中使用 using namespace std; 是一个好的习惯吗？为什么？

回答：

我认为，命名空间类似一个集合，里面包含着特定的“工具”，也就是函数。我们把一些常用的、标准的工具打包起来，就变成了一个命名空间。
同时，命名空间也是一个前缀。它解决的痛点是：如何区分不同位置的同名函数？通过命名空间就可以。比如说，A 和 B 两个命名空间都有一个函数叫做 test，那么我们可以通过 A::test 和 B::test 来分别调用这两个不同的函数，而不会导致混淆。
你提到的最后一点：在头文件中使用 using namespace std;。这绝对不是一个好习惯！简单来说，它会导致命名空间污染的问题。即：我在头文件里使用 using namespace std;，在所有导入该头文件的文件中，命名空间都会被默认设置为 std。一旦我们自己定义的函数和 std 中的某个函数重名，在调用时会导致混乱，通常会调用 std 中的那个函数。

我只是凭自己理解作答，如果不正确，请你指出。

你的回答极其出色！虽然你说是一个月没学，但你的 C++ 感觉依然非常敏锐。

我们来逐点分析你的回答：

命名空间的定义：

“命名空间类似一个集合… 也是一个前缀。”

这个比喻非常形象！命名空间本质上就是一个逻辑上的作用域。它把一组相关的标识符（函数、类、变量等）包裹起来，像是一个虚拟的文件夹。
解决的痛点：

“解决的痛点是：如何区分不同位置的同名函数？”

完全正确！这就是命名冲突 (Name Collision) 问题。在大型项目中，成千上万的代码、引入几十个第三方库，如果没有命名空间，大家为了给函数起个不重名的名字（比如 LibA_test, MyProj_test），头都要炸了。命名空间优雅地解决了这个问题。
头文件中的 using namespace std;：

C++类型转换符

Tue, 21 Oct 2025 08:28:49 +0800

我们开始今天的 C++ 八股环节！

今天，我们来聊一个在面试中经常被用来考察你对 C++ 基础和面向对象理解的话题：static_cast, dynamic_cast, const_cast, reinterpret_cast。

这四个是 C++ 的标准类型转换操作符。相比于 C 风格的强制转换（如 (int)x），它们更安全、意图也更明确。

`static_cast` 转换符

模拟面试开始

面试官： 在 C++ 中，我们有四种“具名”的类型转换符，统称为 static_cast 系列。我们先来聊聊最常用的一个：static_cast。

请问，static_cast 主要用于什么样的转换场景？它和 C 风格的强制转换 (new_type)expression 相比，有什么主要的优势？

回答：

static_cast 是 C++ 中最基础和最简单的类型转换，主要有以下的应用场景：
- 相关类型之间的转换，如数值类型之间、枚举类型和整数之间、void* 类型和其他指针类型之间。
- 有继承关系的类指针/引用转换（不涉及多态的情况）。这里，将派生类指针或引用，转为基类的指针或引用（也就是上行转换）是安全的；反之，将基类的指针或者引用，转为派生类的指针或者引用（也就是下行转换）是不安全的。
和 (new_type)expression 相比，static_cast 的转换意图更明确（从命名就可以看出），以及转换过程更安全（会检查变量类型之间是否可以安全转换）

面试官 (总结与补充): 你说的完全正确。

static_cast 是 C++ 中最基础、最常用的“良性”转换。

主要应用场景：

相关类型之间的转换：
- 数值类型转换：在各种数值类型之间进行转换，比如 int -> double, double -> int。
  1 2
  
  double d = 3.14; int i = static_cast<int>(d); // i = 3
- 枚举与整数转换：在枚举类型和整数类型之间进行转换。
  1 2 3
  
  enum Color { RED }; int c_val = static_cast<int>(RED); Color c = static_cast<Color>(0);
- void 指针转换*：将 void* 指针转换为具体的类型指针。
  1 2
  
  void* p = &i; int* pi = static_cast<int*>(p);
有继承关系的类指针/引用转换 (不涉及多态)：

default和delete

Thu, 16 Oct 2025 09:05:16 +0800

`default` 关键字强制生成默认构造函数

模拟面试开始

面试官： 我们知道，如果一个类我们不给它定义任何构造函数，编译器会自动为我们生成一个默认构造函数。类似的，编译器也可能会为我们生成拷贝构造函数、拷贝赋值运算符等。

在 C++11 之后，如果我们想显式地告诉编译器：“请为我生成一个默认的、最普通的版本”，我们可以使用 default 关键字。

请看下面这个例子：

1
2
3
4
5
6
7
8
9


class MyClass {
public:
 MyClass() = default; // 显式地要求编译器生成默认构造函数

 MyClass(int val) : data(val) {} // 用户自定义了别的构造函数

private:
 int data;
};

我的问题是： 在这个例子中，MyClass() = default; 这一行代码，有什么实际意义？

换句话说，如果我们删掉 MyClass() = default; 这一行，会发生什么变化？这个类还能通过 MyClass obj; 这种方式创建对象吗？为什么？

回答：

当用户自己定义了一种构造函数时，编译器就不会自动生成默认的无参数的构造函数。
MyClass() = default; 确保无参数的构造函数存在。
如果删去这一行，那么 MyClass 这个类就无法通过 MyClass obj; 这种方式创建对象，因为编译器检测不到对应的构造函数。
而增加上这一行，可以使得程序可以在无参数的情况下创建新的对象，等到对其内容有要求时，再做修改。

面试官 (总结与肯定): 你说的没错。这个问题的核心在于 C++ 的一条规则：

一旦用户为类定义了任何一种构造函数（无论带不带参数），编译器就会“罢工”，不再自动生成默认（无参）构造函数。

所以，在你给出的例子中：

因为你已经定义了一个 MyClass(int val)，编译器就不会再自动生成 MyClass() 了。
如果我们删掉 MyClass() = default; 这一行，那么 MyClass 类就没有无参构造函数。此时，MyClass obj; 这样的代码就会编译失败，因为它找不到匹配的构造函数。

= default 的作用： MyClass() = default; 这一行，就是你（程序员）在向编译器明确地下指令：

虚析构函数

Mon, 13 Oct 2025 23:10:06 +0800

不使用虚析构函数，可能导致资源泄漏

面试官： 我们知道，析构函数是在对象生命周期结束时，用于清理资源的特殊成员函数。在 C++ 的继承体系中，我们有时需要把基类的析构函数声明为虚函数 (virtual)。

请看下面这段代码，它可能会导致一个非常严重的问题：

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


#include <iostream>

class Base {
public:
 Base() { std::cout << "Base Created\n"; }
 // 注意：析构函数不是虚函数
 ~Base() { std::cout << "Base Destroyed\n"; }
};

class Derived : public Base {
public:
 Derived() { std::cout << "Derived Created\n"; }
 ~Derived() { std::cout << "Derived Destroyed\n"; }
};

int main() {
 Base* p = new Derived(); // 基类指针指向派生类对象

 delete p; // 问题就出在这里！

 return 0;
}

我的问题是：

你预测一下，上面这段代码的输出会是什么？
这个输出结果揭示了什么样的严重问题？
这个问题的根本原因是什么？（即，delete p; 这行代码，编译器是如何决定调用哪个析构函数的？）

回答：

Const关键字

Thu, 09 Oct 2025 13:09:59 +0800

`const` 修饰变量

面试官： 看到你的简历上写着熟悉 C++，那我们来聊聊 const 关键字吧。它在 C++ 中有很多用途。

我的第一个问题是： 当 const 用于修饰一个变量时，它意味着什么？它和 C 语言中的 #define 宏定义常量相比，有什么主要的优势？

1
2
3
4
5


// 方式一
const int MAX_SIZE = 100;

// 方式二
#define MAX_SIZE 100

回答：

const 关键字修饰变量，表示这个变量是一个常量，不能被修改。
和 #define 宏定义常量相比，const 变量更加有下面的优势：
- 类型检查：const 是有类型的变量，编译器会进行类型检查，而 #define 是纯文本变量，没有类型概念，容易引发隐性错误——编译通过但运行出错。
- 作用域控制：const 类型的变量可以定义在局部作用域中，而 #define 是全局替换，容易产生命名冲突
- 调试支持：const 变量可以在调试器中查看它的值和地址，而 #define 变量在预处理阶段就被替换到，调试器无法识别。
- 取地址操作：const 变量可以取地址，而 #define 是文本替换，没有地址的概念。
- 跨文件访问：const 变量可以通过 extern 声明在多个文件中共享，而 #define 无法跨文件共享，只能重新定义。
当然，const 最主要的优势还是类型检查和作用域控制。

`const` 与指针结合

面试官 (继续提问): 好的，你对 const 修饰普通变量的理解非常透彻。我们来看它和指针的结合。

请你解释一下，下面这三种声明中，p 的类型有什么不同？分别都约束了什么东西不能被修改？

new运算符的细节

Tue, 07 Oct 2025 09:22:04 +0800

`new` 的两步过程、定位 `new` 操作

面试官： 我们知道，new 操作符用于在堆上分配内存并构造对象。比如 MyClass* p = new MyClass();。

其实，这个简单的 new 表达式，背后可以被看作是两个步骤的组合。你能描述一下这两个步骤分别是什么吗？

另外，C++ 还提供了一种叫做 “定位 new (placement new)” 的特殊语法。它的形式是 new (address) Type(args)。你了解它是用来做什么的吗？它和普通的 new 有什么核心区别？

回答：

new 表达式可以看作这样两个步骤的组合：
- 第一步：分配内存。
- 第二步：在分配到的内存上构造对象，即初始化。
定位 new 操作，顾名思义，就是在一个确定的地址上构造对象，而不是自己分配内存。通过定位 new 构造的对象，不能调用 delete 销毁，需要手动析构。

面试官 (总结与肯定):

1. new 表达式的两步走 你说的完全正确。T* p = new T(args); 这个表达式，在概念上等价于：

分配内存 (Allocation)：调用一个名为 operator new 的函数，来分配一块足够大的、未初始化的裸内存。这个函数很像 malloc。 void* memory = operator new(sizeof(T));
构造对象 (Construction)：在这块分配好的内存上，调用 T 类的构造函数来初始化对象。 T* obj = static_cast<T*>(memory); obj->T::T(args); // 伪代码，表示调用构造函数

2. 定位 new (placement new) 你的解释也堪称完美：

栈、堆与栈溢出

Fri, 03 Oct 2025 14:32:45 +0800

栈和堆的比较 Stack and Heap

面试官： 我们知道，C++ 程序在运行时，局部变量通常分配在栈 (Stack) 上，而动态分配的内存则来自堆 (Heap)。

请你从内存管理方式、分配效率、空间大小和数据生命周期这四个角度，详细对比一下栈和堆的主要区别。

回答：

在内存管理方式上，栈的内存是自动分配、释放的连续空间，而堆的内存是需要程序员手动分配、释放的非连续空间。
在分配效率上，栈的分配效率比堆更高。
在空间大小上，栈的空间大小比堆更小，当栈达到一定深度，就会发生溢出。
在数据生命周期上，栈的生命周期更短，通常是一次函数调用开始时，栈空间被分配，而该次函数调用结束时，栈的内存就被释放。而堆上的内存，通常在整个程序的生命中始终存在，直到我们手动释放它。

栈溢出 Stack Overflow

面试官 (深入追问): 好的，你对基础区别已经很清楚了。我们来深入聊聊你提到的 “栈溢出 (Stack Overflow)”。

你刚才说“当栈达到一定深度，就会发生溢出”。这通常是由无限递归或过深的递归导致的。

我的问题是： 除了递归，还有没有其他常见的编程行为，也可能导致栈溢出？你能否写一个不使用递归的、非常简单的代码片段，来人为地触发一个栈溢出？

回答：

可以，除了递归之外，两个函数无限制地相互调用也可以出发栈溢出，比如下面的例子。

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


void funcA();
void funcB();

void funcA() {
 funcB();
}

void funcB() {
 funcA();
}

int main () {
 funcA();
 return 0;
}

面试官 (继续引导): 很好。不过，我们还能不能让问题变得更“纯粹”一点？

模板：template和typename

Mon, 29 Sep 2025 09:33:17 +0800

模板的作用与分类

面试官： 在 C++ 中，模板 (template) 是实现泛型编程的核心机制。

你能用自己的话，简单解释一下什么是模板吗？它主要解决了什么问题？C++ 中主要有哪几种类型的模板？

回答：

模板是 Cpp 的一种机制，它允许我们编写与类型无关的代码（泛型），即：使用同一段代码能覆盖许多的类型。这种机制让编译器能根据识别到的具体类型，执行不同的操作。
模板主要解决的是代码复用的问题，尤其是在函数或者类的逻辑一致、但处理数据类型不同的情况下，避免重复写同样的代码，极大地提高了代码的简洁性和可读性。
C++中主要的模板，我认为有
- 函数模板：处理任意类型参数的模板
- 类模板：处理任意类型成员的模板。
- 模板特化：某一个具体类型需要特殊实现，提供一个特化类型的模板。
- 模板偏特化：允许对模板参数的一部分特化，不过较为复杂，使用较少。

模板实例化 Template Instantiation

面试官 (追问): 好的，你提到了函数模板和类模板。我们知道，模板本身并不是可以直接执行的代码，它更像是一个“蓝图”。

请问，从“模板蓝图”到“可执行代码”这个过程，是在什么时候发生的？这个过程通常被称为什么？

1
2
3
4
5
6
7
8
9


template<typename T>
T add(T a, T b) {
 return a + b;
}

int main() {
 int x = add(5, 10); // 发生了什么？
 double y = add(3.14, 2.71); // 这里又发生了什么？
}

回答：

从“模板蓝图”到“可执行代码”这个过程，是在调用函数时，编译器识别到参数的具体类型时发生的。
在上面的例子中，第一个 add 函数识别到输入的参数为 int 类型，因此执行 int 类型的加法；而第二个 add 函数识别到输入的参数为 double 类型，因此执行 double 类型的加法。
这个过程被称为模板实例化。
- 在上面的例子中，模板实例化由编译器自动完成，而不是程序员手动指定，这样的实例化过程被称为隐式实例化 (Implicit Instantiation)。
- 而程序员手动指定类型并提前生成代码的实例化，被称为显式实例化 (Explicit Instantiation)。

下面是一个基于 add 函数的显式实例化的例子：

inline内联函数

Mon, 22 Sep 2025 08:39:31 +0800

`inline` 的好处与坏处

面试官： 在 C++ 中，我们可以在函数声明或定义前，加上 inline 关键字。

请问，inline 关键字是用来做什么的？它是在向编译器建议什么？使用内联函数，主要可能带来什么好处，又可能带来什么坏处？

回答：

inline 关键字用于声明内联函数，它在向编译器建议：“这个函数代码很短，请你将它的代码直接嵌入我们调用它的地方，而不用进行调用跳转。”
当然，这只是一个建议，编译器有最终的决定权。如果编译器觉得这个函数过于复杂，那么它会忽略 inline 的建议，仍然执行调用跳转。
好处：
- 使用内联函数，尤其是对短小且频繁调用的函数，可以省去函数调用的开销，执行效率更高。
坏处：
- 编译更加复杂，导致编译时间增加。
- 由于每次都要复制一份函数体代码到调用处，因此代码膨胀，且指令数量增加，指令缓存效率受影响。

面试官 (总结与补充): 你说的非常好。我来帮你把这些点串联和补充一下，形成一个更完整的知识体系。

什么是函数调用开销？ 当你省去“函数调用开销”时，具体省去了什么？

参数压栈：将函数参数按照调用约定压入栈中。
返回地址压栈：将调用点下一条指令的地址压入栈中，以便函数返回时能继续执行。
跳转：CPU 执行 call 指令，跳转到函数体的入口地址。
栈帧建立：为函数的局部变量分配栈空间。
函数返回：执行 ret 指令，从栈中弹出返回地址，并跳转回去。
栈帧销毁：释放局部变量空间。

对于一个只有一两行代码的函数，这些“行政”开销，可能比真正执行函数体代码的开销还要大得多。inline 的目的就是消除这些“行政”开销。

你提到的坏处——代码膨胀 (Code Bloat)

这是一个非常重要的权衡。如果一个函数体本身很大，内联它会导致可执行文件的体积急剧增大。
这不仅占用更多磁盘空间，更重要的是，它会破坏指令缓存 (Instruction Cache, i-cache) 的局部性。CPU 访问内存的速度远慢于执行指令的速度，所以它会把最近用到的指令缓存起来。如果代码体积太大，缓存装不下，就会导致频繁的“缓存未命中 (cache miss)”，CPU 需要去慢速的主存中读取指令，反而降低了程序的整体性能。

编译器的决定权 现代编译器非常智能，它在决定是否内联时，通常会自己做判断，即使你没有加 inline。

它会自动内联它认为合适的、足够简单的函数（比如定义在类头文件中的成员函数，默认就是 inline 的）。
它会拒绝内联过于复杂的函数，即使你加了 inline 关键字。比如，包含循环、递归、大量 switch 的函数通常不会被内联。

`inline` 的语法作用——解决 ODR 违例问题

面试官 (深入提问): 好的，你对 inline 的性能考量已经很清楚了。

委托构造函数

Sat, 20 Sep 2025 09:59:58 +0800

委托构造函数 Delegating Constructors

面试官： 在 C++ 中，我们经常会为一个类提供多个构造函数，以方便使用者用不同的方式来初始化对象。

请看下面这个 C++03 风格的例子：

 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


#include <string>
#include <iostream>

class MyData {
private:
 int a;
 double b;
 std::string c;

public:
 // 构造函数 1
 MyData() {
 a = 0;
 b = 0.0;
 c = "default";
 // 假设还有一些其他的通用初始化逻辑
 std::cout << "Common logic executed.\n";
 }

 // 构造函数 2
 MyData(int val_a) {
 a = val_a;
 b = 0.0;
 c = "default";
 // 同样的通用初始化逻辑
 std::cout << "Common logic executed.\n";
 }

 // 构造函数 3
 MyData(int val_a, double val_b) {
 a = val_a;
 b = val_b;
 c = "default";
 // 又是同样的通用初始化逻辑
 std::cout << "Common logic executed.\n";
 }
};

你可以看到，这三个构造函数中，有很多重复的代码（比如对 b, c 的初始化，以及那个通用的逻辑）。在 C++11 之前，处理这种代码重复是一个比较头疼的问题。

NULL和nullptr

Thu, 18 Sep 2025 08:33:33 +0800

`nullptr` 解决函数重载的二义性

面试官： 在 C++11 之前，我们通常使用一个宏 NULL 来表示空指针。而在 C++11 中，引入了一个新的关键字 nullptr 来专门表示空指针。

请问，我们为什么需要 nullptr？或者说，使用宏 NULL 在某些情况下，会带来什么样的问题或歧义，是 nullptr 能够解决的？

回答：

NULL 是一个宏，它除了表示空指针之外，更常用的含义是表示 0，一个整数。
由于 NULL 既能表示空指针，又能表示 0，因此它会引发歧义。
比如，某个函数重载了两个版本，一个的参数类型是 int，而另一个参数类型是 char*。当输入 NULL 时，通常会调用参数为 int 的那个版本。
而使用 nullptr 则规避了这一风险。nullptr 是一个真正的空指针常量，它是一个特殊的类型 std::nullptr_t，可以隐式地转换为任何的指针类型，而不会和 int 类型混淆。

面试官 (总结与肯定): 你说的完全正确。我们来把这个过程再详细地梳理一遍。nullptr 诞生的核心原因是解决函数重载时的二义性。

NULL 的“前世今生” NULL 是一个定义在 <cstddef> 等头文件中的预处理宏。它的具体定义取决于编译器，但通常是下面两种之一：

1
2
3
4
5


#define NULL 0
// 或者
#define NULL 0L
// 或者在 C++ 编译器中，有时甚至是
#define NULL nullptr // 这是现代编译器的“向后兼容”行为

在 C++98/03 的时代，你可以认为 NULL 就是一个值为 0 的整型常量。

Cpp异常处理机制

Wed, 17 Sep 2025 09:14:16 +0800

栈展开

面试官： 在 C++ 中，当我们使用 try...catch 块来处理异常时，有一个重要的过程叫做 “栈展开 (Stack Unwinding)”。

你能用自己的话，简单描述一下，当一个异常被 throw 出来之后，到它被某个 catch 块捕获之前，这个“栈展开”的过程具体发生了什么吗？特别是，对于那些在栈上创建的对象，会发生什么？

比如，请看下面这段代码：

 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


#include <iostream>

// 一个简单的类，在构造和析构时会打印信息
struct RAII_Helper {
 int id;
 RAII_Helper(int i) : id(i) { std::cout << "RAII_Helper " << id << " constructed.\n"; }
 ~RAII_Helper() { std::cout << "RAII_Helper " << id << " destructed.\n"; }
};

void func_C() {
 RAII_Helper h3(3);
 std::cout << "Entering func_C, about to throw.\n";
 throw std::runtime_error("An error occurred in C!");
 std::cout << "This line in func_C is never reached.\n";
}

void func_B() {
 RAII_Helper h2(2);
 std::cout << "Entering func_B, calling C.\n";
 func_C();
 std::cout << "This line in func_B is never reached.\n";
}

void func_A() {
 RAII_Helper h1(1);
 std::cout << "Entering func_A, calling B.\n";
 try {
 func_B();
 }
 catch (const std::exception& e) {
 std::cout << "Caught exception in A: " << e.what() << "\n";
 }
 std::cout << "Exiting func_A.\n";
}

int main() {
 func_A();
 return 0;
}

函数调用链是 main -> func_A -> func_B -> func_C。

Cpp字符串处理

Mon, 15 Sep 2025 09:21:27 +0800

`std::string` 的优点

面试官： 在 C++ 中，我们有两种主要的方式来表示字符串：C++ 标准库提供的 std::string 类，以及从 C 语言继承来的、以空字符 \0 结尾的字符数组（我们常说的 C 风格字符串，通常用 char* 或 const char* 指针来表示）。

请问，和传统的 C 风格字符串相比，使用 std::string 类有什么主要的优点？

回答：

std::string 的封装程度更好，使用时不易出错。
具体来说，包括自动内存管理、安全性和功能性三个方面。

面试官 (补充与扩展): 你说的完全正确。std.string 作为一个类，把所有复杂的、容易出错的底层操作都封装起来了，为我们提供了极大的便利和安全保障。

我来帮你把它的优点展开成几个具体的点，这也是面试时希望听到的内容：

自动内存管理 (Automatic Memory Management)：
- std::string: string 对象自己会负责管理存储字符串所需的内存。当字符串变长时，它会自动扩容；当 string 对象被销毁时，它会自动释放内存。你完全不需要操心 new[] 和 delete[]。
- char*: 你必须手动管理内存。malloc / free 或 new[] / delete[] 必须成对出现，极其容易忘记释放，导致内存泄漏。
安全性 (Safety)：
- std::string: 它内部记录了字符串的当前长度。
  - 成员函数 length() 或 size() 可以 O (1) 复杂度地返回长度。
  - 成员函数 at(i) 提供边界检查，越界会抛出异常。
  - 拼接、拷贝等操作都会自动处理内存，不会造成缓冲区溢出。
- char*:
  - 长度信息依赖于结尾的 \0。每次计算长度 (strlen) 都需要从头遍历，时间复杂度 O (n)。
  - 所有操作（如 strcpy, strcat）都不进行边界检查，如果目标缓冲区不够大，就会发生缓冲区溢出，这是 C/C++ 中最危险的安全漏洞之一。
功能丰富且易用 (Rich Functionality)：

Cpp的三种类型推导关键字

Sun, 14 Sep 2025 09:33:26 +0800

`auto` 关键字

面试官： C++11 引入了 auto 关键字，它极大地改变了我们编写 C++ 代码的方式。

你能简单解释一下，auto 关键字的作用是什么吗？使用它有什么好处？

回答：

auto 关键字的作用是，省略具体的变量类型，而是根据实际变量的类型推导出其类型。
使用 auto 关键字，就不必写复杂的类型名（比如常用的 STL 迭代器），让代码看上去更简洁。
同时，auto 关键字还能实现类似“多态”的效果（这里说“多态”不太准确，应该说，是泛型编程），使得同一份代码可以被许多不同的类型复用。

面试官 (补充与澄清): 你说的很对。我们来把你的回答再精确化和补充一下。

auto 的作用： 它是一个类型占位符。编译器会在编译时，根据变量的初始化表达式，自动推导出变量应该具有的正确类型。

auto 的好处：

简洁性 (Brevity)：正如你所说，它可以避免写冗长、复杂的类型名。这一点在处理 STL 的迭代器和模板时尤其明显。

1
2
3
4
5


// C++03
std::vector<std::string>::iterator it = my_vec.begin();

// C++11 with auto
auto it = my_vec.begin(); // 简洁、易读、不易出错

正确性 (Correctness)：auto 保证了变量的类型与初始化表达式的类型完全匹配，避免了因手写类型错误或发生意外的类型转换而导致的 bug。
可维护性 (Maintainability)：如果初始化表达式的类型未来发生了变化（比如一个函数的返回值从 int 变成了 long long），使用了 auto 的代码不需要任何修改，会自动适应新的类型。

关于你提到的“多态效果”： 这个描述非常有趣！auto 本身是在编译期进行类型推导，不直接产生运行时的多态（那需要虚函数）。但你说的“使得同一份代码可以被许多不同的类型复用”，这个思想非常接近泛型编程 (Generic Programming)。 auto 在 C++14 的泛型 Lambda 中 [](auto x){ ... } 和 C++20 的函数参数中 void func(auto param)，确实扮演了类似模板参数的角色，让一段代码能适用于多种类型。你的直觉是非常准的。

Lambda表达式

Sat, 13 Sep 2025 18:22:44 +0800

什么是 Lambda 表达式？

面试官： 好的，我们来聊聊 C++11 引入的一个非常强大的特性——Lambda 表达式。

你能用自己的话简单解释一下，Lambda 表达式是什么吗？它主要解决了什么问题，或者说，它为我们编写 C++ 代码带来了什么样的便利？

回答：

我的理解是，lambda 表达式就是“匿名函数”，即省略名字的函数。
它定义了一个函数，这个函数有函数的所有功能，但不需要名字。
这让我们在需要写一些小巧的工具性一次性函数时，省去了从头定义函数的麻烦，让代码看上去更加简洁。

面试官 (补充与肯定): 你说的完全正确。Lambda 表达式的出现，极大地改变了 C++ 的编程风格，特别是与标准库算法（STL Algorithms）结合使用时。

在 C++11 之前，如果我们需要给 std::sort, std::find_if 这样的算法传递一个自定义的比较或判断逻辑，我们通常需要：

在别处定义一个完整的具名函数。
或者定义一个函数对象（一个重载了 operator() 的 struct 或 class）。

这两种方式都比较繁琐，并且会导致逻辑和使用点的分离。

而 Lambda 表达式，正如你所说，允许我们在需要的地方，就地定义一个匿名的、小巧的函数，让代码更紧凑、可读性也更强。

Lambda 表达式的捕获列表

面试官 (深入提问): 好的，你对 Lambda 的基本概念很清楚。我们来看一下 Lambda 表达式的语法结构。

一个完整的 Lambda 表达式看起来像这样： [ captures ] ( params ) -> return_type { body }

其中，[ captures ] 这个部分，我们称之为捕获列表 (Capture List)，这是 Lambda 表达式最强大、也最核心的部分。

左值与右值

Tue, 09 Sep 2025 10:09:30 +0800

什么是左值？什么是右值？如何区分它们？

面试官： 在 C++ 中，我们经常听到“左值”和“右值”这两个术语。你能用自己的话，简单地解释一下，什么是左值，什么是右值吗？最简单的区分它们的方法是什么？

回答：我在一年多前的程序设计课上学过这两个概念，但现在我的记忆已经模糊，凭感觉回答一下。

左值是被持久保存而不是临时保存的值，它通常就是我们定义的变量的值。因为出现在赋值式子的左边，所以叫做“左值”。
右值是通过某些代数计算式得到的临时值，它通常出现在赋值式子的右边，因此被称为“右值”。

面试官 (补充与深化): 你说的“能否放在赋值运算符左边”是一个非常好的启发式判断方法。一个更根本的、适用于现代 C++ 的区分标准是：

我们能否对这个表达式“取地址”？

左值 (lvalue)：是一个表达式，它指向了一个具名的、有持久状态的对象或函数。我们可以对它取地址 (&)。它在表达式结束后，依然存在。
- 例子：变量名 int x; x 是一个左值，我们可以 &x。std::string s; s 是一个左值。
右值 (rvalue)：是一个表达式，它通常代表一个匿名的、即将被销毁的临时值。我们无法对它取地址。它在表达式结束后，就不复存在了。
- 例子：字面量 10 是一个右值，你不能 &10。函数返回值 get_string()（如果返回的是一个值而非引用）是一个右值。x + y 这个表达式的结果也是一个右值。

总结一下：

左值：有家（内存地址），能活得久。
右值：没家（没法取地址），是“过客”（马上就消失）。

右值引用

面试官 (引入新概念): 好的，既然我们知道了左值和右值的区别。C++11 为了配合移动语义，引入了一种新的引用类型，叫做右值引用 (rvalue reference)，用 && 表示。

1
2
3
4
5


int x = 10; // x 是一个左值
int& l_ref = x; // 左值引用 l_ref 绑定到左值 x (OK)

int&& r_ref = 20; // 右值引用 r_ref 绑定到右值 20 (OK)
// int&& r_ref2 = x; // 错误！右值引用不能直接绑定到左值

请问，&& 这个右值引用的主要设计目的是什么？它和我们之前讨论的移动语义 (Move Semantics) 是如何关联起来的？

构造函数相关知识

Sun, 07 Sep 2025 21:25:43 +0800

如果没有定义构造函数——默认构造函数

面试官： 好的，我们来聊聊 C++ 的一个核心特性——构造函数 (Constructor)。

我们知道，构造函数是在创建对象时被自动调用的一个特殊函数。除了我们最常见的、带参数的普通构造函数之外，C++ 编译器在某些情况下，还会为我们自动生成一些特殊的构造函数。

我的第一个问题是：如果我们在类中没有定义任何构造函数，编译器会为我们自动生成一个什么样的构造函数？它的作用是什么？

回答：我不太了解这个问题，所以凭感觉回答，请你为我补充。

编译器自动为我们生成的构造函数不会初始化任何的成员变量，所有的成员变量都处于原始状态。
它的作用是保证对象能够生成，而不会导致报错，起到占位的作用。

面试官 (补充与解释): 你说得基本正确。如果我们在类中没有定义任何构造函数，编译器会为我们生成一个默认构造函数 (Default Constructor)。这是一个无参数的构造函数。

这个自动生成的默认构造函数，它会做什么？

它的行为比我们想象的要“智能”一点，它遵循一个规则：

对于类类型的成员 (Class-type Members)：如果这个类成员有自己的默认构造函数，那么编译器生成的默认构造函数就会自动调用这个成员的默认构造函数。

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


class Engine {
public:
 Engine() { std::cout << "Engine constructed\n"; }
};

class Car {
public:
 // 没有定义任何构造函数
private:
 Engine engine_; // 类类型成员
};

// 当你创建 Car c; 时，
// Car 的合成默认构造函数会被调用，
// 它会自动调用 Engine 的默认构造函数，
// 所以你会看到 "Engine constructed" 输出。

对于内置类型的成员 (Built-in Type Members, e.g., int, double, 指针)：

final和override关键字

Sun, 07 Sep 2025 08:53:49 +0800

关键字 `override`

没有 `override` 时存在的风险

面试官： 在 C++11 之后，我们在处理类的继承和虚函数时，多了 override 和 final 这两个说明符。我们先来聊聊 override。

请看下面这段代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class Base {
public:
 virtual void doSomething(int param) { /* ... */ }
};

class Derived : public Base {
public:
 // 这里有一个小小的笔误，程序员将int写成了long
 virtual void doSomething(long param) { /* ... */ }
};

在 Derived 类中，程序员的意图是重写 (override) 基类的 doSomething 函数。但由于笔误，他把参数类型从 int 写成了 long。

请问，在没有 override 关键字的情况下，这段代码能编译通过吗？如果能，它在多态调用时，可能会产生什么样的问题？

回答：

我认为编译能够通过。由于参数列表不同（这里是参数类型不同），编译器会认为程序员在 Derived 类中重载了一个虚函数。
可能的问题：在多态调用时，会出现函数参数实际类型不一致的情况，可能导致冲突。

面试官 (补充与解释): 你说的很对。我们来把这个问题分析得更透彻一些。

函数重载和函数重写

Sat, 06 Sep 2025 09:28:27 +0800

昨天我们聊了虚函数和多态的实现，今天我们来聊一个与它紧密相关，但在概念上又容易混淆的话题：重载 (Overloading)、重写 (Overriding) 和隐藏 (Hiding)。

这三个术语描述了 C++ 中函数名相同但行为不同的几种情况，是面试中考察“你是否能精确理解 C++ 概念”的经典问题。

Overloading 和 Overriding 的区别

面试官： 在 C++ 中，我们经常会遇到函数名相同的情况。你能用自己的话分别解释一下，什么是函数重载 (Overloading) 和函数重写 (Overriding) 吗？它们两者最主要的区别是什么？

回答：Overloading 指的是两个函数同名，但是参数列表不同的情况。

Overriding 指的是两个函数同名、参数也相同（更准确地说，函数签名完全相同），但是一个在派生类中，另一个在基类中的情况。

我认为它们的主要区别是“参数是否相同”，以及“两者之间的关系是并列（Overloading）还是继承（Overriding）”。

你的回答非常出色！直截了当，并且准确地抓住了两者最核心的区别。

重载 (Overloading): 关键在于参数列表不同 (参数个数、类型、顺序)。
重写 (Overriding): 关键在于继承关系，并且函数签名 (signature) 必须完全相同 (函数名、参数列表、const 属性等都相同)。

你的总结“关系是并列还是继承”也非常形象。重载的函数之间是“兄弟”关系，而重写的函数之间是“父子”关系。

确定多态的时机——编译器？运行期？

面试官 (补充与追问): 你说得很好。我们来把这个概念再深化一下。

重载和重写，它们分别是在哪个阶段被决定的？一个是在编译期 (Compile-time)，一个是在运行期 (Run-time)。你觉得哪个对应哪个？为什么？

这可以帮助我们理解它们更深层次的机制差异。

回答：我认为，Overloading 属于静态多态，在编译期就被确定了，因为具有 overloading 关系的两个函数只有名字相同，而函数签名不同，事实上可以被看作两个不同函数，这使得编译器可以分辨他们。（编译器在处理函数调用时，会根据传入的实参类型、数量和顺序，查找应该匹配的函数，这个过程被叫做“名字修饰”）

而对于 overriding 属于动态多态，需要在运行期才能被确定，这和我们昨天讨论的虚函数与多态相关，程序必须通过 v-ptr 和 v-table 才能确定我们调用的到底是哪一个函数。‘

面试官 (总结与肯定): 你说得对极了。

重载 (Overloading) 属于静态多态，是在编译期决定的。
- 编译器在处理函数调用时，会根据你传入的实参类型、数量和顺序，像查字典一样，去查找应该匹配哪个版本的同名函数。这个过程叫做名字修饰 (Name Mangling) 或名称改编。编译器会给每个重载函数一个独特的内部名称，所以对编译器来说，它们就是不同的函数。这个决策过程完全不需要等到程序运行。
重写 (Overriding) 属于动态多态，是在运行期决定的。

面向对象与多态

Sat, 06 Sep 2025 09:28:10 +0800

什么是多态？实现技术是什么？

看到你的简历上写着熟悉 C++ 的面向对象编程。那你能用自己的话简单解释一下，什么是多态吗？在 C++ 中，我们通常通过什么关键技术来实现多态？

我理解的多态，就是同一个函数在不同的继承类中可以有不同的内容，这取决于子类自己的实现方式。（更精炼的表达：同一个接口，不同的实现。）

实现多态的关键技术通常是虚函数 (virtual function)，即基类中声明的函数，在派生类中可以有自己另外的实现 (override)，从而适配每个派生类的具体情况。（如果基类中没有对这一函数的实现，全部靠派生类自己实现，那么这种函数就是纯虚函数）

用基类指针指向派生类对象

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


class Animal {
public:
 // 这是一个普通的虚函数，它有自己的实现
 virtual void makeSound() {
 std::cout << "Some generic animal sound" << std::endl;
 }
};

class Dog : public Animal {
public:
 // Dog 类重写(override)了父类的虚函数
 void makeSound() override {
 std::cout << "Woof!" << std::endl;
 }
};

1
2


Animal* pAnimal = new Dog(); // 用基类指针指向派生类对象
pAnimal->makeSound(); // 请问，这里会输出什么？

如果用基类指针指向派生类对象，并调用函数，那么这个函数应该是派生类中覆写后的版本，而不是基类中的版本。

即：输出结果取决于指针实际指向的对象的类型（动态类型），而不是指针变量本身声明的类型（静态类型）。

C++如何保证能调用正确的函数呢？这一点我只是依稀记得和 v-table 还有 v-ptr 相关，具体内容不记得了。

vector的内部实现和优化

Sat, 06 Sep 2025 09:27:46 +0800

`vector` 在内存中如何存储数据？和 `array` 的区别？

面试官： 我看你写的代码里经常使用 std::vector。你能简单描述一下 std::vector 在内存中是如何存储数据的吗？它和普通的 C 风格数组（比如 int arr[10]）有什么主要的区别？

回答：

对于这个问题，我并不太了解，我谈一谈我粗浅的看法。
首先，vector 应该是基于数组 array 实现的，其底层就是一块动态分配的、连续的内存数组。这是 vector 能够支持快速随机访问的根本原因。但是，vector 肯定有它自身的优化在。
边界检查：
- array 只管给你分配一段连续的内存，其他的管理你都要自己来，也不会管你数组 idx 是否越界；
- 在 vector 中，如果用 [] 操作符，那么行为和 array 一样，不会管你越界与否；
- 但是，vector 提供了 at() 这个成员函数，vec.at(i) 会进行边界检查。如果 i 越界，vector 会抛出 std::out_of_range 异常。这说明 vector 的安全性更好。
自动初始化：
- 再比如，定义 array 时，程序不会帮我们自动初始化，array 中可能有一些奇怪的原始数据（随机值）；
- 但是，定义 vector 时，程序会帮我们自动初始化。

不过，我没有提到 vector 和 array 最重要的区别：（根据 Gemini 的解释补充）

Vector 的大小是动态可变的，可以不断地 push_back 新的元素，而 array 的大小是固定的。
这就是 vector 的动态扩容机制。

`vector` 的扩容机制 (Reallocation)

面试官 (补充与追问): 你说得很好。vector 最大的特点就是它的大小是动态可变的。我们可以不断地对它 push_back 新的元素。

C++的三种访问权限修饰符

Sat, 06 Sep 2025 09:21:34 +0800

成员访问的三种权限

面试官： 在 C++ 的类（class）定义中，我们有 public, protected, 和 private 这三个关键字来控制成员的访问权限。

你能简单解释一下，这三种权限分别意味着什么吗？也就是说，什么样的代码可以访问被它们修饰的成员？

回答：

public 修饰的成员，可以被该类的对象、该类的子类成员，以及该类的其他成员访问。（最宽松）
private 修饰的成员，只能被该类的其他成员访问，而不能被对象和子类成员访问。（最严格）
protected 修饰的成员，可以被该类的其他成员和子类的成员访问，但不能被该类的对象访问。（介于 public 和 private 之间）

Gemini 更好的概括：

public: 类内、子类、类外（通过对象）都能访问。权限最开放。
private: 仅限类内访问。权限最严格，实现了完全的封装。
protected: 类内、子类可以访问，但类外不行。权限介于两者之间，专门为继承体系设计。

类继承的三种权限

面试官 (深入提问): 好的，你对成员访问权限很清楚。现在我们把这个概念和继承结合起来。

C++ 中，继承也有三种方式：public 继承、protected 继承和 private 继承。

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


class Base {
public:
 int public_member;
protected:
 int protected_member;
private:
 int private_member;
};

class Derived_Public : public Base { ... };
class Derived_Protected : protected Base { ... };
class Derived_Private : private Base { ... };

请问，这三种不同的继承方式，会如何影响基类 (Base) 的成员在派生类 (Derived) 中的访问权限？

explicit关键字

Sat, 12 Jul 2025 10:35:00 +0000

好的，我们来深入解析 explicit 这个虽小但非常重要的关键字。

你的理解完全正确！explicit 关键字就像一个“门卫”，它守在你的构造函数门口，防止一些“不请自来”的隐式类型转换，从而让代码的行为更加清晰、可控。

一、问题根源：什么是构造函数的“隐式转换”？

在 C++ 中，编译器有时候会“自作主张”地帮你进行类型转换，让代码能够通过编译。如果一个类的构造函数可以只用一个参数来调用，那么这个构造函数就可能被编译器用来进行隐式转换 (Implicit Conversion)。

让我们来看一个没有 explicit 的“事故现场”：

场景设定：我们有一个字符串类 MyString，它有一个构造函数，可以接受一个整数 n 来创建一个由 n 个 'A' 组成的字符串。

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


#include <iostream>
#include <string>

class MyString {
private:
 std::string m_str;
public:
 // 这个构造函数可以用一个 int 参数来调用
 MyString(int n) : m_str(n, 'A') {
 std::cout << "MyString(" << n << ") 被调用了！\n";
 }

 const char* c_str() const { return m_str.c_str(); }
};

// 这是一个希望接收 MyString 对象的函数
void printString(const MyString& s) {
 std::cout << "打印: " << s.c_str() << std::endl;
}

现在，在 main 函数中，我们可能会写出这样的代码：