内存管理 on Mao's Blog

3-Resource Management

Sat, 02 May 2026 09:27:30 +0800

C++中，我们需要手动管理资源。最常见的资源就是动态分配的内存，但注意，它不是唯一的资源。其他资源还有：file descriptors, mutex locks, fonts and brushes in graphical user interfaces.

Item13: Use objects to manage resouces

核心思想：把资源放进对象里，用对象来管理资源，让对象的构造和析构来保证资源的获取与释放。

其实，这就是 RAII。

这是因为，C++没有垃圾回收机制，手动 new / delete 十分容易出错（比如 delete 可能因为一些异常情况而没有被执行），所以我们需要一个规范化的获取和释放资源的流程。

手动管理资源的做法

例如，下面的代码使用一个 factory function 来为所有继承自 Investment 的类创建统一的调用接口（一个基类指针）。

如果你手动管理资源（new / delete、fopen / fclose、lock / unlock），很容易出错：

1
2
3
4
5


void f() {
 Investment* pInv = createInvestment();
 // ... 中间可能有 return、异常、goto 等各种出口
 delete pInv; // 万一没走到这里？内存泄漏
}

当然，你可以说：啊我 coding 的时候很仔细的，不会犯这样的低级错误。

但是，随着工程越来越大，代码越来越长，不规范的写法维护的成本也会越来越高。所以，为了确保资源一定能够安全释放，我们还是使用 RAII 的做法。

RAII 的做法

用一个对象来持有资源，对象的析构函数负责释放资源。

auto_ptr 就是这样一个对象。它是一个智能指针，管理着一个裸指针；在自身析构时，会自动对自己管理的裸指针调用 delete。

再次回顾：<code>delete</code> 实际做了两件事情

RAII设计哲学

Thu, 27 Nov 2025 16:47:57 +0800

RAII: Resource Acquisition Is Initialization

模拟面试开始

面试官： 我看你的代码风格很现代。在 C++ 资源管理中，RAII 是一个核心概念。

你能用自己的话，简单解释一下什么是 RAII 吗？它的中文含义是什么？它主要用来解决什么问题？

回答：

RAII 的全称是 Resource Acquisition Is Initialization，中文直译过来就是“资源获取即初始化”。意思就是，我们希望在获取资源（比如取用一个指针）时，取用到的资源不是未初始化的（比如说野指针），而是已经经过规范初始化的、安全可用的资源。
它主要用来解决的问题，就是未经许可的内存访问。比如，如果我访问一个野指针，其中的内容可能恰好指向程序的某些重要区域，当我修改其中数据时，程序就直接崩溃了。

这是我对 RAII 这个概念自己的理解，如有不正确之处，还希望批评指正。

你的回答非常坦诚，是基于字面意思的合理推测，但其实 RAII 的真正含义和你现在的理解有比较大的偏差。

你现在的理解更偏向于“初始化安全”或者“避免野指针”，这当然也是好的编程习惯，但 RAII 的核心在于生命周期的绑定和自动释放。

我们来纠正一下这个概念。

面试官 (纠正与引导): 你的直觉很有意思，但 RAII 这个名字其实起得有点“烂”，非常容易让人产生和你一样的误解（以为重点在初始化）。

RAII 的核心其实不在于“获取资源时要初始化”，而在于 “资源的生命周期应该与对象的生命周期绑定”。

关键点在于：

构造函数 (Acquisition)：当我们在栈上创建一个对象（比如一个类实例）时，我们在它的构造函数里去“获取”资源（比如 new 一块内存、打开一个文件、上一个锁）。
析构函数 (Release)：这是最最关键的一步。当这个对象离开作用域（生命周期结束）时，它的析构函数会被编译器自动调用。我们就在析构函数里去“释放”那个资源（比如 delete 内存、关闭文件、解锁）。

所以，RAII 解决的核心问题是：资源泄漏 (Resource Leak)。

举个最经典的例子： 如果不使用 RAII：

1
2
3
4
5
6
7
8
9


void func() {
 int* p = new int[100]; // 获取资源
 if (some_error) {
 // 糟糕！如果这里直接 return 或抛出异常，
 // 下面的 delete 永远不会执行，内存泄漏！
 return;
 }
 delete[] p; // 释放资源
}

如果使用 RAII（比如 std::vector 就是一个 RAII 包装类）：

虚析构函数

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; 这行代码，编译器是如何决定调用哪个析构函数的？）

回答：

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;
}

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

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的三五零法则

Fri, 12 Sep 2025 08:50:48 +0800

三法则 The Rule Of Three

面试官： 在 C++ 编程中，我们经常听到一个叫做 “三法则 (The Rule of Three)” 的设计原则。你能用自己的话解释一下，这个“三法则”指的是什么吗？它规定了如果一个类定义了哪三个特殊的成员函数之一，那么它可能也需要定义另外两个？

回答：

“三法则”指的是，C++编程中，如果一个类中定义了下面三个成员函数之一，那么另外两个成员函数也需要程序员手动定义：
- 析构函数
- 拷贝构造函数
- 拷贝赋值运算符

这三者是一个紧密相关的整体，要么同时提供，要么同时不提供。

面试官 (追问): 很好，你知道是哪三个函数。那你能进一步解释一下，这个法则背后的根本原因是什么吗？

换句话说，为什么一个类只要自己定义了析构函数（比如，为了 delete 一个裸指针成员），就很可能也需要自己定义拷贝构造函数和拷贝赋值运算符？编译器自动生成的版本，在这种情况下会有什么问题？

回答：

当我们只定义这三个成员函数中的某一个时，剩下两个函数由编译器自动生成，而编译器生成的版本和程序员定义的版本可能存在冲突，导致一些 tricky 的错误。
不过，具体的错误和原因我也说不上来，请你补充。

面试官 (补充与解释): 这个问题的根本原因在于，一个类需要手动定义析构函数，几乎总是出于同一个目的：这个类在手动管理某种资源。

最典型的资源就是裸指针指向的堆内存。

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


class MyString {
private:
 char* data_; // 手动管理的裸指针
 size_t size_;

public:
 // 构造函数，分配资源
 MyString(const char* s = "") {
 size_ = strlen(s);
 data_ = new char[size_ + 1];
 strcpy(data_, s);
 }

 // 1. 我们必须手动定义析构函数，来释放资源
 ~MyString() {
 delete[] data_;
 }

 // 2. 但是，我们忘记定义拷贝构造函数...
 // 3. 也忘记定义拷贝赋值运算符...
};

现在，我们来看看编译器自动生成的拷贝函数会有什么问题：

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 新的元素。

Cpp内存管理

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

Cpp 内存分区

你能简单介绍一下 C++ 程序的内存分区吗？一个 C++ 程序在运行时，它的内存大概被分成了哪几个区域？

回答：

Cpp 程序运行时，分成堆、栈，以及全局的静态区域。
栈中的数据在函数调用结束时，就自动被释放。
堆中的数据由程序员自己分配，自己释放。
全局的静态区域在整段程序结束时，自行释放数据。

请问，我的理解正确吗？

基本正确，但还需要补充：

面试官 (补充与细化): 你说的完全正确。为了让这个回答更完整、更专业，我们通常会把内存分区说得更细一些，一般分为五个区。你提到的三个区是其中最重要的，我帮你补充另外两个。

一个典型的 C++ 程序内存布局：

栈区 (Stack)：
- 存放：函数的参数值、局部变量等。
- 管理：由编译器自动分配和释放。
- 特点：函数调用时入栈，函数返回时出栈，分配速度快，但空间有限且是连续的。
堆区 (Heap)：
- 存放：程序运行时动态分配的内存，比如通过 new 或 malloc 创建的对象。
- 管理：由程序员手动分配 (new) 和释放 (delete)。如果忘记释放，就会造成内存泄漏。
- 特点：空间大，不连续，分配和释放速度相对较慢。
全局/静态存储区 (Static Storage Area)：
- 存放：全局变量和静态变量 (包括全局 static 变量和函数内 static 变量)。
- 管理：在程序编译时就已经分配好了，在程序整个运行期间都存在，程序结束时由操作系统释放。
常量存储区 (Constant Storage Area)：
- 存放：常量，特别是字符串常量 (e.g., "hello world")。
- 特点：内容只读，不允许修改。
代码区 (Code Area / Text Segment)：
- 存放：编译后的二进制机器代码。
- 特点：只读，且可共享。

你能把这五个区记住，在面试时就能给出一个非常全面和专业的回答。

堆和栈的对比

面试官 (深入提问): 好的，你对内存分区已经很清楚了。我们来聚焦于堆 (Heap) 和栈 (Stack) 的对比。

内存管理 on Mao's Blog

3-Resource Management

Item13: Use objects to manage resouces

手动管理资源的做法

RAII 的做法

RAII设计哲学

RAII: Resource Acquisition Is Initialization

虚析构函数

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

new运算符的细节

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

栈、堆与栈溢出

栈和堆的比较 Stack and Heap

栈溢出 Stack Overflow

Cpp异常处理机制

栈展开

Cpp的三五零法则

三法则 The Rule Of Three

vector的内部实现和优化

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

vector 的扩容机制 (Reallocation)

Cpp内存管理

Cpp 内存分区

堆和栈的对比

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

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

`vector` 的扩容机制 (Reallocation)