企业官网建设流程全解析

如果你在 C++ 项目里用 vector 用得顺手，头一回来碰 list，大概率会冒出一堆问号：为什么 list 的 insert 不引起重分配？为什么它没有 operator[]？为什么迭代器不支持加减运算？这篇是 C++ list 专题的第二篇，重点做两件事，一是把 list 的接口挨个掰开讲清楚，二是带着你从零手写一个满足基本功能的 list 容器。

写这个专题的起因是我在实际项目中遇到过好几次“该用 list 还是 vector”的争论，很多人对 list 的理解停留在“链表嘛，插入删除快”这种口头层面，真问到接口细节、迭代器失效规则、底层结构设计时又含糊了。所以这篇文章我想把 list 的常见接口、边界行为、内部结构一次说透，再给一份可以直接拿来学习的实现代码。适合正在学 C++ STL 的人、准备面试的人，以及写代码时总在容器之间纠结的工程向同学。

1. 接口全景：list 能做什么，该在什么时候用

1.1 list 的“身份证”：双向链表结构带来的能力边界

list 在标准库里的全称是 std::list，底层是双向链表。这里的“双向”意味着每个节点除了存数据，还有两个指针，一个指向前一个节点，一个指向后一个节点。和 vector 那种连续内存的数组结构比，list 的能力边界非常清晰。

先看它擅长的事。中间位置的插入和删除是 O(1) 复杂度，这是在你已经持有迭代器的情况下成立的。比如你手里有个迭代器指向链表的第三个元素，你想在它前面插入一个新元素，list 只需要改动附近几个节点的指针，数据本身完全不用搬动。vector 就不一样了，中间插入意味着要把插入位置之后的所有元素整体后移，最坏情况 O(n)，如果扩容还要整体拷贝到新内存。

再看它不擅长的事。list 没有随机访问能力，你想取第 n 个元素，只能从头部或者尾部一个个遍历过去，时间复杂度 O(n)。所以标准库干脆不给你提供 operator[]。list 也不擅长查找，你把整个链表翻一遍才能确认某个值在不在，这跟 vector 的二分查找（配合排序）完全没法比。

还有一个很多人容易忽略的点，list 的每个节点是单独分配内存的，节点之间在物理内存上大概率不连续。这就导致一个后果：遍历链表的时候，CPU 缓存命中率远低于遍历 vector。因为 vector 的元素在内存里是挨着的，访问完第一个元素，第二个元素大概率已经加载进缓存了；list 的节点东一个西一个，访问完一个节点，下一个节点很可能不在缓存里，需要重新到内存里取。实际工程里，即使 list 在插入删除上有理论优势，遇到频繁遍历的场景，性能往往还不如 vector。

所以结论很直接：如果数据体量不大、也不需要频繁在中间插入删除，优先考虑 vector；如果确实需要在任意位置高频插入删除，并且持有迭代器作为操作入口，才考虑 list。

1.2 常用接口速查与使用要点

list 的接口分几类：构造、容量、元素访问、修改、特殊操作。我把工程里最常用的整理成一张表，后面逐个挑重点讲。

先说一个高频考点：list 的 size() 在 C++98 时代可能是 O(n) 的，因为标准没有强制要求常数时间，很多早期实现靠遍历计数。但 C++11 之后标准明确规定 size() 必须是 O(1)，所以现代编译器里你可以放心使用 size()，不用担心遍历整个链表数元素。

再看元素访问。list 只有 front() 和 back()，没有 at() 也没有 operator[]。而且 front() 和 back() 在空链表上调用是未定义行为，别指望它给你抛异常。实际写代码时要先判断 empty()，哪怕觉得“这地方肯定非空”，也建议留着防御逻辑，尤其是链表的元素是从外部传入的时候。

insert 接口有个容易混淆的点。vector 的 insert 会导致迭代器失效，list 的 insert 接在指定位置之前，原有的所有迭代器都保持有效，不会失效。这一点在面试中经常作为 vector 和 list 的对比点出现。原因不难理解，list insert 只是改了指针指向，不搬动任何已存在的节点，节点的地址没有变化，指向它们的迭代器自然仍然有效。

erase 接口则需要留意。list 的 erase 会使“被删除节点”的迭代器失效，但其他迭代器不受影响。C++11 之前 erase 返回 void，你删除元素后想继续遍历，得先把要删除的迭代器保存到临时变量再推进。C++11 之后 erase 返回被删除元素的下一个迭代器，遍历删除的写法简化了不少。

splice 是 list 独有的重要接口，也是很多人第一次见到时觉得神奇的接口。它能把一个 list 中的节点直接“搬”到另一个 list，注意是搬而不是复制。搬完之后，源 list 的对应节点就没了，但节点本身没有被销毁，只是换了归属。这个操作在需要把多个链表拼接到一起的场景特别有用，比如实现任务队列时把一批待处理任务整体挂到主队列末尾。

merge 用于合并两个已排序的 list，合并后目标 list 保持有序。这里要特别提醒，源 list 的元素在 merge 之后会被清空，这和直觉不太一样。很多人第一次用 merge，发现另一个 list 变空了，以为是 bug，其实就是标准语义：merge 是转移合并，不是复制合并。

unique 用来删除连续的重复元素。注意是“连续”，如果相同的元素分散在不同位置，unique 不会管它们。所以通常先 sort 再 unique，才能实现真正去重。remove 则不同，它是把链表中所有等于指定值的元素都删掉，不需要元素连续，也不需要链表有序。

2. 看不见的内部结构：哨兵节点和迭代器

2.1 哨兵头节点：让所有边界条件消失的设计

要理解 list 的实现，先要看懂它的节点结构。标准库里的 list 节点不是光秃秃的一个数据加两个指针，通常会有一个哨兵头节点（sentinel node）。这个头节点不存实际数据，它的 next 指向链表第一个元素，prev 指向链表最后一个元素。链表为空时，头节点的 next 和 prev 都指向它自己。

哨兵节点的意义在于消除边界条件。假如没有哨兵，空链表和只有一个元素的链表需要单独处理，头部插入和尾部插入也要分别判断，代码里到处是 if (head == nullptr) 这种分支。有了哨兵节点，所有操作都统一了。

你想想 erase 的逻辑。删除一个节点需要四个步骤：找到它的前驱节点，找到它的后继节点，把前驱的 next 指向后继，把后继的 prev 指向前驱。如果链表只有一个节点，这个节点的前驱和后继都是谁呢？如果没有哨兵，这里就得特殊处理，前驱和后继都不存在。有了哨兵，哪怕链表里只有一个节点，它的前驱和后继也都是哨兵节点，删除操作走同一套逻辑就能完成。

begin() 返回指向第一个实际元素的迭代器，就是 head_->next；end() 返回指向哨兵节点的迭代器。当一个循环遍历到这个“空的”哨兵时，说明链表到头了。这就是为什么下面这种遍历写法能正常工作：

for (auto it = lst.begin(); it != lst.end(); ++it) { // 处理 it 指向的元素 }

end() 返回的其实是一个指向“哨兵”的迭代器，它不代表任何实际元素，只代表链表的结束位置。

如果你自己手写 list，这个设计值得重点学习。初学者经常在 insert、erase 里写出一堆状态判断，就是因为少了哨兵节点。

2.2 迭代器：链表访问的核心抽象

迭代器是 list 设计的第二个关键点。你可以把迭代器理解成“指针的泛化”。对 vector 来说，迭代器差不多就是普通的 T* 指针，因为 vector 的元素连续存储，指针加减就能访问任意位置的元素。但 list 不行，元素不连续，T* 这种原生指针没法完成“指向下一个节点”的操作，因为谁也不知道下一个节点在内存的哪个角落。

所以 list 的迭代器必须是自己定义的类类型，内部封装一个 Node*，对外提供类似指针的操作接口。常见操作包括：

• operator++：让内部的 Node* 指向 next（前移）
• operator--：让内部的 Node* 指向 prev（后退）
• operator*：返回当前节点的数据引用
• operator->：返回当前节点的数据指针
• operator== / operator!=：比较两个迭代器是否指向同一个节点

这些操作封装好之后，迭代器的使用体验和原生指针非常接近。算法库里那些针对迭代器写的算法（find、count、for_each 等）也能直接作用于 list。

迭代器按能力分类，list 的迭代器属于双向迭代器（Bidirectional Iterator），支持 ++ 和 --，但不支持 +n、-n、[] 这类随机访问操作。标准库里的 sort 算法要求随机访问迭代器，所以 list 的 sort 算法和 sort 函数的 sort 是两个不同的东西，一个成员函数、一个算法。这边也解释了一个面试常见问题：为什么 list 有单独的成员函数 sort？因为 std::sort 要求随机访问迭代器，双向迭代器玩不了，必须提供自己的排序实现。

2.3 迭代器失效规则与实际影响

迭代器失效是个经常踩坑的话题。vector 里，插入删除元素后，所有迭代器都可能失效，因为底层可能整体搬了家。list 里规则要温和得多。

• 插入操作（insert、push_front、push_back、splice）不会使任何现有的迭代器失效。
• 删除操作（erase、pop_front、pop_back、remove、unique）只会使被删除元素的迭代器失效，其他迭代器保持有效。

这个规则的意义在于，你可以放心地在遍历 list 的过程中删除元素。最稳妥的写法是利用 C++11 之后 erase 返回后继迭代器的特性：

for (auto it = lst.begin(); it != lst.end(); ) { if (需要删除(*it)) { it = lst.erase(it); // erase 返回下一个有效迭代器 } else { ++it; } }

在 C++11 之前，erase 不返回迭代器，很多人会这样写：

for (auto it = lst.begin(); it != lst.end(); ) { if (需要删除(*it)) { lst.erase(it++); // 先用后加，it 先拷贝并递增 } else { ++it; } }

这个写法利用了后置 ++ 先自增再返回旧值的特性，让 erase 删除的是旧迭代器指向的节点，而 it 已经安全地指向了下一个节点。两种写法都有效，但前者更直观、更不容易出错。我个人推荐在新代码里统一用 C++11 的写法。

3. 手写 list：从零实现一个可用的容器

3.1 节点设计与类骨架

光看不练假把式。理解了上面的结构，接下来我用一个简化但功能完整的 list 实现来验证这些设计。先定义节点结构。

template <typename T> struct ListNode { T data; ListNode* prev; ListNode* next; explicit ListNode(const T& val = T()) : data(val), prev(nullptr), next(nullptr) {} };

这里用 struct 是因为节点内部字段需要被 list 类和迭代器类直接访问，用 struct 省去一堆 friend 声明。

然后定义 list 类的骨架。为了代码清晰，我没有把全部接口都写进去，但核心接口已经覆盖了绝大部分使用场景。

template <typename T> class list { public: // 类型别名，便于外部使用 using value_type = T; using size_type = size_t; using reference = T&; using const_reference = const T&; // 迭代器这里先用一个占位，下面再实现 class iterator; class const_iterator; list(); list(size_type n, const T& val); template <typename InputIt> list(InputIt first, InputIt last); list(const list& other); list& operator=(const list& other); ~list(); iterator begin(); iterator end(); const_iterator begin() const; const_iterator end() const; bool empty() const; size_type size() const; reference front(); reference back(); const_reference front() const; const_reference back() const; void push_front(const T& val); void pop_front(); void push_back(const T& val); void pop_back(); iterator insert(iterator pos, const T& val); iterator erase(iterator pos); iterator erase(iterator first, iterator last); void clear(); void splice(iterator pos, list& other); private: using Node = ListNode<T>; Node* head_; // 哨兵节点 size_type size_; // 元素个数 };

构造函数里的哨兵节点初始化很关键。创建空链表时要让 head_ 的 next 和 prev 都指向自己，这样链表就处于“空”状态，begin() 和 end() 都指向 head_。

template <typename T> list<T>::list() : head_(new Node()), size_(0) { head_->next = head_; head_->prev = head_; }

注意哨兵节点虽然也是 Node 类型，但它并不存放实际数据。这个节点一直存活到 list 被析构，起到维护链表边界的作用。

3.2 迭代器实现：封装指针，让算法统一

迭代器的实现是我认为整个手写 list 中最精华的部分。它把“链表节点怎么走”的细节全部藏起来，对上层提供统一的指针式语法。

template <typename T> class list<T>::iterator { public: // 让算法库识别迭代器类型 using iterator_category = std::bidirectional_iterator_tag; using value_type = T; using difference_type = std::ptrdiff_t; using pointer = T*; using reference = T&; iterator() : node_(nullptr) {} explicit iterator(Node* node) : node_(node) {} reference operator*() const { return node_->data; } pointer operator->() const { return &node_->data; } iterator& operator++() { node_ = node_->next; return *this; } iterator operator++(int) { iterator tmp = *this; node_ = node_->next; return tmp; } iterator& operator--() { node_ = node_->prev; return *this; } iterator operator--(int) { iterator tmp = *this; node_ = node_->prev; return tmp; } bool operator==(const iterator& other) const { return node_ == other.node_; } bool operator!=(const iterator& other) const { return node_ != other.node_; } // 迭代器访问底层节点（list 内部用） Node* node() const { return node_; } private: Node* node_; };

这里有几个细节值得展开说。首先，operator* 返回的是 node_->data 的引用，不是拷贝，所以你可以通过 *it 直接修改链表中的元素。其次，前置 ++ 返回迭代器自身的引用，效率比后置 ++ 返回临时对象更高，这也是为什么循环里优先写 ++it 而不是 it++。

const_iterator 和 iterator 的实现结构基本一致，区别在于 operator* 和 operator-> 返回 const 引用和 const 指针。为了简化代码，我这里没有完整写出来，但原理完全相同。

这里插一句题外话，标准库的实现里 iterator 可以隐式转换为 const_iterator，这样当你把 list 传给一个接受 const list& 的函数时，函数里用 begin() 拿到的迭代器能正常赋值给 const_iterator。自己实现时如果有需要，可以在 const_iterator 里加一个接受 iterator 的构造函数。

3.3 构造与内存管理：拷贝控制是重头戏

list 的默认构造容易，但涉及到拷贝构造、赋值、析构时，很多新手会翻车。原因是链表的内存是分散的，你必须逐个节点地复制过去，不能像 vector 那样 memcpy。

析构函数的核心是逐个销毁节点，注意哨兵节点最后也得 delete。

template <typename T> list<T>::~list() { clear(); delete head_; } template <typename T> void list<T>::clear() { Node* cur = head_->next; while (cur != head_) { Node* nxt = cur->next; delete cur; cur = nxt; } head_->next = head_; head_->prev = head_; size_ = 0; }

clear 的循环条件写得是 cur != head_，因为哨兵节点是链表遍历的终点。循环里先保存 cur->next，再 delete cur，这个顺序不能反，否则你删了当前节点就找不到下一个节点的地址了。

拷贝构造需要遍历原链表，逐个把元素用 insert 方式链到新链表里。

template <typename T> list<T>::list(const list& other) : head_(new Node()), size_(0) { head_->next = head_; head_->prev = head_; for (const auto& val : other) { push_back(val); } } template <typename T> list<T>& list<T>::operator=(const list& other) { if (this != &other) { list tmp(other); // 拷贝构造临时对象 swap(tmp); // 交换内部状态 } return *this; }

赋值运算符我这里用到了 copy-and-swap 惯用法，先构造一个临时链表，再把临时链表和当前链表的内容交换。这样写的好处是如果拷贝过程抛异常，当前链表的内容不会被破坏，异常安全性能得到保证。当然要真正支持 swap，需要在类里加一个 swap 成员函数或友元函数，这里为了篇幅没有完整展开，但思路是对的。

3.4 插入、删除与元素访问：链表操作的核心逻辑

push_back 和 push_front 是最简单的插入操作，本质都是在边界位置插入一个新节点，调整四个指针。

template <typename T> void list<T>::push_back(const T& val) { Node* new_node = new Node(val); Node* tail = head_->prev; tail->next = new_node; new_node->prev = tail; new_node->next = head_; head_->prev = new_node; ++size_; } template <typename T> void list<T>::push_front(const T& val) { Node* new_node = new Node(val); Node* first = head_->next; head_->next = new_node; new_node->prev = head_; new_node->next = first; first->prev = new_node; ++size_; }

push_back 的步骤是：找到当前尾节点（head_->prev），让尾节点的 next 指向新节点，新节点的 prev 指向尾节点，新节点的 next 指向哨兵，最后让哨兵的 prev 指向新节点。四个指针全部更新完，新节点就正式挂到了链表尾部。

pop_back 和 pop_front 是反向操作，删除一个节点后要保证哨兵的 prev 或 next 正确指向下一个节点。

template <typename T> void list<T>::pop_back() { Node* tail = head_->prev; Node* new_tail = tail->prev; new_tail->next = head_; head_->prev = new_tail; delete tail; --size_; }

insert 是给一个位置迭代器，在它前面插入新节点。这就是哨兵节点发挥作用的地方。无论 pos 是指向开头、末尾还是中间，逻辑都是同一套：拿到 pos 的前驱节点，把新节点插在前驱和 pos 之间。

template <typename T> typename list<T>::iterator list<T>::insert(iterator pos, const T& val) { Node* cur = pos.node(); Node* pre = cur->prev; Node* new_node = new Node(val); pre->next = new_node; new_node->prev = pre; new_node->next = cur; cur->prev = new_node; ++size_; return iterator(new_node); }

来看这个逻辑有多统一。如果 pos 指向哨兵节点（也就是 end()），那么 pre 就是真正的尾节点，新节点插到尾部，效果等价于 push_back。如果 pos 指向第一个实际节点（begin()），那么 pre 就是哨兵，新节点插到头部，效果等价于 push_front。不管怎么插，代码都不用写分支。

erase 的逻辑同样统一。删除一个节点，把前驱的 next 指向后继，把后继的 prev 指向前驱，然后 delete 节点。

template <typename T> typename list<T>::iterator list<T>::erase(iterator pos) { Node* cur = pos.node(); Node* pre = cur->prev; Node* nxt = cur->next; pre->next = nxt; nxt->prev = pre; delete cur; --size_; return iterator(nxt); }

这里同样可以体会哨兵节点带来的便利。如果删除的是尾部元素，nxt 就是哨兵，不会出现空指针问题。如果删除的是头部元素，pre 就是哨兵，也不会有空指针问题。

基于 insert 和 erase，push_back、push_front、pop_back、pop_front 其实都可以用统一的接口实现。实际标准库的实现里，这些接口最终都会落到统一的插入删除逻辑上。

3.5 独特算法接口：splice、merge、unique 怎么实现

这几个接口是 list 独有的，vector 想都别想。splice 的实现有点反直觉，它不用 new 和 delete，而是直接把一个链表上的节点“摘下来”，挂到另一个链表上。

template <typename T> void list<T>::splice(iterator pos, list& other) { if (other.empty()) return; Node* cur = pos.node(); Node* pre = cur->prev; Node* first = other.head_->next; // 源链表第一个元素 Node* last = other.head_->prev; // 源链表最后一个元素 // 把 [first, last] 整个区间摘下来 other.head_->next = other.head_; other.head_->prev = other.head_; // 把区间挂到当前链表 pre->next = first; first->prev = pre; last->next = cur; cur->prev = last; size_ += other.size_; other.size_ = 0; }

这个操作的核心是只改指针，不创建新节点。源链表搬走之后变空了，其 size_ 归零，当前链表的 size_ 相应增加。这种“搬节点”的语义在标准库里就是 splice 的默认行为，面试里经常考到对源链表状态的影响。

merge 合并两个有序链表。常见实现方式是依次比较两个链表头部的元素，把较小的那个从源链表“拆”下来，挂到目标链表中。由于两个链表本身有序，这个比较过程可以做到线性复杂度。

template <typename T> void list<T>::merge(list& other) { if (this == &other) return; iterator it_this = begin(); iterator it_other = other.begin(); while (it_this != end() && it_other != other.end()) { if (*it_other < *it_this) { // 把 other 的当前节点搬到 it_this 前面 iterator next_other = it_other; ++next_other; Node* move_node = it_other.node(); Node* pos_node = it_this.node(); Node* pre = pos_node->prev; // 先从 other 摘除 move_node->prev->next = move_node->next; move_node->next->prev = move_node->prev; // 再挂到 this 里 pre->next = move_node; move_node->prev = pre; move_node->next = pos_node; pos_node->prev = move_node; it_other = next_other; ++size_; --other.size_; } else { ++it_this; } } // 如果 other 还有剩余（都是较大元素），整体拼到尾部 if (!other.empty()) { splice(end(), other); } }

merge 的实现细节较多，核心还是指针的摘除和挂接。这个实现里我用了迭代器操作，稍微显得繁琐一点，但便于理解语义。标准库的实际实现更底层，思路是一样的。

unique 的实现就是在链表中遍历一遍，把相邻重复的元素删除掉。因为链表的节点之间通过指针相连，删除之后需要继续比较新的相邻关系，所以用迭代器循环最方便。

4. 常见坑和排查心得

4.1 迭代器失效的典型场景

实际使用 list 时，迭代器失效问题比 vector 温和很多，但它不是没有。最常见的坑出现在 erase 和 splice 的混用上。

先看 erase。如果删除一个元素后，还继续使用指向它的迭代器，程序可能会出现未定义行为。具体表现可能是随机崩溃、数据错乱，也可能运气好没报错。问题在于节点被 delete 之后，那块内存可能已经被回收或者被其他对象占用，你再访问它里面存的指针，鬼才知道会发生什么。

我在实际代码 review 中见过一个典型错误。有人想把链表里所有的偶数值都删掉，他写出了这样一段逻辑：

for (auto it = lst.begin(); it != lst.end(); ) { if (*it % 2 == 0) { lst.erase(it); // it 已经失效了！ ++it; // 这步是未定义行为 } else { ++it; } }

这段代码第一眼看上去没什么问题，但 erase 之后 it 指向的节点已经被释放，此时再执行 ++it，相当于访问了已释放的内存。表面上可能不崩溃，但这是纯粹靠运气。正确的做法是直接用 erase 的返回值更新 it，或者用前面提到的 it++ 技巧。

splice 的坑则更隐蔽。splice 把一个节点从源链表搬到目标链表之后，源链表中原本指向这个节点的迭代器并没有失效，它还指向同一个节点。区别在于这个节点现在已经属于目标链表了，你通过源链表的这个迭代器操作节点，修改的不再是源链表的内容。这一点在逻辑上很容易被忽略，调试的时候经常让人一头雾水。

4.2 list 与 vector 的性能对比：数据不会说谎

光说理论没有感觉，我写过一个简单的性能测试，分别用 list 和 vector 做相同的操作，结果比较有意思。

插入测试：在链表头部连续插入 100 万个元素。list 的 push_front 是 O(1)，vector 的 insert(begin()) 是 O(n)，因为每次插入后面全部元素都要移动。这个测试 list 完胜，差别是数量级的。

遍历测试：对 100 万个元素做累计求和。vector 耗时大约是 list 的五分之一到三分之一。原因就是我前面说的缓存命中率。vector 是连续内存，遍历时 CPU 能高效预取；list 节点分散在堆中，访问一个节点就要去内存里捞一次。

排序测试：对 100 万个随机整数排序。这里有个反直觉的结果。vector 用 std::sort 比 list 的成员函数 sort 快很多，差距可能在十倍以上。虽然两者时间复杂度都是 O(n log n)，但 vector 的常数因子小得多，连续内存的访问效率碾压链表的指针跳跃。

这个测试给我最大的启发是：链表的 O(1) 插入删除优势是有条件的，一旦操作频率不够高，或者遍历和查询占比很大，vector 反而是更好的选择。工程上选择容器，不要只看复杂度，还要看数据规模、操作分布、内存访问模式。

4.3 内存碎片、分配器和工程建议

list 的每个节点单独 new，这是它能做到 O(1) 插入的原因，但也带来了内存碎片问题。如果你的程序频繁创建和销毁大量 list 节点，堆上会出现很多小块内存碎片，导致内存利用率下降，甚至影响整体性能。

缓解手段有两个思路。第一个思路是用自定义分配器。标准库的 list 模板第二个模板参数就是 allocator，你可以在一个大的内存池上实现节点分配，减少对全局堆的依赖。第二个思路是直接用 std::list 的静态方法，比如提前批量插入、避免频繁 clear。这个效果有限，很多时候还是分配器更靠谱。

说实话，在大多数业务代码里，list 都不是性能瓶颈所在。我见过很多项目把 list 用在小规模数据上，比如配置文件里的几十个目录项、UI 消息队列里的少量事件对象。这种场景，直接用 std::list 就好，别在这上面花太多心思做优化。

如果你确实遇到要频繁创建链表节点的场景，还有另一个思路：用 std::vector 加上逻辑上的“链表行为”，或者直接用第三方的侵入式链表。侵入式链表的节点里不存指向自己的指针，而是由外部容器管理，这能省去每个节点的独立分配开销。但这个方案写起来复杂，可读性也差些，除非有明确的性能瓶颈，否则不建议在团队项目里贸然引入。

我自己的经验是：优先用标准库容器，不要过早优化。等 profiling 数据明确指出 list 的内存分配是热点，再考虑换分配器或者改侵入式方案。绝大多数情况下，vector 加合理的预留（reserve）就已经处理得很好了。

写到这里，手写 list 的核心逻辑都过了一遍。我实际做这个练习时最大的感触是，自己写一遍和只看文档是完全不同的体验。只有亲手处理过 node_->prev->next 这类指针操作，你才真正理解为什么 list 的接口长这个样子，为什么 insert 不失效、erase 只让当前迭代器失效。

如果你正在学 STL 源码，我建议你也动手写一个简化版 list，不用管异常安全，先跑通基本功能。写的过程里遇到的所有“为什么”，都会成为你面试时最扎实的答案。