04.9.1 指针、内存布局与 RAII
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.9 C 与 C++
覆盖范围
- 指针运算、指针与数组、函数指针、void*
- 内存四区:栈/堆/全局静态区/代码段
- 智能指针:unique_ptr/shared_ptr/weak_ptr 与控制块
- RAII 惯用法与异常安全
- 移动语义、右值引用、完美转发
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 04.9.1-001 | 指针与引用的区别 | 基础 | ★★★★★ |
| 04.9.1-002 | 程序内存布局分哪几个区 | 基础 | ★★★★★ |
| 04.9.1-003 | unique_ptr/shared_ptr/weak_ptr 区别 | 进阶 | ★★★★★ |
| 04.9.1-004 | shared_ptr 线程安全吗 | 进阶 | ★★★★☆ |
| 04.9.1-005 | 移动语义与右值引用 | 高级 | ★★★★☆ |
| 04.9.1-006 | RAII 是什么,解决什么问题 | 基础 | ★★★★★ |
| 04.9.1-007 | 什么情况下会产生悬空指针 | 进阶 | ★★★★★ |
| 04.9.1-008 | 完美转发 std::forward | 高级 | ★★★★☆ |
04.9.1-001 指针和引用的区别是什么?
频率 ★★★★★ | 难度 基础
一句话结论
指针是一个变量,存储地址,可以为空、可以重新赋值、可以有多级;引用是变量的别名,必须初始化、不能改绑、不能为 NULL。
概念解释
- 指针:占有内存空间(32 位 4 字节 / 64 位 8 字节),可以为 nullptr,可以
++做指针运算。 - 引用:不占独立内存(实现上常是指针,但语法层面是别名),必须在定义时初始化绑定到某个对象,之后不能再绑定到别的对象。
- 引用的底层实现通常就是指针,但语法上对使用者透明。
原理流程
- 指针声明后可以不初始化(野指针风险),可以赋值为 nullptr。
- 引用必须在声明时就绑定到一个已有对象,后续所有对引用的操作都直接作用于原对象。
- 函数参数中用引用可以避免拷贝,同时语义上比指针更明确(不为空)。
代码 / 示例
int a = 10;
int* p = &a; // 指针
int& r = a; // 引用,必须初始化
p = nullptr; // 合法,指针可以为空
// r = nullptr; // 非法,引用不能为 nullptr
int b = 20;
p = &b; // 合法,指针可以改指
// r = b; // 这不是改绑,而是把 b 的值赋给 a,a 变成 20
int* p2 = p; // 二级指针合法
int&* r2 = r; // 非法,不存在指向引用的指针
常见误区
- 误区:引用占内存吗?正解:语法上不占独立空间,但编译器通常用指针实现,sizeof(引用) 等于所引用对象的大小。
- 误区:引用可以改绑吗?正解:不能。
r = b是赋值操作,不是改绑。
追问 / 延伸
- 什么时候用指针什么时候用引用?答:需要为空或需要重新绑定时用指针;作为参数传递且保证不为空时用引用(左值引用)或万能引用。
- const 引用和 const 指针?答:const 引用更常用,既避免拷贝又不允许修改原对象。
04.9.1-002 一个 C++ 程序的内存布局分哪几个区?
频率 ★★★★★ | 难度 基础
一句话结论
从低地址到高地址依次为:代码段(.text)、全局/静态存储区(.data/.bss)、堆(heap,向上增长)、栈(stack,向下增长)。
概念解释
- 代码段 .text:存放编译后的机器指令,只读,可共享。
- 全局初始化区 .data:存放已初始化的全局变量和静态变量。
- 全局未初始化区 .bss:存放未初始化或初始化为 0 的全局变量和静态变量,程序启动时清零。
- 堆 heap:由 malloc/new 分配,向上(高地址)增长,需要 free/delete 释放。
- 栈 stack:函数调用时的栈帧,存放局部变量、函数参数、返回地址,向下(低地址)增长。
原理流程
- 程序加载时,操作系统把代码段和数据段映射到进程地址空间。
- 堆从 brk 开始向上扩展,通过系统调用 sbrk/mmap 调整。
- 栈从高地址开始向下增长,每次函数调用压入一个栈帧。
- 堆和栈之间的区域是共享库映射区和未分配空间。
代码 / 示例
int g1 = 10; // .data 已初始化全局变量
int g2; // .bss 未初始化全局变量
static int s1 = 20; // .data 静态已初始化
static int s2; // .bss 静态未初始化
int main() {
int local = 1; // 栈
int* p = new int(5); // 堆
printf("栈地址: %p\n", (void*)&local);
printf("堆地址: %p\n", (void*)p);
printf("全局地址: %p\n", (void*)&g1);
delete p;
return 0;
}
常见误区
- 误区:栈上分配的内存会自动回收所以不用管?正解:栈变量离开作用域自动析构,但栈上不能分配大对象(栈大小通常 1~8MB)。
- 误区:堆和栈谁大谁小?正解:堆可以很大(受限于虚拟内存),栈通常很小。
追问 / 延伸
- 局部 static 变量在哪个区?答:已初始化在 .data,未初始化在 .bss。
- 字符串常量在哪个区?答:通常在 .text 的只读数据段(.rodata)。
04.9.1-003 unique_ptr、shared_ptr、weak_ptr 有什么区别?
频率 ★★★★★ | 难度 进阶
一句话结论
unique_ptr 独占所有权、零开销、可移动不可拷贝;shared_ptr 共享所有权、内部引用计数、有控制块开销;weak_ptr 弱引用不增加计数,配合 shared_ptr 解决循环引用。
概念解释
- unique_ptr:独占指向的对象,同一时间只能有一个 unique_ptr 指向它,不能拷贝只能移动,析构时自动 delete。
- shared_ptr:多个 shared_ptr 可以指向同一个对象,内部有引用计数(控制块),最后一个 shared_ptr 销毁时释放对象。
- weak_ptr:指向 shared_ptr 管理的对象但不拥有它,不增加引用计数,需要
lock()提升为 shared_ptr 才能访问对象。
原理流程
- unique_ptr 通过删除拷贝构造和拷贝赋值、只保留移动构造来实现独占语义,大小和裸指针一样。
- shared_ptr 内部包含两个指针:一个指向对象,一个指向控制块(引用计数、弱计数、删除器、分配器)。
- shared_ptr 拷贝时原子递增引用计数,析构时原子递减,计数归零时 delete 对象。
- weak_ptr 不操作强引用计数,只观察对象是否还存活;
lock()检查强计数是否大于 0,是则返回一个新的 shared_ptr。
代码 / 示例
#include <memory>
void unique_demo() {
std::unique_ptr<int> p1 = std::make_unique<int>(42);
// std::unique_ptr<int> p2 = p1; // 错误:拷贝被删除
std::unique_ptr<int> p3 = std::move(p1); // 正确:转移所有权
// p1 现在为 nullptr
}
void shared_demo() {
auto sp1 = std::make_shared<int>(42);
{
auto sp2 = sp1; // 引用计数变成 2
std::cout << sp1.use_count() << std::endl; // 2
}
// sp2 销毁,引用计数变回 1
std::cout << sp1.use_count() << std::endl; // 1
}
void weak_demo() {
auto sp = std::make_shared<int>(42);
std::weak_ptr<int> wp = sp;
if (auto locked = wp.lock()) {
std::cout << *locked << std::endl; // 42
}
sp.reset(); // 对象销毁
if (wp.expired()) {
std::cout << "对象已销毁" << std::endl;
}
}
// 循环引用问题
struct Node {
std::shared_ptr<Node> next;
std::weak_ptr<Node> prev; // 用 weak_ptr 打破循环
};
常见误区
- 误区:shared_ptr 可以任意拷贝所以很安全?正解:两个 shared_ptr 互相持有对方就形成循环引用,内存永远不会释放。
- 误区:make_shared 比 new 好在哪?正解:一次分配同时分配对象和控制块,减少一次堆分配,且异常安全。
追问 / 延伸
- 为什么尽量用 make_shared 而不是 shared_ptr(new T)?答:减少一次内存分配(对象和控制块合并分配),且避免 new 和 shared_ptr 构造之间发生异常导致内存泄漏。
- weak_ptr 的 lock() 和 expired() 有什么区别?答:expired() 只判断是否过期;lock() 原子地检查并提升为 shared_ptr,更安全。
04.9.1-004 shared_ptr 的线程安全吗?
频率 ★★★★☆ | 难度 进阶
一句话结论
shared_ptr 的引用计数操作是原子的,但 shared_ptr 对象本身的读写不是线程安全的——多个线程同时读写同一个 shared_ptr 实例需要加锁,不同线程持有不同的 shared_ptr 副本指向同一个对象是安全的。
概念解释
- 控制块的引用计数:原子递增/递减,多线程拷贝/析构不同副本是安全的。
- shared_ptr 对象本身:指向对象的指针和指向控制块的指针不是原子的,多个线程同时
sp = another_sp或同时sp.reset()同一个 shared_ptr 实例会产生数据竞争。 - 指向的对象:如果多线程读写同一个对象,对象本身需要自己同步。
原理流程
- shared_ptr 拷贝构造时,原子操作把控制块的强计数加 1。
- shared_ptr 析构时,原子操作把强计数减 1,归零时 delete 对象。
- 但 shared_ptr 内部的两个指针(对象指针、控制块指针)的写入不是原子的,两个线程同时修改同一个 shared_ptr 实例时,可能一个线程刚读完对象指针,另一个线程已经把它改成新值,导致读到无效指针。
代码 / 示例
// 安全:不同线程持有不同副本
std::shared_ptr<int> sp = std::make_shared<int>(0);
void thread_a() {
auto local = sp; // 拷贝一份,引用计数 +1,安全
(*local)++;
}
void thread_b() {
auto local = sp; // 拷贝一份,引用计数 +1,安全
(*local)++;
}
// 不安全:多线程同时修改同一个 shared_ptr 实例
std::shared_ptr<int> global_sp;
void thread_c() {
global_sp = std::make_shared<int>(10); // 数据竞争
}
void thread_d() {
auto local = global_sp; // 数据竞争
}
// 需要加锁保护 global_sp 的读写
std::mutex mtx;
void safe_write() {
std::lock_guard<std::mutex> lock(mtx);
global_sp = std::make_shared<int>(10);
}
常见误区
- 误区:shared_ptr 是线程安全的可以随便用?正解:引用计数安全,但 shared_ptr 对象本身不是。
- 误区:用 shared_ptr 管理的对象就不需要同步了?正解:对象本身的并发访问仍需同步。
追问 / 延伸
- 如何在多线程中安全地传递 shared_ptr?答:每个线程持有自己的副本,不要共享同一个 shared_ptr 实例;需要替换时用 mutex 保护。
- std::atomic<std::shared_ptr
> 是什么?答:C++20 提供的原子 shared_ptr,把对 shared_ptr 实例的读写变成原子操作。
04.9.1-005 什么是移动语义?右值引用解决什么问题?
频率 ★★★★☆ | 难度 高级
一句话结论
移动语义允许把一个对象的资源(堆内存、文件句柄等)"偷"给另一个对象,而不是深拷贝,避免不必要的拷贝开销;右值引用 T&& 是实现移动语义的语言机制。
概念解释
- 左值:有名字、可以取地址的表达式。
- 右值:临时对象、即将销毁的值,没有名字。
- 右值引用
T&&:绑定到右值的引用,允许修改右值(因为我们要"偷"它的资源)。 - 移动构造函数
T(T&& other):把 other 的资源指针置空,把所有权转移给新对象。 std::move:只是一个类型转换,把左值转为右值引用,不移动任何东西。
原理流程
- 函数返回一个局部对象时,如果没有移动语义,会发生拷贝构造(堆上数据复制)。
- 有了移动构造,编译器检测到返回值是即将销毁的临时对象,调用移动构造,直接把内部指针转移过来,O(1) 完成。
std::move(obj)告诉编译器:我不再需要这个 obj 了,可以把它的资源搬走。- 移动后原对象处于"有效但未指定"的状态,通常应该把它当作空对象。
代码 / 示例
#include <vector>
#include <utility>
class Buffer {
public:
Buffer(size_t n) : data_(new int[n]), size_(n) {}
~Buffer() { delete[] data_; }
// 拷贝构造:深拷贝
Buffer(const Buffer& other) : data_(new int[other.size_]), size_(other.size_) {
for (size_t i = 0; i < size_; i++) data_[i] = other.data_[i];
}
// 移动构造:偷资源
Buffer(Buffer&& other) noexcept : data_(other.data_), size_(other.size_) {
other.data_ = nullptr; // 原对象置空
other.size_ = 0;
}
private:
int* data_;
size_t size_;
};
int main() {
std::vector<int> v1 = {1, 2, 3, 4, 5};
std::vector<int> v2 = std::move(v1); // 移动,v1 变空
// v1.size() == 0,v2 持有原来的堆内存
return 0;
}
常见误区
- 误区:std::move 会移动对象?正解:std::move 只是强制类型转换,真正的移动发生在移动构造/移动赋值函数里。
- 误区:移动后原对象还能用?正解:移动后原对象处于有效但未指定状态,通常只应该析构或重新赋值。
追问 / 延伸
- 为什么移动构造函数要加 noexcept?答:如果不加 noexcept,std::vector 在扩容时可能因为担心移动构造抛异常而退回到拷贝构造,失去移动的性能优势。
- 什么是移动赋值?答:
T& operator=(T&& other),先释放自己的资源,再把 other 的资源偷过来。
04.9.1-006 RAII 是什么?解决什么问题?
频率 ★★★★★ | 难度 基础
一句话结论
RAII(Resource Acquisition Is Initialization)把资源的获取和对象的生命周期绑定:对象构造时获取资源,对象析构时自动释放资源,不管是正常离开作用域还是异常展开,资源都能正确释放。
概念解释
- 资源:堆内存、文件句柄、锁、网络连接、数据库连接等。
- RAII 核心思想:用栈对象管理资源,利用栈对象离开作用域自动调用析构函数的机制,自动释放资源。
- 典型例子:std::lock_guard、std::unique_ptr、std::fstream。
原理流程
- 构造函数中获取资源(malloc、open、lock 等)。
- 析构函数中释放资源(free、close、unlock 等)。
- 不管作用域是正常结束还是抛异常展开,栈对象的析构函数一定会被调用,资源不会泄漏。
- 这是 C++ 异常安全的核心机制。
代码 / 示例
#include <mutex>
#include <fstream>
// 手动管理锁的问题:异常时忘记 unlock
void bad_lock(std::mutex& mtx) {
mtx.lock();
if (do_something() == -1) {
throw std::runtime_error("error");
// mtx.unlock() 没执行到,锁永远不释放
}
mtx.unlock();
}
// RAII 方式:lock_guard 自动 unlock
void good_lock(std::mutex& mtx) {
std::lock_guard<std::mutex> lock(mtx); // 构造时 lock
if (do_something() == -1) {
throw std::runtime_error("error");
// 栈展开时 lock 析构,自动 unlock
}
} // 离开作用域时 lock 析构,自动 unlock
// 文件句柄的 RAII
void read_file(const char* path) {
std::ifstream file(path); // 构造时 open
std::string line;
while (std::getline(file, line)) {
// ...
}
} // 离开作用域时 ifstream 析构,自动 close
常见误区
- 误区:RAII 只是智能指针?正解:所有需要获取和释放成对的资源都适合 RAII,锁、文件、连接都可以。
- 误区:try-finally 和 RAII 一样?正解:try-finally 需要手动写 finally 块,容易遗漏;RAII 把释放逻辑藏在析构函数里,不可能漏。
追问 / 延伸
- RAII 和异常安全的关系?答:没有 RAII,异常展开时手动管理的资源会泄漏;有了 RAII,所有栈上的 RAII 对象都会正确析构。
- 什么是异常安全的几个等级?答:基本保证(不泄漏)、强保证(回滚到操作前状态)、不抛保证(noexcept)。
04.9.1-007 什么是悬空指针?怎么产生的?怎么避免?
频率 ★★★★★ | 难度 进阶
一句话结论
悬空指针是指向已经被释放(或无效)的内存的指针,继续访问会导致未定义行为;常见于 free/delete 后忘记置空、局部变量地址被返回、对象析构后成员指针被使用。
概念解释
- 野指针:未初始化的指针,指向随机地址。
- 悬空指针:曾经有效,但指向的内存已经被释放或对象已析构。
- 内存泄漏:该释放的没释放,程序还在跑但内存越来越少。
- 悬空指针比内存泄漏更危险,因为访问悬空指针会立刻崩溃或产生诡异行为。
原理流程
- 动态分配内存,用完 delete,但指针本身没有置空。
- 后续代码又通过这个指针访问内存——此时这块内存可能已经被分配给别的对象。
- 函数返回局部变量的地址,函数结束后栈帧销毁,返回的指针指向无效栈空间。
- 两个对象互相持有对方的 shared_ptr,形成循环引用,对象析构后内部指针变成悬空的。
代码 / 示例
// 情况一:delete 后继续使用
int* p = new int(42);
delete p;
// p 现在是悬空指针
*p = 10; // 未定义行为,可能崩溃也可能不崩溃
// 情况二:返回局部变量地址
int* bad_func() {
int x = 10;
return &x; // x 在栈上,函数返回后栈帧销毁
} // 返回的指针是悬空的
// 情况三:对象析构后访问成员指针
struct Widget {
int* data;
Widget() { data = new int(42); }
~Widget() { delete data; }
};
void use_after_free() {
Widget* w = new Widget();
int* p = w->data;
delete w; // w 析构,data 被 delete
*p = 10; // p 是悬空指针,未定义行为
}
// 避免方法:delete 后置空
int* p = new int(42);
delete p;
p = nullptr; // 之后再用 *p 会立刻崩溃(段错误),容易发现
常见误区
- 误区:delete 后指针会自动变空?正解:不会。delete 只是释放内存,指针本身的值不变,还是原来的地址。
- 误区:悬空指针访问一定会崩溃?正解:不一定。如果那块内存还没被复用,读出来可能还是原来的值;一旦被复用,就会产生数据损坏。
追问 / 延伸
- 怎么检测悬空指针?答:用 AddressSanitizer(-fsanitize=address)可以检测 use-after-free。
- 智能指针能避免悬空指针吗?答:shared_ptr/weak_ptr 可以通过 weak_ptr::expired() 检查对象是否还存活;unique_ptr 因为独占,不存在多个指针的问题。
04.9.1-008 什么是完美转发 std::forward?
频率 ★★★★☆ | 难度 高级
一句话结论
完美转发让函数模板可以把参数按原来的值类别(左值/右值)转发给另一个函数,既不丢失移动语义,又不需要写左值和右值两个版本。
概念解释
- 引用折叠:T& & -> T&,T& && -> T&,T&& & -> T&,T&& && -> T&&。
- 万能引用(转发引用):模板函数参数
T&&中,T 是模板参数,此时T&&不是右值引用,而是能接受左值和右值的万能引用。 - std::forward
(arg):有条件的转换,当 T 是右值引用时转成右值,否则保持左值。 - std::move 是无条件转右值;std::forward 是按类型 T 有条件转。
原理流程
- 模板函数
template<class T> void f(T&& arg)中,传入左值时 T 推导为int&,传入右值时 T 推导为int。 - 在函数内部,arg 是一个有名字的变量,所以它是左值——直接传给另一个函数会变成拷贝,丢失移动语义。
- 用
std::forward<T>(arg):如果原来传入的是右值,T 是 int,forward 把 arg 转回右值;如果原来传入的是左值,T 是 int&,forward 保持左值。 - 这样就实现了"参数是什么类别,转发出去还是什么类别"。
代码 / 示例
#include <utility>
#include <iostream>
void process(int& x) { std::cout << "左值: " << x << std::endl; }
void process(int&& x) { std::cout << "右值: " << x << std::endl; }
template <typename T>
void wrapper(T&& arg) {
// 直接调用 process(arg):arg 是有名字的变量,永远走左值版本
// process(arg);
// 用完美转发:保持原来的值类别
process(std::forward<T>(arg));
}
int main() {
int a = 42;
wrapper(a); // 传入左值,输出 "左值: 42"
wrapper(100); // 传入右值,输出 "右值: 100"
return 0;
}
// 典型应用:emplace_back
// vector::emplace_back<Args...>(Args&&... args)
// : construct(std::forward<Args>(args)...)
// 把用户传入的参数完美转发给 T 的构造函数,避免不必要的临时对象
常见误区
- 误区:std::forward 和 std::move 一样?正解:std::move 无条件转右值;std::forward 只在模板参数 T 表示右值时才转右值。
- 误区:所有 T&& 都是右值引用?正解:只有当 T 不是模板参数时才是右值引用;模板函数里的 T&& 是万能引用。
追问 / 延伸
- 为什么需要完美转发?答:写泛型容器和工厂函数时,不想为左值和右值各写一个版本,用完美转发一份代码搞定。
- 引用折叠规则为什么需要?答:因为模板推导中可能出现 T& && 这样的组合,语言规定折叠成 T&,让代码可以正确编译。
待整理清单
- [ ] C++20 智能指针增强与 make_shared 数组版本
- [ ] 对象池与内存池设计
- [ ] RAII 在异常安全等级中的实战
- [ ] volatile 与 atomic 的区别