Skip to main content

Chapter 4: Memory Management

核心问题与阅读主线

本章导读6 个核心小节 · 附自检与总结

STL 容器必须把“原始存储”与“对象生命周期”拆开管理——正如 std::vector<int> v; v.reserve(8); v.emplace_back(1); v.clear(); 依次只推进容量、构造、析构与最终释放。本章沿分配接口、构造边界、内存布局与异常安全提交点,建立阅读 vector、list、deque 与 allocator 源码的统一分析路径。

全章共用代码样本(下文各节持续拆解)

贯穿材料核心代码

本章以极简动态数组 IntBuffer 作为贯穿材料,用 begin_、end_、cap_ 三个指针划分已构造区间 [begin_, end_) 与未构造容量区间 [end_, cap_):

#include <cstddef>
#include <memory>
#include <new>
#include <utility>

class IntBuffer {
public:
void reserve(std::size_t new_cap) {
if (new_cap <= capacity()) {
return;
}

int* new_begin = static_cast<int*>(::operator new(new_cap * sizeof(int)));
int* new_end = new_begin;

try {
for (int* p = begin_; p != end_; ++p, ++new_end) {
std::construct_at(new_end, std::move(*p));
}
} catch (...) {
for (int* p = new_begin; p != new_end; ++p) {
std::destroy_at(p);
}
::operator delete(new_begin);
throw;
}

for (int* p = begin_; p != end_; ++p) {
std::destroy_at(p);
}
::operator delete(begin_);

begin_ = new_begin;
end_ = new_end;
cap_ = new_begin + new_cap;
}

void push_back(int value) {
if (end_ == cap_) {
reserve(capacity() == 0 ? 1 : capacity() * 2);
}
std::construct_at(end_, value);
++end_;
}

void clear() noexcept {
for (int* p = begin_; p != end_; ++p) {
std::destroy_at(p);
}
end_ = begin_;
}

~IntBuffer() {
clear();
::operator delete(begin_);
}

private:
std::size_t capacity() const noexcept {
if (begin_ == nullptr) {
return 0;
}
return static_cast<std::size_t>(cap_ - begin_);
}

int* begin_ = nullptr;
int* end_ = nullptr;
int* cap_ = nullptr;
};

四步职责严格分离:::operator new 取得满足对齐的原始存储,std::construct_at 开启对象生命周期,std::destroy_at 结束生命周期,::operator delete 归还存储——这正是 STL 将 size 与 capacity 拆成两个独立状态的原因。

4.1 分配接口:malloc / free 与 operator new / delete​

malloc / free 与 operator new / operator delete 都处在字节级原始存储层,不调用构造函数也不执行析构函数。STL 容器通过 allocator 进入分配路径(默认通常落到 C++ 分配函数),以便把存储取得、元素构造、异常清理与最终释放拆成可独立控制的阶段。

对比维度malloc / freeoperator new / operator delete
输入与输出接收字节数,返回 void*接收字节数,返回 void*
失败处理返回 nullptr常规版本抛出 std::bad_alloc
对象语义不构造也不析构,仅提供字节存储不构造也不析构;需由 construct_at 或 new expression 建构对象
释放配对必须由 free 释放必须由匹配的 operator delete 释放
典型定位C 接口兼容、纯字节缓冲、底层自定义分配器C++ 存储分配基元、new expression 与 allocator 默认底层

下面的 manual_object_path 把“取得存储”与“管理对象生命周期”显式拆开:

struct Widget {
Widget(int value) : value(value) {}
~Widget() {}
int value;
};

void manual_object_path() {
void* raw = ::operator new(sizeof(Widget));
Widget* ptr = nullptr;

try {
ptr = std::construct_at(static_cast<Widget*>(raw), 42);
} catch (...) {
::operator delete(raw);
throw;
}

std::destroy_at(ptr);
::operator delete(raw);
}

核心判断

阅读分配路径时必须锁死四道边界:operator new(或 malloc)只代表“取得存储”;std::construct_at 或 placement new 才进入“对象存在”;std::destroy_at 结束对象生命周期;operator delete(或 free)归还存储。混用释放接口会破坏分配器内部账本。

4.2 new / delete expression 的组合动作​

语言级 new / delete expression 把存储分配与对象初始化、析构与存储释放合并为单一表达式:

  • 单对象路径:new Widget(42) 先调用 operator new 再初始化对象;delete p 先调用析构函数再调用匹配的 operator delete。
  • 数组路径:new[] 与 delete[] 独立配对,常见实现会在数组存储附近写入元素计数元数据(array cookie),供 delete[] 按元素逆序析构。

下面的对比展示组合表达式与手动拆解路径的四阶段对应关系:

void expression_path() {
Widget* p = new Widget(42);
delete p;
}

void roughly_equivalent_manual_path() {
void* raw = ::operator new(sizeof(Widget));
Widget* p = nullptr;

try {
p = std::construct_at(static_cast<Widget*>(raw), 42);
} catch (...) {
::operator delete(raw);
throw;
}

std::destroy_at(p);
::operator delete(raw);
}

语言表达式与容器分离路径的工程差异集中在构造时机与异常清理责任:

机制构造与析构时机构造抛异常时的清理责任为何(不)适合容器容量管理
new T(...) / delete p分配后立即构造单个对象;释放前析构语言自动调用匹配的 operator delete 归还存储仅管理单个对象,无容量预留概念
new T[n] / delete[] p一次性默认构造 n 个元素;delete[] 逆序析构已构造前缀逆序析构,再释放整块存储强制将空余容量构造为真实对象,无法低成本区分 size() 与 capacity()
容器分离路径(allocate + construct_at)先取得原始存储,再按元素数量逐个构造与销毁容器或调用方必须在 catch 中析构已构造前缀并释放存储可独立维护已构造区间与预留容量区间

边界与误区

注意

new 与 delete、new[] 与 delete[] 必须严格成对使用,不能跨路径混用释放接口。此外,真实的 new / delete expression 还会参与类内重载分配函数、对齐感知分配以及构造异常时的匹配释放函数查找,并非固定等同于全局 ::operator new。

容器源码正是把单次 new / delete 隐藏的状态跃迁拆开显式调度:

图中未画出多元素迁移边界:扩容批量构造若中途失败,仅已跃迁到 LiveObject 的前缀需要回滚析构,旧存储中的原有对象在提交点之前保持有效。

4.3 placement new、raw memory 与 uninitialized memory​

placement new(new (address) T(args...))在调用方提供的地址上直接构造对象而不申请堆内存(标准库形式 operator new(std::size_t, void*) 直接返回传入地址),并随即建立析构责任。

STL 中的 raw memory / uninitialized memory(如 vector 扩容后 [end_, cap_) 区间)表示已分配但尚无活跃对象的存储区域:

  • 显式原地构造:C++20 的 std::construct_at(p, args...) 与早期 placement new ::new (static_cast<void*>(p)) T(args...) 职责相同,负责把已对齐的原始存储转为有效对象。
  • 批量生命周期工具:容器与 allocator 源码常使用 std::allocator_traits<A>::construct、std::uninitialized_move、std::uninitialized_copy 与 std::destroy 处理成段构造和销毁。

下面的例子在 std::byte 局部缓冲区上完成构造与销毁:

#include <cstddef>
#include <memory>
#include <new>

void construct_in_local_buffer() {
alignas(Widget) std::byte storage[sizeof(Widget)];

Widget* p = std::construct_at(
reinterpret_cast<Widget*>(storage),
7
);

std::destroy_at(p);
}

边界与误区

注意

缓冲区必须同时满足 sizeof(T) 与 alignas(T);reinterpret_cast 只改变指针类型,绝不开启对象生命周期。同时严禁对 [end_, cap_) 等未构造区域执行普通赋值(operator=),因为赋值假定目标位置已有合法对象。

批量构造必须通过游标追踪已经进入生命周期的前缀,保证部分失败时不越界析构:

template <class T>
T* uninitialized_move_range(T* first, T* last, T* dest) {
T* current = dest;
try {
for (; first != last; ++first, ++current) {
std::construct_at(current, std::move(*first));
}
return current;
} catch (...) {
for (T* p = dest; p != current; ++p) {
std::destroy_at(p);
}
throw;
}
}

核心变量 current 严格划定了异常清理的区间边界:

  • [dest, current):已构造为有效对象,异常时必须逐个执行 std::destroy_at。
  • [current, dest + n):仍是未构造原始存储,严禁执行析构操作。
  • 旧区间 [first, last):在新状态提交前须保持可清理状态。

排查顺序

  1. 先找分配接口取得的原始存储范围;
  2. 再找当前已构造对象边界与未构造空余区间;
  3. 检查异常路径是否只销毁已构造前缀;
  4. 最后定位提交点如何更新 begin、end、capacity 状态。

4.4 对齐、cache locality 与内存碎片​

时间复杂度只刻画操作次数增长,而对象对齐、cache locality 与内存碎片直接决定容器的实际运行与内存成本。

allocator::allocate 必须返回满足 alignof(T) 的地址;面对超过默认 new 对齐上限的过对齐类型(如 std::vector<CacheLineSlot>),C++17 会触发带 std::align_val_t 的对齐感知 operator new / operator delete 路径:

struct alignas(64) CacheLineSlot {
int value;
};

static_assert(alignof(CacheLineSlot) == 64);

连续存储使线性访问高度契合 cache line 复用与硬件预取,指针顺序递增即对应物理地址递增:

int sum_contiguous(const int* first, const int* last) {
int total = 0;
for (const int* p = first; p != last; ++p) {
total += *p;
}
return total;
}

关键事实

内存碎片分两类:外部碎片指空闲空间总量充足但被割裂成离散小块,导致大块连续分配失败;内部碎片指对象对齐填充、分配器元数据或 size class 向上取整导致的块内空间浪费。

结合布局成本、局部性与稳定性,连续容器与节点容器的选型取舍如下:

评估维度连续存储容器(如 vector)节点存储容器(如 list)
遍历局部性地址连续,利于 cache line 命中与硬件预取节点离散,需追踪 next 指针,易触发 cache miss
碎片与空间开销无单元素元数据,但扩容瞬时存在新旧双份内存峰值每节点独立分配并携带指针/分配器元数据,易产生内部与外部碎片
修改成本尾部摊还开销低;扩容或中间插删需批量迁移元素节点重连无需移动既有元素,开销分摊到单次节点分配
指针与 iterator 稳定性扩容或插入点之后会令指针、引用和 iterator 失效仅被删除节点自身失效,其余节点链接保持稳定

4.5 内存池与 allocator 策略入口​

内存池针对“大量近似尺寸对象高频分配释放”的场景:预先申请较大内存块并切分为固定或少数几类尺寸的 slot,通过空闲链表分发与回收,从而减少底层分配调用并提升同类对象的地址聚集度。

最关键的职责边界在于:内存池只改变存储来源与复用方式,不接管对象生命周期。对象仍须在取得的 slot 上构造,失效时先行析构,然后才能把 slot 归还给池;STL 中 allocator 的 allocate / deallocate 与 std::allocator_traits 正对应这层分工。

下面的 FixedIntPool 演示基于空闲链表的定长 slot 复用:

#include <cstddef>
#include <new>
#include <vector>

class FixedIntPool {
public:
int* allocate_one() {
if (free_ == nullptr) {
grow();
}
Node* node = free_;
free_ = free_->next;
return reinterpret_cast<int*>(node);
}

void deallocate_one(int* p) noexcept {
Node* node = reinterpret_cast<Node*>(p);
node->next = free_;
free_ = node;
}

~FixedIntPool() {
for (void* block : blocks_) {
::operator delete(block);
}
}

private:
union Node {
Node* next;
alignas(int) unsigned char storage[sizeof(int)];
};

void grow() {
constexpr std::size_t block_count = 64;
Node* block = static_cast<Node*>(::operator new(sizeof(Node) * block_count));
blocks_.push_back(block);
for (std::size_t i = 0; i < block_count; ++i) {
block[i].next = free_;
free_ = &block[i];
}
}

Node* free_ = nullptr;
std::vector<void*> blocks_;
};

union Node 的复用要求调用方严格隔离状态:slot 在空闲链表中读写 next 指针,分配出去后只能按 int 对象访问;一般池化 allocator 会把这类状态切换封装在接口之下。

以 C++17 std::pmr::vector<T> 为例,allocator 将容器的存储来源策略化,而容器仍负责维护元素数量、构造边界、异常回滚与 iterator 失效规则:

分配策略适用生命周期特征空间复用与释放方式主要工程代价
默认 allocator(普通堆)通用生命周期与混合对象尺寸单次独立申请与释放,直接归还底层分配器高频小对象分配时底层调用次数多
std::pmr 单调缓冲资源批量创建、阶段性整体销毁顺序推进缓冲指针分配,结束时整块一次性释放提前释放单对象无法原地复用
std::pmr 池资源大量同尺寸或近似尺寸对象反复分配释放按空闲链表复用 slot,降低大块申请频率产生内部碎片,且可能滞留未还系统的空闲内存

边界与误区

注意

池化并非“必然更快”:除可能扣留已释放给池但尚未归还系统的内存、产生内部碎片外,跨线程共享池还需同步锁或线程本地策略,对象尺寸离散时分桶开销也会急剧上升。是否引入池化 allocator 应依据实测分配频率、尺寸分布、批量释放模式与内存峰值决策。

4.6 STL 容器的内存管理路径​

无论 vector(连续存储)、list(节点存储)还是 deque(分段存储),底层都必须守住存储范围与对象生命周期的边界。以 vector 的三指针状态模型为例:

template <class T>
struct VectorState {
T* begin;
T* end;
T* cap;
};

// [begin, end) : live objects
// [end, cap) : raw storage reserved for future objects

容器的插入、删除、扩容与清空操作,本质上都在同步维护这两个区间的一致性:

  • push_back 的快慢路径:end != cap 时直接在 end 原地构造新元素并推进 end(常数代价);end == cap 时触发扩容分配、迁移旧元素并释放旧块,造成单次线性代价(摊还仍为常数)。
  • erase 的区间维护:连续容器删除元素后需将后续元素前移赋值或移动构造、析构末尾多余元素并回退 end;节点容器则只需断开链接、析构节点元素并释放该节点存储。

扩容异常安全依赖“两阶段提交”设计——在新存储全部构造成功前,旧状态保持完整可用:

真实 STL 实现常把提交点 E 封装在局部 guard 或内部提交函数中;阅读源码时只需定位成员指针或控制结构在何处被覆盖,即可切分“异常回滚新存储”与“清理旧存储”两段路径。

排查顺序

  1. 区分容器持有的存储范围与已构造对象范围;
  2. 定位构造与析构动作的发生位置;
  3. 检查底层分配函数与释放函数是否严格配对;
  4. 核对异常路径是否仅回滚部分构造的新元素;
  5. 将内存布局映射到移动成本与 iterator 失效规则。

最小自检任务​

动手自检先独立判断

阅读下面的 build_items 代码,判断其生命周期管理路径是否正确,并逐项回答:

  1. 哪一段代码取得原始存储?此时内存处于什么状态?
  2. 哪一段代码开启对象生命周期?current 扮演什么角色?
  3. 构造中途抛异常时,哪些区间需要析构、哪些不能析构?
  4. 全部构造成功后,销毁与释放顺序为何必须如此安排?
struct Item {
Item(int value) : value(value) {}
Item(const Item& other) : value(other.value) {}
~Item() {}
int value;
};

void build_items(const Item* source, std::size_t count) {
Item* buffer = static_cast<Item*>(::operator new(sizeof(Item) * count));
Item* current = buffer;

try {
for (std::size_t i = 0; i < count; ++i, ++current) {
std::construct_at(current, source[i]);
}
} catch (...) {
for (Item* p = buffer; p != current; ++p) {
std::destroy_at(p);
}
::operator delete(buffer);
throw;
}

for (Item* p = buffer; p != current; ++p) {
std::destroy_at(p);
}
::operator delete(buffer);
}

本章知识点总结​

  • 存储与对象分离

    malloc、operator new 与 allocator allocate 只取得满足对齐的原始存储,对象生命周期必须由 std::construct_at 或 placement new 显式开启。

  • 组合表达式边界

    new / delete 合并分配与生命周期动作并自动处理单对象构造异常回滚;new[] / delete[] 依赖元素计数元数据,必须严格成对使用。

  • 未构造区间规则

    容器预留容量 [end, cap) 属于 raw memory,严禁直接赋值或析构;批量构造必须使用游标追踪已构造前缀边界。

  • 局部性与碎片权衡

    连续容器遍历局部性高但扩容迁移会令引用与 iterator 失效;节点容器链接稳定但小块分配更易放大碎片与指针追踪开销。

  • 池化与 allocator

    内存池与 std::pmr 只策略化存储来源与 slot 复用,对象构造/析构责任与复用状态边界仍须严格隔离。

  • 提交点与异常安全

    容器扩容必须先在新存储完成全量构造,全部成功后再提交成员指针,失败则仅清理新存储已构造前缀并保留旧状态。

  • 源码检查线

    阅读 STL 容器内存源码按“存储区间、对象区间、配对释放、部分异常回滚、布局与失效后果”五步定位状态边界。