C++ on Snow

C++ STL的底层实现

Wed, 25 Mar 2026 22:03:05 +0800

前言

C++ 标准模板库（Standard Template Library, STL）是泛型编程的巅峰之作，它首次将数据结构与算法解耦，通过迭代器这一 “胶合剂” 实现了组件的高度复用。而在众多 STL 实现中，SGI STL无疑是最经典、最深入的一个版本，它不仅是 GCC libstdc++ 的基础，更是无数 C++ 开发者深入理解底层实现的必读范本。

本文将基于 SGI STL 3.3 版本的源码，从空间配置器到迭代器萃取，从序列容器到红黑树，从哈希表到混合排序算法，全方位、无死角地剖析 STL 的底层实现细节，带你彻底搞懂每一个 API 背后的内存布局与性能逻辑。

一、STL 整体架构：六大组件的协作

STL 的设计哲学是 “分而治之”，它将整个库拆分为六大独立但可协作的组件：

空间配置器（Allocator）：负责内存的分配与管理，解决内存碎片与分配效率问题
容器（Containers）：负责数据的存储，提供不同的数据结构实现
迭代器（Iterators）：作为容器与算法之间的桥梁，实现泛型访问
算法（Algorithms）：负责数据的处理，提供通用的操作逻辑
仿函数（Functors）：作为算法的策略参数，定制化行为
适配器（Adapters）：负责接口的转换，让不同组件可以相互适配

这种架构使得每一个组件都可以独立进化，同时又能通过标准接口无缝协作，这也是 STL 能够历经数十年依然保持活力的核心原因。

二、空间配置器：STL 的内存基石

很多人以为 STL 的内存管理就是简单的new/delete封装，但实际上，SGI STL 的空间配置器是工业级内存管理的典范，它通过两级配置机制，完美解决了小对象频繁分配导致的内存碎片与性能损耗问题。

2.1 两级配置器的设计思想

SGI STL 的std::alloc配置器将内存请求分为两类，分别处理：

大块内存（>128 字节）：直接调用系统的malloc/free进行分配
小块内存（<=128 字节）：通过内存池 + 空闲链表进行管理，避免碎片

2.2 空闲链表：16 个桶的精准管理

为了管理小块内存，SGI 设计了 16 个空闲链表（free_list），每个链表负责管理特定大小的内存块：

对齐策略：所有小块内存按 8 字节向上对齐
链表范围：8 字节、16 字节、24 字节… 直到 128 字节，共 16 种规格

enum {_ALIGN = 8};       // 对齐字节数
enum {_MAX_BYTES = 128}; // 最大管理字节
enum {_NFREELISTS = 16}; // 128/8=16个链表

union _Obj {
    // 当内存块未被分配时，_M_free_list_link 用来串联空闲块
    // 当内存块被分配后，_M_client_data 直接交给用户使用
    union _Obj* _M_free_list_link;
    char _M_client_data[1]; // 客户数据区
};
static _Obj* _S_free_list[_NFREELISTS];

union的特点是：有成员共享同一块内存，同一时间只用一个，这就实现了空间的复用：

空闲状态（没给用户）:

这个时候，我们把这个空闲块当成链表的节点，用它自己的前 8 字节（指针的大小），存下一个空闲块的地址。比如 16 字节的空闲块，前 8 字节存 next 指针，剩下的 8 字节？哦不对，整个 16 字节都是这个块的空间，前 8 字节存指针，剩下的 8 字节？不，整个 16 字节的块，前 8 字节用来存指针，剩下的 8 字节？不对，整个 16 字节的块，当它空闲的时候，我们只需要前 8 字节存指针，剩下的 8 字节暂时没用，反正也没人用。

分配状态（给用户了）:

当我们把这个块分配给用户的时候，我们就把它从 free_list 里摘出来了，那个 next 指针我们已经不需要了！这个时候，整个 16 字节的空间，全部交给用户用！用户拿到之后，会直接往里面写自己的数据，把原来的 next 指针直接覆盖掉，完全没问题。

释放的时候:

当用户用完了，把这个块释放回来，我们又把它插回 free_list 里。这个时候，我们又把下一个空闲块的指针，写到这个块的前 8 字节，把用户之前写的数据覆盖掉 —— 反正用户已经释放了，他也不管里面是什么了。

2.3 内存池

当某个空闲链表为空时，配置器不会每次只申请一个块，而是一次性向内存池申请 20 个相同大小的块，批量填充到空闲链表中。而如果内存池剩余的空间不足以满足 20 个块的需求，配置器会先把剩余的空间切成一个块放到对应的空闲链表里，然后再向系统申请一大块内存来补充内存池。

这种设计带来了巨大的性能提升：

减少系统调用次数：小对象分配不再需要每次调用malloc
降低内存碎片：避免了大量小内存块导致的堆碎片化
提升缓存命中率：连续的内存池布局让 CPU 缓存更高效

根据 SGI 官方测试，这种机制将小对象的分配速度提升了 3-5 倍，内存碎片率降低了 40% 以上。

2.4 构造与析构的分离

SGI STL 还将 “内存分配” 与 “对象构造” 彻底分离：

allocate()：只负责分配原始的内存空间，不调用构造函数。
construct()：在已分配的内存上调用 placement new 构造对象。
destroy()：调用对象的析构函数，不释放内存。
deallocate()：释放原始的内存空间。

更重要的是，通过__type_traits，SGI 可以判断对象是否有 trivial 析构函数：

如果是 POD 类型（Plain Old Data，也就是 C 风格的数据类型），析构函数直接跳过，什么都不做
如果是非 POD 类型，才会逐个调用析构函数

这一优化在批量销毁大量小对象时，能节省大量的无用调用开销。

三、迭代器：容器与算法的胶合剂

如果说空间配置器是 STL 的基石，那么迭代器就是 STL 的骨架。它让算法可以完全不关心容器的具体实现，只通过统一的接口访问元素，这也是泛型编程的核心。

3.1 迭代器的设计模式

在 GoF（Gang of Four）的设计模式中，迭代器模式用来提供一种顺序访问聚合对象元素的方法，而不暴露其内部表示。STL 的迭代器正是这一思想的极致实现，但它比传统 OOP（面向对象编程）的迭代器更高效 —— 它是编译期的静态多态，没有虚函数的开销。

3.2 Traits：特性萃取的黑科技

为了让算法能够在编译期知道迭代器的类型，从而选择最优的实现（例如对随机访问迭代器直接用指针减法计算距离，而对双向迭代器只能逐个递增），STL 引入了 iterator_traits 萃取机制。

它的核心原理是模板偏特化：

// 泛化版本，适用于所有自定义迭代器，如 vector<T>::iterator、list<T>::iterator 等
template <class Iterator>
struct iterator_traits {
    typedef typename Iterator::value_type      value_type;
    typedef typename Iterator::difference_type difference_type;
    typedef typename Iterator::pointer         pointer;
    typedef typename Iterator::reference       reference;
    typedef typename Iterator::iterator_category iterator_category;
};

// 偏特化版本：针对原生指针，如 int*、char* 等
template <class T>
struct iterator_traits<T*> {
    typedef T                          value_type;
    typedef ptrdiff_t                  difference_type;
    typedef T*                         pointer;
    typedef T&                         reference;
    typedef random_access_iterator_tag iterator_category;
};

// 偏特化版本：针对const原生指针，如 const int* 等
template <class T>
struct iterator_traits<const T*> {
    typedef T                          value_type; // 萃取掉const！
    typedef ptrdiff_t                  difference_type;
    typedef const T*                   pointer;
    typedef const T&                   reference;
    typedef random_access_iterator_tag iterator_category;
};

这层萃取机完美解决了所有问题：

对于自定义迭代器，它提取其内部定义的型别
对于原生指针，它通过偏特化，手动提供对应的型别
对于 const 指针，它还能自动去掉 const，保证value_type永远是可变的类型

通过这个机制，算法可以在编译期自动 “萃取” 出迭代器的属性，从而实现零成本的抽象。不管你是自定义迭代器还是原生指针，算法都能通过它，问清楚你能干啥，然后选最快的办法干活。

3.3 迭代器的五种分类

STL 根据迭代器支持的操作，将其分为 5 类，能力依次增强：

迭代器类型	支持的操作	典型容器
输入迭代器 (Input)	只读，单向遍历，只能读一次	`istream_iterator`
输出迭代器 (Output)	只写，单向遍历	`ostream_iterator`
前向迭代器 (Forward)	读写，单向遍历，可多次遍历	`forward_list`
双向迭代器 (Bidirectional)	读写，双向遍历 (`++`/`--`)	`list`, `map`, `set`
随机访问迭代器 (Random Access)	读写，随机跳转 (`it+n`, `it-n`)	`vector`, `deque`, `string`

算法会根据迭代器的类别，自动选择最优的实现。比如copy算法，如果是随机访问迭代器，就会直接用memcpy批量拷贝；如果是双向迭代器，就会逐个拷贝。

3.4 迭代器失效问题

迭代器失效是指当容器的内存结构发生变化时，原来的迭代器指向的内存可能已经失效，继续使用会导致未定义行为。不同容器的失效规则不同：

vector：扩容时所有迭代器失效；插入 / 删除点之后的迭代器失效。
deque：两端插入不会导致迭代器失效，但中间插入会导致所有迭代器失效。
list：只有指向被删除元素的迭代器失效，其他全部有效。
map/set：插入不会导致迭代器失效；只有指向被删除元素的迭代器失效。

四、序列式容器：线性存储的艺术

序列式容器是 STL 中最常用的容器，它们维护元素的线性顺序，不同的实现针对不同的操作做了优化。

4.1 std::vector：动态数组

vector 是 STL 中最基础也最高效的容器，它的底层是一个动态增长的连续数组。

4.1.1 核心内存布局

vector 的内部只维护了三个指针，这就是它的全部状态：

template <class T, class Alloc>
struct _Vector_base {
    T* _M_start;        // 指向第一个元素
    T* _M_finish;       // 指向最后一个有效元素的下一个位置
    T* _M_end_of_storage; // 指向分配的内存的末尾
};

这三个指针定义了 vector 的所有状态：

size() = _M_finish - _M_start：当前元素个数
capacity() = _M_end_of_storage - _M_start：当前容量
empty() = _M_start == _M_finish：是否为空

4.1.2 动态扩容策略

当push_back发现容量不足时，vector会触发扩容：

申请一块新的、更大的内存（通常是原来的 1.5~2 倍，GCC 为 2 倍，MSVC 为 1.5 倍）。
将旧内存中的元素拷贝 / 移动到新内存。
释放旧的内存。
更新三个指针。

这种指数扩容的策略保证了push_back的均摊时间复杂度是 O (1)，因为每 n 次插入才会触发一次 O (n) 的扩容，均摊下来每个插入的成本是常数。

4.1.3 迭代器失效的真相

正是因为 vector 的连续内存特性，导致了迭代器失效问题：

当扩容发生时，整个内存块被迁移，所有迭代器、指针、引用全部失效
当在中间插入 / 删除元素时，插入点之后的迭代器全部失效
尾部删除时，只有被删除的那个迭代器失效

这也是为什么我们在遍历 vector 时不能随意插入元素的原因。

4.2 std::list：双向循环链表

list 的底层是一个双向循环链表，它的每个节点都包含前驱和后继指针：

template <class T>
struct _List_node {
    _List_node* _M_prev;
    _List_node* _M_next;
    T _M_data;
};

为了简化边界处理，list 使用了一个哨兵节点（Sentinel Node），begin() 指向哨兵的 next，end() 指向哨兵自己，形成一个环。

list 的优势在于：

任意位置的插入 / 删除都是 O(1)，只需要修改指针
不会导致迭代器失效，除非删除的是当前元素
没有内存碎片问题，每个节点独立分配

但它的缺点也很明显：

不支持随机访问，遍历只能逐个移动
每个节点额外占用 16 字节（64 位系统）的指针开销
内存不连续，CPU 缓存命中率极低，遍历速度比 vector 慢 10-100 倍

4.3 std::deque：双端队列的分段魔法

deque 是 STL 中最复杂的序列容器，它是为了解决 vector 头部插入慢、list 随机访问慢的问题而生的。它实现了分段连续的存储，既支持 O(1) 的双端插入，又支持 O(1) 的随机访问。

它的底层既不是连续内存，也不是链表，而是分段连续内存 + 中控器的设计。

4.3.1 中控器：分段的管理者

deque 的核心是一个叫做map的中控器（注意不是 STL 的 map 容器），它是一个指针数组，每个元素指向一个固定大小的缓冲区（buffer）：

每个缓冲区是一段连续的内存，大小固定（默认 512 字节或根据元素大小调整）
中控器负责管理这些缓冲区，当需要在头部 / 尾部添加新的缓冲区时，只需要在 map 的前后新增指针即可
当 map 满了，才会重新分配一个更大的 map，把旧的指针拷贝过去

4.3.2 复杂的迭代器：维护连续的假象

为了让用户感觉 deque 是连续的，deque 的迭代器做了非常复杂的设计，它内部维护了四个指针：

struct __deque_iterator {
    T* cur;    // 当前指向的元素
    T* first;  // 当前缓冲区的起始
    T* last;   // 当前缓冲区的末尾
    T** node;  // 指向中控器中当前缓冲区的指针
};

当迭代器移动时：

如果还在当前缓冲区内，直接移动 cur 指针
如果到达缓冲区边缘，就通过 node 指针跳到下一个缓冲区，更新 first、last、cur

它的随机访问通过计算缓冲区的偏移来实现，而双端插入只需要新增缓冲区即可，完全不需要移动元素。

虽然内存是分段的，但 deque 依然支持 operator[]：

reference operator[](size_type n) {
  size_type offset = n + start.cur - start.first;
  size_type node_idx = offset / buffer_size();
  size_type elem_idx = offset % buffer_size();
  return map[start.node - map + node_idx][elem_idx];
}

通过一次计算就能定位到元素，时间复杂度依然是 O(1)。

4.4 std::string：小字符串优化 (SSO)

std::string 本质上是一个 vector<char>，但现代实现都加入了小字符串优化 (Small String Optimization, SSO)，以避免短字符串的堆分配开销。

SSO 的原理

string 对象内部通常有一个 union，用来区分短字符串和长字符串：

短字符串：当字符串长度小于阈值（GCC/libstdc++ 是 15，Clang/libc++ 是 22）时，字符直接存储在 string 对象内部的栈上缓冲区中，无需调用 malloc。
长字符串：当超过阈值时，才会在堆上分配内存，像传统的 string 一样存储指针、大小和容量。

这块内存，要么当短字符串的缓冲区，要么当长字符串的指针 + size+capacity，反正两种情况不会同时出现。

这就是为什么创建一个 "hello" 字符串比长字符串快得多的原因，它完全在栈上完成，没有系统调用开销。

4.5 容器适配器：接口的封装

std::stack、std::queue、std::priority_queue 这三个容器并不是独立的容器，它们是容器适配器，底层默认封装了 deque，通过修改接口来实现特定的语义：

stack：封装 deque，只暴露 push_back/pop_back，实现后进先出（LIFO）
queue：封装 deque，只暴露 push_back/pop_front，实现先进先出（FIFO）
priority_queue：封装 vector，在其上实现堆算法（堆排序），实现优先级队列

这种设计完美体现了 STL 的复用思想，不需要重新实现一遍数据结构，只需要包装一下接口即可。

五、关联式容器：有序的平衡二叉树

关联式容器用来存储键值对，支持高效的按键查找，它们的底层都是红黑树。

5.1 红黑树：自平衡的搜索树

红黑树是一种自平衡的二叉搜索树，它通过颜色标记和旋转操作，保证树的高度始终是 O(log n)，从而保证了所有操作的时间复杂度都是 O(log n)。

5.1.1 红黑树的节点结构

SGI 的红黑树节点包含了三叉链和颜色标记：

struct __rb_tree_node_base {
    typedef __rb_tree_color_type color_type;
    color_type color; // 节点颜色：红/黑
    __rb_tree_node_base* parent;
    __rb_tree_node_base* left;
    __rb_tree_node_base* right;
};

template <class Value>
struct __rb_tree_node : public __rb_tree_node_base {
    Value value_field; // 存储实际的值
};

红黑树的五条规则保证了它的平衡性：

节点要么是红色，要么是黑色
根节点是黑色和所有叶子节点（NIL 节点）是黑色
如果一个节点是红色，那么它的两个子节点都是黑色
从任意节点到其每个叶子（NIL 节点）的所有路径都包含相同数目的黑色节点

咸鱼的口诀：左根右，根叶黑，不红红，黑路同。

这保证了最长路径不会超过最短路径的 2 倍，从而保证了树的平衡。

5.1.2 插入与旋转

当插入新节点时，新节点默认为红色，并且按 BST（二叉搜索树） 的规则插入，然后检查是否破坏了红黑规则，如果破坏了，就通过变色和旋转（左旋转、右旋转）来调整，恢复平衡。

根据插入节点的位置和父节点的颜色，调整分为几种情况：

父节点是黑色：直接插入，不需要调整
父节点是红色：需要调整，分为以下几种情况：
- 1. 叔叔节点是红色（红叔）：父节点和叔叔节点变黑，祖父节点变红，继续向上调整
- 1. 叔叔节点是黑色且当前节点是父节点的右子节点：先左旋转父节点，再进行下一步调整
- 1. 叔叔节点是黑色且当前节点是父节点的左子节点：父节点变黑，祖父节点变红，右旋转祖父节点

可视化网站的链接：https://www.cs.usfca.edu/~galles/visualization/RedBlack.html。

比如左旋转的核心实现：

inline void _Rb_tree_rotate_left(_Rb_tree_node_base* x, _Rb_tree_node_base*& root) {
    // x 是当前节点，y 是 x 的右子节点
    _Rb_tree_node_base* y = x->_M_right;
    // 将 y 的左子树连接到 x 的右子树
    x->_M_right = y->_M_left;
    // 如果 y 的左子树不为空，更新它的父节点为 x
    if (y->_M_left != 0)
        y->_M_left->_M_parent = x;
    // 将 y 的父节点连接到 x 的父节点
    y->_M_parent = x->_M_parent;
    
    // 如果 x 是根节点，更新根节点为 y
    if (x == root) root = y;
    // 否则将 x 的父节点的左子节点连接到 y
    else if (x == x->_M_parent->_M_left)
        x->_M_parent->_M_left = y;
    // 否则将 x 的父节点的右子节点连接到 y
    else
        x->_M_parent->_M_right = y;
    // 将 x 连接到 y 的左子节点
    y->_M_left = x;
    // 更新 x 的父节点为 y
    x->_M_parent = y;
}

5.2 std::map/std::set：红黑树的复用

最巧妙的是，SGI 只实现了一个红黑树，就复用出了 std::map 和 std::set 两个容器：

// set的实现：value就是key
template <class Key, class Compare = less<Key>, class Alloc = alloc>
class set {
private:
    typedef rb_tree<key_type, value_type, identity<value_type>, key_compare, Alloc> rep_type;
    rep_type t; // 底层红黑树
};

// map的实现：value是pair，key是pair的first
template <class Key, class T, class Compare = less<Key>, class Alloc = alloc>
class map {
private:
    typedef rb_tree<key_type, value_type, select1st<value_type>, key_compare, Alloc> rep_type;
    rep_type t; // 底层红黑树
};

这里的identity和select1st就是键提取器：

对于 std::set，元素本身就是 key，所以直接返回 value
对于 std::map，key 是 pair 的 first 元素，所以提取 first

因为底层都是使用红黑树，所以它们的时间复杂度都是 O(log n)，非常稳定，不会退化。

红黑树内部只需要通过这个键提取器拿到 key，就可以进行比较，完全不需要关心 value 是什么。这就是泛型编程的魔力，一个红黑树实现，就能支持所有的关联容器！

六、无序容器：哈希表的极速查找

std::unordered_map 和 std::unordered_set 是 C++11 引入的无序容器，它们的底层是哈希表，提供了均摊 O(1) 的查找性能。

6.1 开链法：哈希冲突的解决方案

SGI 的哈希表采用 开链法（Separate Chaining，也可以叫拉链法） 来解决哈希冲突：

底层是一个桶数组（bucket array），每个桶对应一个链表的头
当插入元素时，通过哈希函数计算 key 对应的桶索引
如果桶里已经有元素了，就链到链表的后面

这种方式解决了哈希冲突的问题，即使多个 key 哈希到同一个桶，也能通过链表存储。

6.2 素数扩容：负载因子的控制

哈希表的性能依赖于负载因子（元素数 / 桶数），当负载因子超过 1.0 时，哈希表会触发扩容：

新的桶数选择下一个素数（SGI 预定义了 28 个素数：53, 97, 193…）
重新计算所有元素的哈希值，重新映射到新的桶中
释放旧的桶数组

为什么用素数？因为素数可以减少哈希冲突的概率，让 key 的分布更均匀。

static const unsigned long __stl_prime_list[28] = {
  53ul, 97ul, 193ul, 389ul, 769ul, 1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
  49157ul, 98317ul, 196613ul, 393241ul, 786433ul, 1572869ul, 3145739ul, 6291469ul,
  12582917ul, 25165843ul, 50331653ul, 100663319ul, 201326611ul, 402653189ul,
  805306457ul, 1610612741ul, 3221225473ul, 4294967291ul
};

这就是 unordered_map 的查找速度比 map 快得多的原因（unordered_set 也是如此），它把 O (log n) 的查找降到了均摊 O (1)。

七、算法：混合策略的极致优化

STL 的算法并不是简单的实现，它们融合了多种算法的优势，针对不同的场景做了极致的优化。

7.1 std::sort: introsort 的混合艺术

std::sort 是 STL 中最经典的算法，它采用了introsort（内省排序），结合了三种算法的优点：

快速排序：作为主力，处理大部分数据，分治递归
堆排序：当递归深度超过 2*log2 (n) 时，说明快排遇到了最坏情况，切换到堆排序，避免 O (n²) 的最坏情况
插入排序：当子数组的大小小于 16 时，切换到插入排序，因为小数据量下插入排序的常数更小，速度更快

template <class RandomAccessIter>
void sort(RandomAccessIter first, RandomAccessIter last) {
    if (first != last) {
        // 内省排序：递归深度限制为2*log(n)
        __introsort_loop(first, last, __lg(last - first) * 2);
        // 最后对几乎有序的数组做一次插入排序
        __final_insertion_sort(first, last);
    }
}

这种混合策略让 sort 在所有情况下都能保证 O(n log n) 的时间复杂度，同时在常见情况下拥有快排的极致速度。

7.2 copy：根据迭代器类型的自动优化

std::copy 也做了极致的优化：

如果迭代器是 POD 类型的随机访问迭代器，直接调用memcpy批量拷贝，速度极快
否则，逐个元素拷贝

正是因为这个优化，copy 在处理原生数组或 vector 时，速度比手写的循环快 10 倍以上。且处理 vector 时比 list 快得多，因为 list 的迭代器不支持随机访问，无法使用memcpy。

八、仿函数与适配器：组件的配接器

8.1 仿函数：可配接的策略

仿函数就是重载了operator()的类，它可以作为算法的策略参数。为了让仿函数可以被适配器配接，STL 定义了两个基类：

template <class Arg, class Result>
struct unary_function {
    // 定义参数类型和返回类型，供适配器萃取使用
    typedef Arg argument_type;
    typedef Result result_type;
};

template <class Arg1, class Arg2, class Result>
struct binary_function {
    // 定义参数类型和返回类型，供适配器萃取使用
    typedef Arg1 first_argument_type;
    typedef Arg2 second_argument_type;
    typedef Result result_type;
};

所有标准仿函数都继承自这两个类，这样适配器就能萃取它们的参数类型和返回类型，实现配接。

8.2 适配器：三类包装器

适配器是 STL 中用来转换接口的组件，分为三类：

容器适配器：就是我们之前讲的 std::stack、std::queue、std::priority_queue，包装容器的接口
迭代器适配器：包装迭代器的接口，比如：
- back_inserter：把普通迭代器转换成尾部插入迭代器
- reverse_iterator：把正向迭代器转换成反向迭代器
- ostream_iterator：把输出流转换成迭代器
函数适配器：包装仿函数的接口，比如：
- bind1st/bind2nd：绑定二元函数的一个参数，把它变成一元函数
- not1/not2：对仿函数的结果取反
- mem_fun/ptr_fun：把成员函数或普通函数转换成仿函数

九、性能对比与选型指南

性能对比

了解了底层实现，我们就能根据场景选择最合适的容器：

容器	随机访问	头部插入	尾部插入	中间插入	查找	内存连续性	适用场景
vector	O(1)	O(n)	O (1) 均摊	O(n)	O(n)	完全连续	高频随机访问、尾部插入
list	O(n)	O(1)	O(1)	O(1)	O(n)	完全分散	高频中间插入删除
deque	O(1)	O(1)	O(1)	O(n)	O(n)	分段连续	双端队列、消息队列
map	O(log n)	O(log n)	O(log n)	O(log n)	O(log n)	分散	有序键值对、范围查询
unordered_map	O (1) 均摊	O (1) 均摊	O (1) 均摊	O (1) 均摊	O (1) 均摊	分散	无序快速查找、缓存
unordered_set	O (1) 均摊	O (1) 均摊	O (1) 均摊	O (1) 均摊	O (1) 均摊	分散	无序快速查找、缓存

选型避坑指南

不要为了省内存选 list：list 每个节点多 16 字节指针开销（前驱和后继指针），而且缓存命中率极低，大部分场景下 vector 更快
unordered_map 要提前 reserve：它的扩容需要 rehash 所有元素，代价很高，提前预留空间可以避免。例如 unordered_map.reserve(n) 就是提前告诉它你要存 n 个元素，这样它就一次性分配好足够的桶，避免频繁扩容。
vector 的 reserve 可以避免迭代器失效：提前分配好足够的空间，避免扩容导致的迭代器失效
需要有序就用 map，不需要就用 unordered_map：不要为了快用 unordered_map 然后自己排序，那样反而更慢
需要随机访问，且主要在尾部操作：选 vector，缓存友好，速度最快。
需要频繁在两端操作：选 deque。
需要频繁在任意位置插入删除：选 list。
需要有序键值对，且需要稳定的 O (log n)：选 map/set。
不需要顺序，只需要最快的查找：选 unordered_map/unordered_set。

参考资料

《STL 源码剖析》- 侯捷
SGI STL 3.3 官方源码
GCC libstdc++ 实现文档
《C++ Standard Library》- Nicolai Josuttis

C++各版本的特性

Fri, 06 Mar 2026 15:34:25 +0800

C++几个版本的特性

C++11的特性：史诗级变革（现代 C++ 的基石）

nullptr

在 C++ 的世界里，虽然 NULL 和 nullptr 都代表“空指针”，但它们在底层逻辑和类型安全上有本质的区别。简单来说，NULL 是过去（C 语言遗产），而 nullptr 是未来（现代 C++）。

本质区别：整数 vs 指针

NULL：在底层通常被定义为整数0或者 (void*)0。在 C++ 中，它本质上是一个宏。因为 C++ 允许将0隐式转换为指针，所以 NULL 一直被当作指针用。
nullptr：是 C++11 引入的关键字。它的类型是 std::nullptr_t，它可以隐式转换为任何指针类型，但不能隐式转换为整数。

nullptr是为了解决NULL的二义性问题而出现的。由于NULL本质上是一个整数，因此在函数重载时会导致意想不到的错误。举个例子，加入你有以下两个函数：

1
2

void func(int n);    // 函数 A
void func(char* s);  // 函数 B

如果你调用func(NULL)：编译器会优先把它看作整数0，从而调用函数A。这通常不是你的本意。如果你调用func(nullptr)：编译器明确知道这是一个指针，从而调用函数B。
因此，在编写现代C++（C++11及以上）：请永远使用nullptr。它能帮你规避掉很多难以排查的重载Bug。

以下是它们的核心差异对比表：

特性	NULL	nullptr
本质	宏定义（通常是 0）	关键字（std::nullptr_t）
类型安全	弱（容易与整数混淆）	强（只能代表指针）
引入版本	C 语言时代 / C++98	C++11 及以后
隐式转换	可转为整数或指针	仅可转为指针，不可转为整数
推荐用法	现代 C++ 中应避免使用	强烈建议在所有场景使用

类型推导

在现代 C++（C++11 及以后）中，auto 和 decltype 都是用来进行类型推导的利器。虽然它们看起来都在替你省事，但它们的工作原理和“脑回路”完全不同。

auto：由值推导类型

auto的核心逻辑是：“根据等号右边的初始化值，推断出变量应该是什么类型。”

特点：变量必须初始化。
规则：它会忽略顶层的 const 属性和引用属性（除非你显式加上 auto& 或 const auto）。

int x = 10;
auto a = x;       // a 是 int
const int b = x;
auto c = b;       // c 依然是 int (const 被忽略了)
auto& d = b;      // d 是 const int& (显式写了引用，const 就会保留)

decltype：由表达式推导类型

decltype（declared type）的核心逻辑是：“查询一个表达式或变量的声明类型，而不实际计算它。”

特点：不需要初始化，它只看表达式的“户口本”。
规则：它会完整保留所有的 const 和引用属性。

1
2

const int x = 0;
decltype(x) y = 1; // y 的类型精确地就是 const ints

协作场景：追踪返回类型

在C++11中，如果你写一个模板函数，返回值取决于参数的运算，你可能无法预先知道类型。这时需要结合两者：

template <typename T, typename U>
auto add(T t, U u) -> decltype(t + u) {
    return t + u;
}

Lambda表达式

Lambda表达式实际上就是提供了一个类似匿名函数的特性，而匿名函数则是在需要一个函数，但是又不想费力去命名一个函数的情况下去使用的。

智能指针

智能指针的核心思想是 RAII（资源获取即初始化）：它本质上是一个类（封装了原始指针），利用栈上对象的生命周期来管理堆上的内存。当智能指针对象超出作用域被销毁时，它的析构函数会自动帮你 delete 掉底层的内存。

C++ 标准库（<memory>）主要提供了三种智能指针，它们各自对应不同的“所有权”模型：

1.std::unique_ptr：独占所有权（霸道总裁）

这是最常用、也最高效的智能指针。它的原则是：同一时刻，只能有一个unique_ptr指向同一块内存。

特点：不允许复制（拷贝构造函数被禁用），只允许移动（转移所有权）。由于没有额外的性能开销，它的性能和裸指针几乎一模一样。
适用场景：只要你不需要在多个地方共享这块内存，就无脑用它。

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "创建对象\n"; }
    ~MyClass() { std::cout << "销毁对象\n"; }
    void doSomething() { std::cout << "执行任务\n"; }
};

int main() {
    {
        // 推荐使用 std::make_unique (C++14 引入) 来创建
        std::unique_ptr<MyClass> ptr1 = std::make_unique<MyClass>();
        ptr1->doSomething();

        // std::unique_ptr<MyClass> ptr2 = ptr1; // 错误！编译不通过，不能复制
        
        // 正确做法：使用 std::move 转移所有权
        std::unique_ptr<MyClass> ptr3 = std::move(ptr1); 
        // 此时 ptr1 变成空指针，内存由 ptr3 接管
    } 
    // 离开作用域，ptr3 被销毁，自动调用 MyClass 的析构函数！
    return 0;
}

输出：

1
2
3

创建对象
执行任务
销毁对象

2.std::shared_ptr：共享所有权（合伙人）

当你确实需要多个指针共同管理同一块内存时，就需要用到它。它的原则是：大家一起用，最后一个走的人负责关灯（释放内存）。

核心机制：引用计数（Reference Counting）。系统会在内部维护一个计数器，记录有多少个 shared_ptr 指向这块内存。
- 每多一个 shared_ptr 指向它，计数器 +1。
- 每销毁一个 shared_ptr，计数器 -1。
- 当计数器归 0 时，自动 delete 内存。
代价：因为要维护引用计数（且计数操作是线程安全的），它的性能开销比 unique_ptr 稍大。

#include <iostream>
#include <memory>

int main() {
    // 推荐使用 std::make_shared，只分配一次内存（控制块和数据一起），性能更好
    std::shared_ptr<int> sp1 = std::make_shared<int>(100);
    std::cout << "引用计数: " << sp1.use_count() << "\n"; // 输出 1

    {
        std::shared_ptr<int> sp2 = sp1; // 允许复制！
        std::cout << "引用计数: " << sp1.use_count() << "\n"; // 输出2，sp1.use_count()也是2
    } // sp2 离开作用域被销毁，计数器减 1

    std::cout << "引用计数: " << sp1.use_count() << "\n"; // 输出 1
    // sp1 离开作用域，计数变为 0，内存释放
    return 0;
}

输出：

1
2
3

引用计数: 1
引用计数: 2
引用计数: 1

3.std::weak_ptr：弱引用（旁观者）

weak_ptr 是为了解决 shared_ptr 的一个致命缺陷而生的：循环引用。

什么是循环引用？ 假设对象 A 里面有一个 shared_ptr 指向对象 B，对象 B 里面也有一个 shared_ptr 指向对象 A。这会导致它们的引用计数永远降不到 0，从而造成内存泄漏。代码演示如下：

#include <iostream>
#include <memory>

// 因为 ClassA 中用到了 ClassB，所以需要先打个招呼（前置声明）
class ClassB; 

class ClassA {
public:
    // A 里面有一个共享管家，负责保管 B
    std::shared_ptr<ClassB> ptrToB; 

    ClassA() { std::cout << "ClassA 诞生了！\n"; }
    // 如果管家正常下班，会触发这个销毁函数
    ~ClassA() { std::cout << "ClassA 被销毁了！\n"; } 
};

class ClassB {
public:
    // B 里面也有一个共享管家，负责保管 A
    std::shared_ptr<ClassA> ptrToA; 
    // std::weak_ptr<ClassA> ptrToA; 

    ClassB() { std::cout << "ClassB 诞生了！\n"; }
    // 如果管家正常下班，会触发这个销毁函数
    ~ClassB() { std::cout << "ClassB 被销毁了！\n"; } 
};

int main() {
    std::cout << "--- 实验开始 ---\n";
    {
        // 1. 雇佣管家 a 保管 ClassA，雇佣管家 b 保管 ClassB
        // 此时，A 和 B 的引用计数都是 1
        std::shared_ptr<ClassA> a = std::make_shared<ClassA>();
        std::shared_ptr<ClassB> b = std::make_shared<ClassB>();

        // 2. 互相绑定（循环引用的罪魁祸首！）
        // a 里面的管家也去保管 B，导致 B 的引用计数变成 2
        a->ptrToB = b; 
        // b 里面的管家也去保管 A，导致 A 的引用计数变成 2
        b->ptrToA = a; 

        std::cout << "A 的引用计数: " << a.use_count() << "\n"; // 输出 2
        std::cout << "B 的引用计数: " << b.use_count() << "\n"; // 输出 2
        
    } // 3. 离开大括号，局部变量 a 和 b 下班被销毁
    
    std::cout << "--- 离开作用域，实验结束 ---\n";
    return 0;
}

输出：

--- 实验开始 ---
ClassA 诞生了！
ClassB 诞生了！
A 的引用计数: 2
B 的引用计数: 2
--- 离开作用域，实验结束 ---

~ClassA() 和 ~ClassB() 里的“被销毁了！”这两句话根本没有打印出来，这意味着内存泄漏了。所以，为了避免出现上述问题，我们需要引入weak_ptr。只需讲上面代码中的这行代码 // std::weak_ptr ptrToA; 取消注释即可，下面就不再赘述。

weak_ptr 的作用：它只能从 shared_ptr 或另一个 weak_ptr 构造。它不增加引用计数，仅仅是“观察”这块内存。当你要使用数据时，必须调用.lock() 方法将它提升为shared_ptr（如果内存还没被释放的话）。该方法会返回一个shared_ptr，但若没有被接收的话，则不会增加所指向对象的引用计数。

#include <iostream>
#include <memory>

int main() {
    // 先创建一个旁观者（目前什么都没看）
    std::weak_ptr<int> weak_viewer;

    {
        // 创建一个共享管家，保管数字 42
        std::shared_ptr<int> shared_owner = std::make_shared<int>(42);
        
        // 旁观者开始观察这个管家手里的数据 (引用计数依然是 1)
        weak_viewer = shared_owner; 

        // 第一次尝试使用数据 (此时 shared_owner 还在)
        std::cout << "--- 第一次尝试 ---\n";
        // 核心用法：用 lock() 临时获取一个 shared_ptr
        if (std::shared_ptr<int> temp_sp = weak_viewer.lock()) {
            std::cout << "对象还活着！它的值是: " << *temp_sp << "\n";
            std::cout << "此时引用计数临时变成: " << temp_sp.use_count() << "\n";
        } else {
            std::cout << "对象已经被销毁了。\n";
        }
    } // 离开大括号，shared_owner 被销毁，引用计数归 0，数字 42 被释放

    // 第二次尝试使用数据 (此时数据已经被销毁)
    std::cout << "\n--- 第二次尝试 ---\n";
    if (std::shared_ptr<int> temp_sp = weak_viewer.lock()) {
        std::cout << "对象还活着！它的值是: " << *temp_sp << "\n";
    } else {
        std::cout << "对象已经被销毁了，无法访问。\n";
    }

    return 0;
}

输出：

--- 第一次尝试 ---
对象还活着！它的值是: 42
此时引用计数临时变成: 2

--- 第二次尝试 ---
对象已经被销毁了，无法访问。

基于范围的for循环：for(auto &i:arr)

thread类和mutex类

C++14的特性

泛型 Lambda

Lambda 的参数可以用 auto 推导了（[](auto x, auto y) { return x + y; }）。

返回值类型推导

普通函数也可以直接写 auto 作为返回值类型，让编译器去猜。

std::make_unique

补齐了 C++11 只有 std::make_shared 的遗憾。

C++17的特性

结构化绑定

可以直接解包结构体或 std::tuple：auto [x, y, z] = get_3d_point();。

if / switch 带初始化

把变量的作用域严格限制在判断语句内，例如：if (auto it = map.find(key); it != map.end()) { … }。

现代化词汇类型：

std::optional：完美替代以前用指针判空来表示“可能没有值”的场景。
std::variant：类型安全的 union。
std::string_view：字符串的“只读视图”，实现了零拷贝传递字符串，极大地提升了性能。

C++20的特性：四大支柱（第二次历史跨越）

C++20 是继 C++11 之后最庞大的一次更新，它引入的“四大支柱”彻底改变了现代 C++ 的编程范式。

Concepts (概念)

给模板编程加上了“类型约束”。以前写模板报错时，编译器会打印几百行天书；现在用 Concepts 约束后，错误信息终于变成了人类可读的文字。

Modules (模块)

正式告别 #include 历史！使用 import 引入模块，不仅解决了宏污染问题，还让大型项目的编译速度有了数量级的提升。

Coroutines (协程)

引入了无栈协程，新增了 co_await, co_yield, co_return 关键字，让异步编程（比如网络请求、高并发）可以用同步的方式写出来。

Ranges (范围库)

结合了函数式编程思想，允许用类似 Linux 管道符 | 的方式处理数据：data | views::filter(…) | views::transform(…)，代码极其优雅。

其他亮点

三路比较运算符（<=>，也叫飞船运算符）、std::format（类似 Python 的高级格式化输出）。

C++23 (及以后)：标准库的极致完善

C++23 进一步吸收了其他现代语言的优点，让标准库更加“开箱即用”。

std::print / std::println

大家终于可以抛弃老旧的 std::cout « 和不安全的 printf 了，这是一种更现代、更快速的控制台输出方式。

std::expected

引入了类似 Rust Result 的错误处理机制。函数可以返回一个“期望的值”或者“错误原因”，比抛出异常更轻量，比返回错误码更清晰。

显式 this 参数 (Deducing this)

允许在类成员函数中显式把 this 当作参数传递，极大简化了复杂的模板代码（如 CRTP 模式）。

多维数组操作：std::mdspan

对科学计算和高性能计算非常友好，提供了一种访问连续内存的多维视图。

auto,auto&,auto&& 的作用和区别？

Fri, 23 Jan 2026 16:09:18 +0800

auto,auto&,auto&& 的作用和区别？

指针数组、数组指针

首先要先区分好什么是指针数组，什么是数组指针：

常量指针：指向的值不可修改，不可变的是指向的地址的值。
指针常量：指针的地址不可修改，不可变的是指向的地址。

#include<iostream>

int main() {
    int num = 1;
    int num2 = 10000;
    const int* a = &num;    // 常量指针：指向的值不可修改
    int* const b = &num;    // 指针常量：指针的地址不可修改

    std::cout << *a << std::endl; // Outputs: 1
    std::cout << *b << std::endl; // Outputs: 1

    // 我们尝试修改a和b所指向的值：
    // *a = 2; // 报错：不能通过常量指针修改值
    *b = 2; // 有效：可以通过指针常量修改值
    std::cout << num << std::endl; // Outputs: 2

    // 我们尝试修改a和b所指向的地址：
    a = &num2; // 有效：可以改变常量指针指向的地址
    std::cout << *a << std::endl; // Outputs: 10000
    // b = &num2; // 报错：不能改变指针常量指向的地址

    return 0;
}

输出：

auto 值类型推导

    int a = 1;
    auto va = a; // va 被推导为 int 类型


    const int b = a;
    auto vb = b; // vb 被推导为 int 类型，const 修饰符被忽略

    const int* p1 = &a;           // 常量指针
    auto vp1 = p1; // vp1 被推导为 const int* 类型，指针的 const 修饰符被保留

    int* const p2 = &a;           // 指针常量
    auto vp2 = p2; // vp2 被推导为 int* 类型，指针常量的 const 修饰符被忽略

    const char name[] = "example";
    auto vname = name; // vname 被推导为 const char* 类型，退化成指针了

推导结果如下图所示，我用的是VS Code中的clangd插件，可以直接看见推到结果，下同。

auto& 左值引用推导

    int a = 1;
        auto& ra = a; // ra 被推导为 int& 类型

        const int b = a;
        auto& rb = b; // rb 被推导为 const int& 类型，保留 const 修饰符

        const int* p1 = &a;           // 常量指针
        auto& rp1 = p1; // rp1 被推导为 const int*& 类型，保留指针的 const 修饰符

        int* const p2 = &a;           // 指针常量
        auto& rp2 = p2; // rp2 被推导为 int* const& 类型，保留指针常量的 const 修饰符

        const char name[] = "example";
        auto& rname = name; // rname 被推导为 const char (&)[8] 类型，保留数组的 const 修饰符

推导结果如下图所示，我用的是VS Code中的clangd插件，可以直接看见推到结果，下同。

auto&& 万能引用推导

    int a = 1;            // 左值：变量有名字，有地址；
        auto&& ua = a; // ua 被推导为 int& 类型（左值引用）

        const int b = a;
        auto&& ub = b; // ub 被推导为 const int& 类型（左值引用）

        // 2是右值：字面值，无名字，无地址；
        auto&& uc = 2; //被推导为 int 类型（右值引用）

        const char name[] = "example";
        auto&& uname = name; // uname 被推导为 const char (&)[8] 类型（左值引用）

推导结果如下图所示，我用的是VS Code中的clangd插件，可以直接看见推到结果，下同。

总结和推导结果解释

除了auto是值类型以外，auto&和auto&&都是引用，因此也只有auto会拷贝对象。并且在处理const的时候，auto也不同于auto&和auto&&，会忽略掉顶层const保留底层const，而auto&和auto&&会同时保留顶层const和底层const。

也就是说，const可以被分为两种：

顶层const：包括常量指针、基本类型 作用于变量本身，该变量不可修改。
底层const：包括指针常量、引用。 作用于指向或引用的对象，不能通过该变量修改指向的对象。

各种方法是否拷贝对象

是否拷贝我们只需输出一下变量的地址即可得知。

    int a = 1;
    auto va = a; // va 被推导为 int 类型，          拷贝，内存地址不同
    auto& ra = a; // ra 被推导为 int& 类型，      引用，内存地址相同
    auto&& ua = a; // ua 被推导为 int& 类型，     引用，内存地址相同

    std::cout << &a << ", " << &va << ", " << &ra << ", " << &ua << std::endl;

输出：

`1`	`0xcfa3ff768, 0xcfa3ff764, 0xcfa3ff768, 0xcfa3ff768`

每次运行输出都会变化，但a、ra和ua的地址是始终相同的。