罗罗编程学习记录
本页内容 展开查看

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,可以 ++ 做指针运算。
  • 引用:不占独立内存(实现上常是指针,但语法层面是别名),必须在定义时初始化绑定到某个对象,之后不能再绑定到别的对象。
  • 引用的底层实现通常就是指针,但语法上对使用者透明。

原理流程

  1. 指针声明后可以不初始化(野指针风险),可以赋值为 nullptr。
  2. 引用必须在声明时就绑定到一个已有对象,后续所有对引用的操作都直接作用于原对象。
  3. 函数参数中用引用可以避免拷贝,同时语义上比指针更明确(不为空)。

代码 / 示例

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:函数调用时的栈帧,存放局部变量、函数参数、返回地址,向下(低地址)增长。

原理流程

  1. 程序加载时,操作系统把代码段和数据段映射到进程地址空间。
  2. 堆从 brk 开始向上扩展,通过系统调用 sbrk/mmap 调整。
  3. 栈从高地址开始向下增长,每次函数调用压入一个栈帧。
  4. 堆和栈之间的区域是共享库映射区和未分配空间。

代码 / 示例

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 才能访问对象。

原理流程

  1. unique_ptr 通过删除拷贝构造和拷贝赋值、只保留移动构造来实现独占语义,大小和裸指针一样。
  2. shared_ptr 内部包含两个指针:一个指向对象,一个指向控制块(引用计数、弱计数、删除器、分配器)。
  3. shared_ptr 拷贝时原子递增引用计数,析构时原子递减,计数归零时 delete 对象。
  4. 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 实例会产生数据竞争。
  • 指向的对象:如果多线程读写同一个对象,对象本身需要自己同步。

原理流程

  1. shared_ptr 拷贝构造时,原子操作把控制块的强计数加 1。
  2. shared_ptr 析构时,原子操作把强计数减 1,归零时 delete 对象。
  3. 但 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:只是一个类型转换,把左值转为右值引用,不移动任何东西。

原理流程

  1. 函数返回一个局部对象时,如果没有移动语义,会发生拷贝构造(堆上数据复制)。
  2. 有了移动构造,编译器检测到返回值是即将销毁的临时对象,调用移动构造,直接把内部指针转移过来,O(1) 完成。
  3. std::move(obj) 告诉编译器:我不再需要这个 obj 了,可以把它的资源搬走。
  4. 移动后原对象处于"有效但未指定"的状态,通常应该把它当作空对象。

代码 / 示例

#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。

原理流程

  1. 构造函数中获取资源(malloc、open、lock 等)。
  2. 析构函数中释放资源(free、close、unlock 等)。
  3. 不管作用域是正常结束还是抛异常展开,栈对象的析构函数一定会被调用,资源不会泄漏。
  4. 这是 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 后忘记置空、局部变量地址被返回、对象析构后成员指针被使用。

概念解释

  • 野指针:未初始化的指针,指向随机地址。
  • 悬空指针:曾经有效,但指向的内存已经被释放或对象已析构。
  • 内存泄漏:该释放的没释放,程序还在跑但内存越来越少。
  • 悬空指针比内存泄漏更危险,因为访问悬空指针会立刻崩溃或产生诡异行为。

原理流程

  1. 动态分配内存,用完 delete,但指针本身没有置空。
  2. 后续代码又通过这个指针访问内存——此时这块内存可能已经被分配给别的对象。
  3. 函数返回局部变量的地址,函数结束后栈帧销毁,返回的指针指向无效栈空间。
  4. 两个对象互相持有对方的 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 有条件转。

原理流程

  1. 模板函数 template<class T> void f(T&& arg) 中,传入左值时 T 推导为 int&,传入右值时 T 推导为 int。
  2. 在函数内部,arg 是一个有名字的变量,所以它是左值——直接传给另一个函数会变成拷贝,丢失移动语义。
  3. 用 std::forward<T>(arg):如果原来传入的是右值,T 是 int,forward 把 arg 转回右值;如果原来传入的是左值,T 是 int&,forward 保持左值。
  4. 这样就实现了"参数是什么类别,转发出去还是什么类别"。

代码 / 示例

#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 的区别