C++ std::list 实战指南：双向链表容器的核心特性与高效应用 1. 项目概述为什么你需要深入了解 std::list在C的世界里容器是构建一切复杂数据结构的基石。当你需要频繁地在序列中间插入或删除元素时std::vector的“搬家式”操作会让你头疼不已而std::deque的内部结构又略显复杂。这时std::list——这个基于双向链表的容器就该登场了。我见过太多项目因为容器选型不当导致性能瓶颈隐藏在代码深处直到线上压力测试时才暴露出来追悔莫及。std::list的核心价值在于其插入和删除操作的时间复杂度是常数O(1)并且迭代器在元素移动时只要元素本身未被删除是稳定的。这意味着如果你正在处理一个需要频繁重组、元素位置经常变动的数据集比如一个实时更新的游戏对象列表、一个需要不断调整优先级的任务队列或者一个图形编辑器中的图层管理std::list会是比std::vector更明智的选择。当然它不支持随机访问即不能用[ ]运算符这是为链表特性付出的代价。这篇文章不是简单的API罗列而是我结合多年踩坑经验为你梳理的一份std::list实战指南。我会从它的内部实现原理讲起拆解每一个关键操作的底层逻辑和性能开销然后通过几个贴近真实开发的示例展示如何把它用对、用好。无论你是正在准备面试、啃八股文的初学者还是想在项目中优化数据结构的资深开发者相信都能从中找到你需要的东西。2. std::list 的核心特性与内部机制剖析2.1 双向链表一切特性的根源要理解std::list必须从它的底层数据结构——双向链表说起。这决定了它所有的优势和劣势。想象一下一列老式火车每一节车厢节点都通过挂钩指针与前一节和后一节车厢相连。std::list的每个节点大致包含三部分存储的数据value、指向前一个节点的指针prev、指向后一个节点的指针next。此外容器本身通常还会维护一个“哨兵节点”或头尾指针来标记链表的开始和结束。这种结构带来了几个直接后果O(1)的插入与删除在已知位置通过迭代器定位插入或删除一个节点只需要修改相邻节点的几个指针无需移动任何其他数据。这是std::list最核心的优势。迭代器稳定性因为节点在内存中是独立分配的插入新节点或拼接splice现有节点不会导致其他节点的地址变化。因此指向其他元素的迭代器、引用和指针在操作后依然有效除非该元素被删除。这一点在复杂的状态管理或缓存场景中至关重要。不支持随机访问要访问链表中第n个元素你必须从头部或尾部开始沿着指针“走”n步。这意味着operator[]和at()方法是不存在的其时间复杂度是O(n)。更高的内存开销每个元素除了存储数据本身还需要额外存储两个指针在64位系统上通常是16字节。对于存储小对象比如int、char的链表这个开销比例会非常惊人可能远超数据本身的大小。缓存不友好链表节点在内存中是分散存储的不像std::vector那样是连续的内存块。当遍历链表时CPU无法有效地预读数据缓存命中率低这会导致遍历速度远慢于std::vector即使它们的时间复杂度都是O(n)。注意很多人知道链表插入快但常常忽略其遍历慢和内存开销大的缺点。在选择std::list前一定要评估你的主要操作是遍历多还是插入删除多。对于小型数据集或元素本身很大的情况遍历的劣势可能被掩盖但对于需要频繁线性访问的大型数据集std::vector通常是更好的选择即使它插入慢但现代CPU的缓存优势足以碾压链表。2.2 与其它顺序容器的横向对比光说std::list好不行得放在一起比才知道什么时候该用它。我们把它和std::vector、std::deque、std::forward_list放在一起看。特性std::vectorstd::dequestd::liststd::forward_list(C11)底层结构动态数组分块数组双端队列双向链表单向链表随机访问O(1) 连续内存O(1)不支持 O(n)不支持 仅前向尾部插入/删除摊还O(1)O(1)O(1)O(1) (需维护尾迭代器)头部插入/删除O(n)O(1)O(1)O(1)中间插入/删除O(n)O(n)O(1)(已知位置)O(1)(已知位置)迭代器稳定性插入/删除常导致失效中间插入/删除导致失效强稳定(元素未删则有效)强稳定(元素未删则有效)内存开销低 (仅可能容量冗余)中 (管理多个内存块)高 (每元素两个指针)中 (每元素一个指针)缓存友好度极好好差差主要适用场景默认选择 随机访问多 尾部操作多头尾操作都频繁的队列频繁任意位置插入/删除 需迭代器稳定内存极端敏感 只需前向遍历从表格可以清晰看出std::list的战场非常明确当你需要频繁在序列中间进行插入或删除并且需要保证迭代器、指针或引用的长期有效性时。典型的例子包括LRU缓存实现需要将最近使用的元素移动到链表头部这涉及中间节点的删除和头部插入。图形编辑器中的对象列表用户频繁调整图层顺序拼接操作。实时游戏中的单位管理单位不断被创建和销毁且其他系统可能持有对某个单位的引用。2.3 关键成员类型与迭代器理解std::list的成员类型是正确使用它的基础。当你声明一个std::listint myList;时编译器为你生成了一个高度特化的类型。value_type:int。你存储的元素类型。reference:int。元素的引用类型。iterator/const_iterator:双向迭代器。这是std::list的“导航器”。它支持下一个、--上一个操作但不支持 n或- n随机跳跃。begin()返回指向第一个元素的迭代器end()返回指向“尾后”位置的迭代器这是一个重要的“哨兵”不指向任何有效元素。reverse_iterator/const_reverse_iterator: 反向迭代器用rbegin()和rend()获取可以让你从后往前遍历链表。关于迭代器失效的黄金法则对于std::list只有指向被删除元素的迭代器会失效。指向其他元素的迭代器、引用和指针在插入、删除、拼接splice甚至排序sort后都保持有效。这是链表相比数组类容器一个巨大的优势但也需要你小心管理那些指向已删除元素的“野”迭代器。3. std::list 核心操作详解与实战技巧了解了底层原理我们进入实战环节。我会按照创建、增删改查、特殊操作的顺序结合代码示例和性能分析带你掌握每一个关键点。3.1 创建与初始化创建std::list有多种方式选择哪种取决于你的数据来源和初始化需求。#include list #include vector #include iostream int main() { // 1. 默认构造函数创建一个空链表 std::listint list1; // 2. 指定初始大小和值 std::listint list2(5, 100); // 包含5个元素每个都是100 // list2: {100, 100, 100, 100, 100} // 3. 通过迭代器范围初始化从其他容器拷贝 std::vectorint vec {1, 2, 3, 4, 5}; std::listint list3(vec.begin(), vec.end()); // 拷贝vec的所有元素 // list3: {1, 2, 3, 4, 5} // 4. 初始化列表 (C11 起) std::listint list4 {10, 20, 30, 40, 50}; // 最简洁的方式 // list4: {10, 20, 30, 40, 50} // 5. 拷贝构造函数和移动构造函数 (C11) std::listint list5(list4); // 拷贝list4 std::listint list6(std::move(list4)); // 移动list4list4现在为空 // list5: {10, 20, 30, 40, 50} // list6: {10, 20, 30, 40, 50} // list4: {} return 0; }实操心得对于已知的少量初始数据优先使用初始化列表方式4代码最清晰。如果需要从其他容器如std::vector、C风格数组转换数据使用迭代器范围初始化方式3是标准做法。尽量避免先创建空链表再一个个push_back因为多次分配节点可能带来不必要的开销。3.2 元素访问与遍历由于不支持随机访问遍历std::list只有两种主要方式迭代器和范围for循环。#include list #include iostream int main() { std::listint myList {1, 2, 3, 4, 5}; // 方法1使用迭代器 (最传统、最灵活) std::cout Using iterator: ; for (std::listint::iterator it myList.begin(); it ! myList.end(); it) { std::cout *it ; // 解引用迭代器获取值 // *it *it * 2; // 可以修改元素值 } std::cout std::endl; // 方法2使用常量迭代器 (如果不需要修改) std::cout Using const_iterator: ; for (std::listint::const_iterator cit myList.cbegin(); cit ! myList.cend(); cit) { std::cout *cit ; // *cit 10; // 错误不能通过const_iterator修改值 } std::cout std::endl; // 方法3使用基于范围的for循环 (C11 最简洁) std::cout Using range-based for: ; for (const auto value : myList) { // 使用const引用避免拷贝 std::cout value ; } std::cout std::endl; // 方法4反向遍历 std::cout Using reverse iterator: ; for (auto rit myList.rbegin(); rit ! myList.rend(); rit) { std::cout *rit ; } std::cout std::endl; // 访问首尾元素 (仅此两个直接访问接口) if (!myList.empty()) { std::cout Front: myList.front() std::endl; // 1 std::cout Back: myList.back() std::endl; // 5 } // 错误示例尝试随机访问 // std::cout myList[2] std::endl; // 编译错误没有operator[] // auto middle myList.begin() 2; // 编译错误迭代器不支持 操作 return 0; }遍历性能警告虽然遍历的时间复杂度是O(n)但由于缓存不友好实际速度可能比遍历同样大小的std::vector慢一个数量级。如果算法瓶颈在于遍历务必考虑换用std::vector。3.3 插入与删除操作这是std::list的“高光”环节。所有插入和删除操作只要你能提供正确的位置迭代器时间复杂度都是O(1)。3.3.1 基础插入push_front, push_back, insert#include list #include iostream int main() { std::listint lst {2, 3}; // 头部和尾部插入 lst.push_front(1); // lst: {1, 2, 3} lst.push_back(4); // lst: {1, 2, 3, 4} // 在指定位置前插入单个元素 auto it std::find(lst.begin(), lst.end(), 3); if (it ! lst.end()) { lst.insert(it, 99); // 在3之前插入99 // lst: {1, 2, 99, 3, 4} } // 在指定位置插入多个相同元素 it std::find(lst.begin(), lst.end(), 4); if (it ! lst.end()) { lst.insert(it, 3, 88); // 在4之前插入3个88 // lst: {1, 2, 99, 3, 88, 88, 88, 4} } // 在指定位置插入一个初始化列表 lst.insert(lst.begin(), { -2, -1, 0}); // 在开头插入 // lst: {-2, -1, 0, 1, 2, 99, 3, 88, 88, 88, 4} // C11 的 emplace 系列原地构造避免临时对象拷贝/移动 struct Point { int x; int y; Point(int a, int b) : x(a), y(b) {} }; std::listPoint pointList; pointList.push_back(Point(1, 2)); // 构造临时Point再移动或拷贝到链表 pointList.emplace_back(3, 4); // 直接在链表节点中构造Point(3,4)更高效 pointList.emplace_front(5, 6); // 在头部原地构造 for (const auto p : pointList) { std::cout ( p.x , p.y ) ; } // 输出: (5, 6) (1, 2) (3, 4) return 0; }3.3.2 基础删除pop_front, pop_back, erase#include list #include iostream int main() { std::listint lst {1, 2, 3, 4, 5, 6, 7, 8}; // 删除首尾元素 lst.pop_front(); // 删除1 lst.pop_back(); // 删除8 // lst: {2, 3, 4, 5, 6, 7} // 删除指定位置的单个元素 auto it std::find(lst.begin(), lst.end(), 4); if (it ! lst.end()) { it lst.erase(it); // 删除4erase返回被删除元素之后的位置指向5 // 此时it指向5 } // lst: {2, 3, 5, 6, 7} // 删除一个区间 [first, last) auto first std::find(lst.begin(), lst.end(), 3); auto last std::find(lst.begin(), lst.end(), 6); if (first ! lst.end() last ! lst.end()) { // 删除从3含到6不含之间的元素 lst.erase(first, last); // 删除3和5 } // lst: {2, 6, 7} // 清空整个链表 lst.clear(); // lst: {} std::cout Size after clear: lst.size() std::endl; // 0 std::cout Is empty? std::boolalpha lst.empty() std::endl; // true return 0; }重要陷阱erase函数会使指向被删除元素的迭代器失效但它会返回一个指向被删除元素之后位置的有效迭代器。在循环中删除元素时必须利用这个返回值来更新循环变量否则会导致未定义行为。这是链表和所有STL容器操作中的一个经典坑。3.3.3 条件删除remove 和 remove_ifstd::list提供了基于值的删除和基于谓词的删除这两个是成员函数比用std::remove_if算法erase的组合更高效因为它们是专门为链表优化的。#include list #include iostream #include algorithm int main() { std::listint lst {1, 2, 3, 2, 4, 2, 5}; // 1. remove(value): 删除所有等于value的元素 lst.remove(2); // 删除所有值为2的元素 // lst: {1, 3, 4, 5} // 2. remove_if(predicate): 删除所有使谓词返回true的元素 lst.remove_if([](int n) { return n % 2 0; }); // 删除所有偶数 // lst: {1, 3, 5} // 对比使用通用算法 std::remove_if erase 不推荐用于list std::listint lst2 {1, 2, 3, 4, 5}; auto new_end std::remove_if(lst2.begin(), lst2.end(), [](int n){ return n 3; }); lst2.erase(new_end, lst2.end()); // lst2: {1, 2, 3} // 这种方法会先“标记”要删除的元素然后通过移动元素来覆盖最后再删除尾部。 // 对于链表移动元素是低效的而成员函数 remove_if 直接操作指针效率更高。 return 0; }3.4 链表专属操作splice, merge, sort, unique, reverse这些是std::list作为链表容器特有的、高效的操作它们直接操作节点指针而非拷贝或移动元素数据。3.4.1 splice拼接链表splice是std::list的“王牌”操作它可以将另一个链表或其中一部分的节点移动到当前链表的指定位置时间复杂度是O(1)或O(n)取决于形式且不涉及任何元素的拷贝或移动只修改指针。#include list #include iostream int main() { std::listint list1 {1, 2, 3}; std::listint list2 {4, 5, 6}; std::listint list3 {7, 8, 9}; // 形式1将另一个链表的所有元素拼接到当前链表的指定位置之前 auto it std::find(list1.begin(), list1.end(), 3); list1.splice(it, list2); // 将list2的全部内容拼接到list1的3之前 // list1: {1, 2, 4, 5, 6, 3} // list2: {} (变空) // 形式2将另一个链表的单个元素拼接过來 list1.splice(list1.begin(), list3, std::next(list3.begin())); // 将list3的第二个元素(8)拼接到list1开头 // list1: {8, 1, 2, 4, 5, 6, 3} // list3: {7, 9} // 形式3将另一个链表的一个子区间拼接过來 auto first list3.begin(); // 指向7 auto last std::next(first, 2); // 指向9之后的位置 list1.splice(list1.end(), list3, first, last); // 将list3的[7, 9)区间拼接到list1末尾 // list1: {8, 1, 2, 4, 5, 6, 3, 7} // list3: {9} for (int n : list1) std::cout n ; // 输出: 8 1 2 4 5 6 3 7 std::cout std::endl; return 0; }核心优势splice操作后所有指向被移动元素的迭代器、引用和指针仍然有效只不过它们现在属于新的链表list1。这个特性在需要保持对象引用稳定的复杂系统中极其有用。3.4.2 merge合并有序链表merge用于合并两个已经排序的链表。合并后目标链表包含所有元素且保持有序源链表变为空。默认使用运算符比较也可以传入自定义比较函数。#include list #include iostream int main() { std::listint sorted1 {1, 3, 5, 7}; std::listint sorted2 {2, 4, 6, 8}; sorted1.merge(sorted2); // 合并sorted2到sorted1 // sorted1: {1, 2, 3, 4, 5, 6, 7, 8} // sorted2: {} (变空) for (int n : sorted1) std::cout n ; std::cout std::endl; // 使用自定义比较函数降序合并 std::listint desc1 {7, 5, 3, 1}; std::listint desc2 {8, 6, 4, 2}; desc1.merge(desc2, std::greaterint()); // 传入greaterint实现降序合并 // desc1: {8, 7, 6, 5, 4, 3, 2, 1} // desc2: {} // 重要前提两个链表必须已经按照相同的比较规则排好序 // 如果未排序就调用merge结果是未定义的可能崩溃或得到错误结果。 return 0; }3.4.3 sort链表排序std::list有自己的sort成员函数它通常实现为归并排序因为归并排序天然适合链表结构。不要使用std::sort算法因为std::sort要求随机访问迭代器而std::list的迭代器是双向的。#include list #include iostream #include algorithm // 注意这里不会用std::sort int main() { std::listint lst {5, 3, 8, 1, 9, 2}; // 使用成员函数 sort lst.sort(); // 默认升序 // lst: {1, 2, 3, 5, 8, 9} // 使用自定义比较函数降序排序 lst.sort(std::greaterint()); // lst: {9, 8, 5, 3, 2, 1} // 错误示例尝试使用 std::sort // std::sort(lst.begin(), lst.end()); // 编译错误因为list的迭代器不是随机访问迭代器。 // 性能对比对于链表lst.sort() 比先将元素拷贝到vector排序再拷回来要快。 // 因为lst.sort()直接操作指针而vector排序涉及大量元素移动对于大对象代价高。 return 0; }3.4.4 unique去除连续重复项unique删除连续的重复元素。通常需要先排序才能去除所有重复项。#include list #include iostream int main() { std::listint lst {1, 2, 2, 3, 3, 3, 2, 1, 1}; // 注意重复项不全是连续的 // 直接调用unique只去除连续的重复 lst.unique(); // lst: {1, 2, 3, 2, 1} // 非连续的2和1没有被去除 // 标准去重流程先排序再unique lst {1, 2, 2, 3, 3, 3, 2, 1, 1}; lst.sort(); lst.unique(); // lst: {1, 2, 3} // 可以传入二元谓词自定义“相等”的判断条件 std::listdouble dlist {1.0, 1.1, 1.05, 2.0, 2.1}; dlist.unique([](double a, double b) { return std::abs(a - b) 0.1; }); // 认为相差小于0.1即为“相等”会删除1.1或1.05中的一个 // 结果取决于实现可能是 {1.0, 2.0, 2.1} 或类似 return 0; }3.4.5 reverse反转链表reverse将链表的元素顺序反转操作非常高效只需要修改每个节点的prev和next指针。#include list #include iostream int main() { std::listint lst {1, 2, 3, 4, 5}; lst.reverse(); // lst: {5, 4, 3, 2, 1} for (int n : lst) std::cout n ; return 0; }4. 实战示例用 std::list 实现一个简单的 LRU 缓存理论讲得再多不如一个实战例子来得透彻。LRULeast Recently Used缓存淘汰算法是std::list的经典应用场景。其核心思想是当缓存满时淘汰最久未被使用的数据。我们需要快速找到并更新最近使用的项链表非常适合。设计思路使用一个std::liststd::pairKey, Value作为缓存队列链表头部是最近使用的尾部是最久未使用的。使用一个std::unordered_mapKey, 链表迭代器来实现O(1)时间的键查找。get操作通过哈希表找到键对应的链表迭代器将该节点移动到链表头部并返回值。put操作如果键已存在更新值并将节点移动到头部。如果键不存在且缓存未满在链表头部插入新节点并更新哈希表。如果键不存在且缓存已满删除链表尾部节点同时从哈希表中删除对应的键然后在头部插入新节点。#include list #include unordered_map #include iostream templatetypename Key, typename Value class LRUCache { private: using ListType std::liststd::pairKey, Value; using MapType std::unordered_mapKey, typename ListType::iterator; size_t capacity_; ListType cacheList_; // 双向链表 (key, value) 对 front最新back最旧 MapType keyMap_; // 哈希表 key - 链表迭代器 public: explicit LRUCache(size_t capacity) : capacity_(capacity) {} Value* get(const Key key) { auto it keyMap_.find(key); if (it keyMap_.end()) { return nullptr; // 未找到 } // 找到将该节点移动到链表头部表示最近使用 // splice 是 O(1) 操作且迭代器保持有效 cacheList_.splice(cacheList_.begin(), cacheList_, it-second); // it-second 迭代器现在指向被移动的节点在哈希表中仍然有效 return (it-second-second); // 返回值的指针 } void put(const Key key, const Value value) { auto it keyMap_.find(key); if (it ! keyMap_.end()) { // 键已存在更新值并移动到头部 it-second-second value; cacheList_.splice(cacheList_.begin(), cacheList_, it-second); return; } // 键不存在需要插入 if (cacheList_.size() capacity_) { // 缓存已满淘汰最久未使用的链表尾部 auto last cacheList_.back(); // 获取尾部的键值对 keyMap_.erase(last.first); // 从哈希表删除键 cacheList_.pop_back(); // 从链表删除节点 } // 在链表头部插入新节点 cacheList_.emplace_front(key, value); // 在哈希表中记录 key - 新节点的迭代器 keyMap_[key] cacheList_.begin(); } void print() const { std::cout LRU Cache (most recent - least recent): ; for (const auto kv : cacheList_) { std::cout [ kv.first : kv.second ] ; } std::cout std::endl; } }; int main() { LRUCacheint, std::string cache(3); cache.put(1, Data1); cache.put(2, Data2); cache.put(3, Data3); cache.print(); // 输出: [3:Data3] [2:Data2] [1:Data1] auto* val cache.get(2); // 访问 key2 if (val) { std::cout Got key 2: *val std::endl; } cache.print(); // 输出: [2:Data2] [3:Data3] [1:Data1] (2被提到最前) cache.put(4, Data4); // 插入新元素缓存满淘汰最旧的 key1 cache.print(); // 输出: [4:Data4] [2:Data2] [3:Data3] cache.put(2, Data2-Updated); // 更新已存在的 key2 cache.print(); // 输出: [2:Data2-Updated] [4:Data4] [3:Data3] return 0; }为什么用 std::listsplice 操作是 O(1)将节点移动到链表头部是LRU的核心高频操作splice只修改指针效率极高。迭代器稳定性哈希表存储的是链表迭代器。当使用splice移动节点时迭代器本身不会失效哈希表里的指针依然指向正确的节点无需更新。如果用std::vector插入删除导致的元素移动会使迭代器失效管理起来会非常复杂。头部插入删除是 O(1)push_front和pop_back淘汰都是常数时间。这个例子完美展示了std::list在需要频繁调整元素顺序、且需要保持外部引用稳定的场景下的巨大优势。5. 性能考量、常见陷阱与最佳实践5.1 何时用何时不用优先考虑使用 std::list 的场景频繁在序列中间进行插入或删除这是链表的天生优势O(1)复杂度。需要极强的迭代器/引用稳定性元素插入、删除、甚至链表合并排序都不会使指向其他元素的迭代器失效。不需要随机访问你的算法主要是顺序遍历或只在头尾操作。元素对象很大或拷贝代价高昂链表插入删除只操作指针不移动元素本身。而vector插入可能导致整个数组重新分配和拷贝。避免使用 std::list优先考虑 std::vector 的场景需要频繁随机访问元素这是vector的绝对优势。存储的基本类型或小对象链表每个元素的内存开销两个指针可能比数据本身还大且缓存不友好会导致遍历极慢。内存占用敏感链表每个节点的额外开销和内存碎片化可能导致总内存使用量更高。作为默认选择std::vector因其缓存友好性和简单性在大多数情况下都是默认的最佳选择。只有在明确链表优势的场景下才使用list。5.2 迭代器失效陷阱再强调虽然std::list的迭代器很稳定但仍有失效的情况指向被删除元素的迭代器必然失效。这是最需要小心的。在循环中删除元素必须使用erase的返回值更新迭代器。// 正确做法 for (auto it lst.begin(); it ! lst.end(); /* 不在这里递增 */) { if (condition(*it)) { it lst.erase(it); // erase返回下一个有效迭代器 } else { it; } } // 错误做法在删除后继续使用旧的it for (auto it lst.begin(); it ! lst.end(); it) { if (condition(*it)) { lst.erase(it); // it 失效后续 it 行为未定义 } }指向被pop_front()或pop_back()删除元素的迭代器也会失效。5.3 与算法库的配合std::list提供了自己的sort,merge,remove,remove_if,unique,reverse这些都比通用算法std::sort,std::remove等更高效务必使用成员函数版本。对于查找操作如std::find、std::find_if可以使用通用算法因为它们是线性遍历链表和向量效率差异不大虽然链表缓存不友好。但如果查找是主要操作或许你应该考虑std::set或std::unordered_set。5.4 内存与调试建议内存碎片频繁的插入删除可能导致内存碎片。在极端性能要求的场景下可以考虑使用自定义分配器或内存池来管理链表节点。调试在调试器中查看std::list的内容可能不如std::vector直观因为节点是分散的。但大多数现代调试器如VS、GDB都提供了良好的std::list可视化支持。C11/14/17/20 新特性充分利用emplace系列C11来避免拷贝使用std::list的模板推导指南C17简化声明关注C20 Ranges和C23的append_range/prepend_range等新方法它们能让代码更简洁。选择std::list从来不是因为它“高级”而是因为它解决了特定场景下的特定痛点。理解其O(1)插入删除和迭代器稳定性的代价是牺牲随机访问和缓存局部性是做出正确选择的关键。下次当你需要维护一个频繁变动的列表并且有多个地方持有其中元素的引用时你会庆幸自己手里有std::list这把精准的手术刀。