1. 从“容器”到“集合”为什么你需要了解C的set如果你刚开始接触C或者已经写过一些代码用过vector、array那你对“容器”这个概念应该不陌生。它们就像一个个盒子帮你把数据装起来方便你存取。但当你需要处理一些特殊需求时比如“自动去重”、“快速判断某个元素是否存在”、“按顺序遍历所有元素”普通的“盒子”就显得有点力不从心了。这时候你就需要认识一下C标准库里的“集合”容器——std::set。我第一次真正觉得set好用是在处理一个用户标签系统的时候。后台会收到大量用户打上的标签同一个用户可能重复提交相同的标签我需要把这些标签整理成一个唯一的、有序的列表方便后续的统计和展示。最开始我用的是vector每次插入新标签前都要遍历一遍整个列表用find函数检查是否已经存在。当用户量上来标签数量达到几万甚至几十万时这个遍历操作就成了性能瓶颈程序响应慢得让人抓狂。后来换成了set代码简洁到只需要一句tags.insert(newTag)不仅自动去重而且内部元素始终是有序的遍历输出时直接就是排好序的性能更是提升了几个数量级。那一刻我才明白选对工具事半功倍。简单来说std::set是一个关联容器它存储的是唯一的“键”key并且这些键会按照特定的顺序默认是升序自动排列。它的底层通常由红黑树一种自平衡的二叉查找树实现这保证了插入、删除和查找操作的平均时间复杂度都是O(log n)对于需要频繁进行“存在性检查”和“有序遍历”的场景效率远高于顺序容器如vector、list的O(n)查找。这篇文章我会从一个实际使用者的角度带你彻底搞懂set。我们不只讲语法更会深入它“为什么”要这么设计以及在实际项目中“怎么用”才能避开那些常见的坑。无论你是正在准备面试被“C八股文”里关于STL的问题困扰还是在实际开发中遇到了需要高效管理唯一集合的需求这篇超详细的指南都能给你直接的帮助。2. 核心特性与底层原理它凭什么这么“聪明”在开始敲代码之前我们必须先理解set的设计哲学。它不是一个简单的“数组”或“链表”而是一个高度结构化、有自己规则的“智能集合”。它的核心特性决定了它的适用场景和性能表现。2.1 三大核心特性唯一、有序、不可直接修改元素唯一性这是set最直观的特性。在同一个set中不允许存在两个值相同的元素。当你尝试插入一个已经存在的值时插入操作会被忽略不会报错但插入失败。这省去了我们手动去重的麻烦。自动排序set中的元素并非按照插入顺序存储而是会根据元素的“比较规则”自动进行排序。默认情况下它使用std::less即运算符进行升序排列。你也可以在定义set时传入自定义的比较函数或函数对象来指定排序规则。键即值不可直接修改在set中元素的值同时就是它的“键”key。这意味着你不能像修改vector里某个位置的值那样直接通过迭代器去修改set中的元素例如*it newValue;。因为修改元素可能会破坏set内部赖以维持有序性的红黑树结构。如果你需要修改一个元素通常的做法是先删除旧元素再插入新元素。2.2 底层数据结构红黑树简析为什么set能同时做到O(log n)的查找、插入、删除并且保持有序秘密就在于它的底层实现——红黑树Red-Black Tree。你可以把红黑树想象成一棵总是保持“相对平衡”的二叉树。它通过一套复杂的着色和旋转规则确保从根节点到任意叶子节点的最长路径不会超过最短路径的两倍。这种“平衡性”是高效操作的关键。查找从根节点开始比较目标值与当前节点值根据比较结果决定进入左子树或右子树每次比较都能排除掉大约一半的节点因此效率是O(log n)。插入先像查找一样找到合适的插入位置插入新节点初始为红色然后通过一系列的颜色翻转和树旋转操作修复可能被破坏的红黑树性质维持平衡。这个过程也是O(log n)。删除过程更复杂一些但核心思想类似在删除节点后通过调整来维持树的平衡复杂度同样是O(log n)。正因为底层是树形结构set的迭代器进行操作中序遍历时得到的就是有序的序列。同时这也解释了为什么set的元素不能直接修改——你无法保证修改后的新值还能放在树中正确的位置上这会导致整棵树的结构错乱。2.3 与其它容器的对比什么时候该用set理解了原理我们就能更理智地做技术选型。这里用一个表格来快速对比set和几个常用容器特性std::setstd::vectorstd::unordered_setstd::multiset元素是否唯一是否是否允许重复内部顺序有序默认升序插入顺序无序基于哈希有序默认升序底层数据结构红黑树动态数组哈希表红黑树平均查找复杂度O(log n)O(n)O(1)O(log n)插入/删除平均复杂度O(log n)尾部O(1) 中间O(n)O(1)O(log n)是否需要可哈希否需要可比较否是否需要可比较典型使用场景需要有序、唯一元素的集合频繁查找随机访问频繁尾部增删多只需快速判断存在性不关心顺序需要有序但允许重复的集合选择指南当你需要维护一个唯一且有序的集合并且会频繁地进行查找、插入、删除操作时set是你的首选。例如维护一个系统的在线用户ID列表需要快速判断用户是否在线并且可能按ID顺序进行某些操作。如果你只关心元素是否存在完全不关心顺序并且你的元素类型提供了良好的哈希函数那么std::unordered_setC11引入的平均O(1)操作会更快。如果你需要允许重复元素但同时要保持有序那么应该选择std::multiset。如果你的操作以随机访问通过下标和尾部插入为主那么vector仍然是效率最高的选择。注意set的O(log n)复杂度是“平均”且“摊还”的。虽然它不如unordered_set的O(1)惊艳但其有序性和稳定性不受哈希冲突影响在很多场景下是不可替代的。不要盲目追求O(1)而忽略了业务需求。3. 从零开始使用set完整API与实战示例理论说再多不如动手写一遍。这一部分我们将像搭积木一样从创建set对象开始一步步掌握它的所有常用操作。我会用具体的代码示例和注释让你看得明白抄得放心。3.1 基础操作创建、插入与遍历首先要使用set必须包含头文件set。#include iostream #include set using namespace std; int main() { // 1. 创建一个空的set存储int类型默认按升序排列 setint mySet; // 2. 插入元素 - insert() 方法 mySet.insert(3); mySet.insert(1); mySet.insert(4); mySet.insert(1); // 重复插入1会被忽略 mySet.insert(2); // 3. 遍历set - 迭代器 cout Set elements (using iterator): ; for (setint::iterator it mySet.begin(); it ! mySet.end(); it) { cout *it ; // 输出1 2 3 4 已自动排序 } cout endl; // 4. 使用范围for循环 (C11) - 更简洁 cout Set elements (using range-for): ; for (int num : mySet) { cout num ; } cout endl; // 5. 获取元素个数 - size() cout Size of set: mySet.size() endl; // 输出4 (不是5因为1重复了) // 6. 判断是否为空 - empty() setint emptySet; cout Is mySet empty? (mySet.empty() ? Yes : No) endl; cout Is emptySet empty? (emptySet.empty() ? Yes : No) endl; return 0; }插入操作的返回值insert方法有一个非常重要的返回值它是一个pairiterator, bool。first是一个迭代器指向被插入的元素如果插入成功或指向set中已存在的那个等值元素如果插入失败。second是一个bool值表示插入是否成功true表示成功插入新元素false表示元素已存在。这个返回值在需要知道插入是否真正发生时非常有用。auto result mySet.insert(5); if (result.second) { cout Element 5 inserted successfully. endl; } else { cout Element 5 already exists. Iterator points to: *(result.first) endl; }3.2 查找与删除精准操作集合元素找到了、用完了有时候也需要请出去。set提供了高效的查找和删除方法。#include iostream #include set using namespace std; int main() { setint mySet {10, 20, 30, 40, 50}; // C11 初始化列表 // 1. 查找元素 - find() int target 30; setint::iterator it mySet.find(target); if (it ! mySet.end()) { // 判断是否找到 cout Found element: *it endl; } else { cout Element target not found. endl; } // 2. 统计元素个数 - count() // 对于set返回值只能是0或1因为元素唯一。 // 对于multiset返回值可能大于1。 cout Count of 20: mySet.count(20) endl; // 输出1 cout Count of 99: mySet.count(99) endl; // 输出0 // 3. 删除元素 - erase() // 方法一通过值删除 size_t numRemoved mySet.erase(20); // 返回删除的元素个数对于set是0或1 cout Removed numRemoved instance(s) of 20. endl; // 方法二通过迭代器删除 it mySet.find(40); if (it ! mySet.end()) { mySet.erase(it); // 更高效因为省去了二次查找 } // 方法三删除一个区间 [first, last) // 例如删除从30开始到末尾之前的所有元素 it mySet.find(30); if (it ! mySet.end()) { // erase(it, mySet.end()) 会删除从it指向的元素开始直到end()不包括end() mySet.erase(it, mySet.end()); } cout Set after deletions: ; for (int num : mySet) { cout num ; // 输出10 只剩10了 } cout endl; // 4. 清空整个set - clear() mySet.clear(); cout Size after clear: mySet.size() endl; // 输出0 return 0; }实操心得在删除已知迭代器位置的元素时优先使用通过迭代器删除的方式erase(iterator)。通过值删除erase(value)会先内部执行一次find操作再执行删除。如果你已经通过find或其他方式获得了迭代器直接用它删除能避免一次不必要的查找。3.3 边界与范围操作处理有序集合的利器由于set是有序的它提供了一些基于顺序的特殊查询方法这在处理范围问题时非常高效。#include iostream #include set using namespace std; int main() { setint mySet {10, 20, 30, 40, 50, 60, 70}; // 1. 获取边界迭代器 if (!mySet.empty()) { cout Smallest element: *mySet.begin() endl; // 输出10 cout Largest element: *mySet.rbegin() endl; // 输出70 (反向迭代器) } // 2. 上下界查找 - lower_bound upper_bound // 假设我们想找到所有 35 且 65 的元素 int lowerVal 35; int upperVal 65; // lower_bound(val): 返回第一个 val 的元素的迭代器 setint::iterator lowIt mySet.lower_bound(lowerVal); // upper_bound(val): 返回第一个 val 的元素的迭代器 setint::iterator upIt mySet.upper_bound(upperVal); cout Elements in range [ lowerVal , upperVal ): ; for (auto it lowIt; it ! upIt; it) { cout *it ; // 输出40 50 60 } cout endl; // 3. 等值范围 - equal_range // 对于set因为元素唯一这个范围最多包含一个元素。 // 对于multiset更有用可以一次性获取所有等值元素的范围。 auto range mySet.equal_range(50); // 返回一个pairiterator, iterator if (range.first ! range.second) { cout Found element 50. endl; // range.first 是 lower_bound(50) 的结果 // range.second 是 upper_bound(50) 的结果 } // 一个更直观的例子删除某个范围内的所有元素 // 删除所有值在 [20, 50] 之间的元素 auto start mySet.lower_bound(20); // 第一个 20 的即20本身 auto end mySet.upper_bound(50); // 第一个 50 的即60 mySet.erase(start, end); cout Set after erasing [20, 50]: ; for (int num : mySet) { cout num ; // 输出10 60 70 } cout endl; return 0; }lower_bound和upper_bound是处理有序区间的核心工具。它们之所以高效O(log n)是因为底层红黑树支持快速的二分查找而不是像在vector中那样需要线性扫描。4. 进阶与定制让set适应你的复杂数据类型到目前为止我们用的都是int这种内置类型。但实际项目中我们更常需要存储自定义的结构体或类对象。这时set的“排序”特性就带来了挑战它怎么知道两个自定义对象谁大谁小呢4.1 存储自定义类型定义比较规则set默认使用std::less即运算符来比较元素。对于自定义类型你有两种方式来提供比较规则方法一重载运算符这是最直接的方法。在你的类或结构体内部重载小于运算符。#include iostream #include set #include string using namespace std; class Person { public: string name; int age; Person(string n, int a) : name(n), age(a) {} // 重载 运算符 // 这里我们定义按年龄升序排序。如果年龄相同再按名字升序排序。 bool operator(const Person other) const { if (age ! other.age) { return age other.age; } return name other.name; } // 为了方便打印重载 运算符 friend ostream operator(ostream os, const Person p) { os p.name ( p.age ); return os; } }; int main() { setPerson personSet; personSet.insert(Person(Alice, 30)); personSet.insert(Person(Bob, 25)); personSet.insert(Person(Charlie, 30)); // 年龄与Alice相同比较名字 personSet.insert(Person(Alice, 30)); // 与第一个Alice完全相同不会被插入 cout Persons in set (sorted by age, then name): endl; for (const auto p : personSet) { cout p endl; } // 输出 // Bob(25) // Alice(30) // Charlie(30) return 0; }方法二提供自定义比较函数对象仿函数这种方法更灵活尤其是当你不想或不能修改原有类的定义时或者你需要多种不同的排序方式。#include iostream #include set #include string using namespace std; struct Person { string name; int age; // 注意这里没有重载 运算符 }; // 自定义比较器按姓名升序排序 struct CompareByName { bool operator()(const Person a, const Person b) const { return a.name b.name; } }; int main() { // 在定义set时将比较器类型作为第二个模板参数传入 setPerson, CompareByName personSetByName; personSetByName.insert({Alice, 30}); personSetByName.insert({Bob, 25}); personSetByName.insert({Charlie, 35}); cout Persons sorted by name: endl; for (const auto p : personSetByName) { cout p.name - p.age endl; } // 输出 // Alice - 30 // Bob - 25 // Charlie - 35 // 你甚至可以定义另一个按年龄降序的set struct CompareByAgeDesc { bool operator()(const Person a, const Person b) const { return a.age b.age; // 注意这里是 实现降序 } }; setPerson, CompareByAgeDesc personSetByAgeDesc; personSetByAgeDesc.insert({Alice, 30}); personSetByAgeDesc.insert({Bob, 25}); personSetByAgeDesc.insert({Charlie, 35}); cout \nPersons sorted by age (descending): endl; for (const auto p : personSetByAgeDesc) { cout p.name - p.age endl; } // 输出 // Charlie - 35 // Alice - 30 // Bob - 25 return 0; }重要提醒自定义的比较规则必须满足严格弱序Strict Weak Ordering。简单来说它需要满足非自反性comp(a, a)必须为false。非对称性如果comp(a, b)为true则comp(b, a)必须为false。可传递性如果comp(a, b)为true且comp(b, c)为true则comp(a, c)必须为true。等价的可传递性如果!comp(a, b) !comp(b, a)即a和b“等价”并且!comp(b, c) !comp(c, b)那么必须有!comp(a, c) !comp(c, a)。不满足严格弱序的比较规则会导致set行为未定义通常会在运行时崩溃。最常见的错误是在比较浮点数时直接使用因为NaN不满足任何比较关系或者在多字段比较时逻辑写错。务必小心。4.2 性能考量与迭代器失效虽然set的操作大多是O(log n)但在某些特定场景下性能仍有差异并且迭代器的稳定性也需要关注。插入性能在已知位置附近插入通过hint迭代器可以提升效率。insert方法有一个重载版本iterator insert (iterator position, const value_type val)。如果你能提供一个指向插入位置“附近”的正确迭代器例如通过lower_bound获得插入操作可能接近常数时间。setint s {10, 30, 50}; auto hint s.lower_bound(25); // 指向30 s.insert(hint, 20); // 在30之前插入20效率可能更高查找性能find是O(log n)。如果你的操作模式是“先查找如果不存在则插入”那么使用insert的返回值pairiterator, bool是更高效的做法因为它将查找和插入合并为一次树操作。// 低效做法 if (mySet.find(value) mySet.end()) { mySet.insert(value); } // 高效做法 mySet.insert(value); // insert本身会检查是否存在迭代器失效set的迭代器在插入和删除操作中表现出很强的稳定性。插入不会使任何现有迭代器失效。删除只有指向被删除元素的迭代器会失效其他迭代器仍然有效。 这与vector插入/删除可能导致所有迭代器失效和deque在中间插入/删除会使所有迭代器失效形成鲜明对比。这使得在遍历set的同时安全地删除某些元素成为可能但需要小心处理迭代器。setint s {1, 2, 3, 4, 5, 6}; for (auto it s.begin(); it ! s.end(); /* 注意这里不递增 */) { if (*it % 2 0) { // 删除所有偶数 it s.erase(it); // erase(it) 返回被删除元素的下一个元素的迭代器 } else { it; } } // s 现在包含 {1, 3, 5}关键技巧在循环中删除元素时利用erase的返回值来更新迭代器这是安全且标准的做法。5. 实战场景与避坑指南了解了所有API之后我们来看看set在真实项目中是如何大显身手的以及有哪些“坑”需要提前避开。5.1 典型应用场景剖析场景一维护唯一且有序的ID集合这是set最经典的应用。比如在游戏服务器中维护所有在线玩家的ID需要快速检查某个玩家是否在线并且有时需要按ID顺序进行批量操作如广播消息给前N个玩家。setuint64_t onlinePlayerIds; // 玩家登录 onlinePlayerIds.insert(playerId); // 玩家退出 onlinePlayerIds.erase(playerId); // 快速检查是否在线 bool isOnline (onlinePlayerIds.find(playerId) ! onlinePlayerIds.end()); // 按顺序处理前100名玩家 int count 0; for (auto id : onlinePlayerIds) { doSomething(id); if (count 100) break; }场景二求交集、并集、差集利用set的有序特性可以高效地实现集合运算。标准库提供了std::set_intersection、std::set_union、std::set_difference等算法它们要求输入范围是有序的。#include iostream #include set #include algorithm #include iterator using namespace std; int main() { setint A {1, 2, 3, 4, 5}; setint B {3, 4, 5, 6, 7}; setint C; // 求交集 A ∩ B set_intersection(A.begin(), A.end(), B.begin(), B.end(), inserter(C, C.begin())); // 使用inserter迭代器插入结果 cout Intersection: ; for (int x : C) cout x ; // 输出3 4 5 cout endl; C.clear(); // 求并集 A ∪ B set_union(A.begin(), A.end(), B.begin(), B.end(), inserter(C, C.begin())); cout Union: ; for (int x : C) cout x ; // 输出1 2 3 4 5 6 7 cout endl; return 0; }场景三作为字典的“键”的集合当你有一个std::mapKey, Value有时你需要获取所有键key的集合。虽然map本身提供了迭代器但如果你需要一个独立、有序且唯一的键集合可以将其键插入到一个set中。mapstring, int studentScores {{Alice, 90}, {Bob, 85}, {Charlie, 92}}; setstring studentNames; for (const auto pair : studentScores) { studentNames.insert(pair.first); } // 现在 studentNames 是一个有序的学生姓名集合5.2 常见“坑”与解决方案坑一误用[]运算符std::map和std::unordered_map支持通过[]运算符来访问或插入元素但set没有这个运算符因为set只有键没有键值对通过键来索引值没有意义。试图使用mySet[5]会导致编译错误。正确做法插入用insert()查找用find()或count()。坑二试图修改set中的元素这是新手常犯的错误。由于set元素的常量性const通过迭代器获取的是const引用不能修改。setint s {1, 2, 3}; auto it s.find(2); // *it 4; // 错误编译不通过不能修改set中的元素正确做法如果需要修改必须先删除旧元素再插入新元素。但要注意这可能会使指向旧元素的迭代器失效。auto it s.find(2); if (it ! s.end()) { int newValue 4; s.erase(it); // 删除旧元素 s.insert(newValue); // 插入新元素 }坑三自定义比较规则不满足严格弱序这是最隐蔽也最危险的坑。比如你想按字符串长度排序但如果两个字符串长度相同你希望它们“相等”从而只保留一个。错误的写法// 错误的比较器不满足严格弱序 struct BadComparator { bool operator()(const string a, const string b) const { return a.length() b.length(); // 只比较长度 } }; setstring, BadComparator badSet; badSet.insert(apple); badSet.insert(banana); // 长度都是5根据比较器它们“等价”所以不会被插入 // 问题在于对于set“等价”(!comp(a,b) !comp(b,a))意味着“相同”但“apple”和“banana”内容不同。 // 这会导致未定义行为程序可能崩溃或产生奇怪的结果。正确做法当主要比较条件相等时必须提供一个次要比较条件来建立全序确保任意两个不同的元素都能比出大小。struct GoodComparator { bool operator()(const string a, const string b) const { if (a.length() ! b.length()) { return a.length() b.length(); } return a b; // 长度相同时按字典序比较 } }; setstring, GoodComparator goodSet; goodSet.insert(apple); goodSet.insert(banana); // 现在两者都会存在且按字典序排列坑四忽略insert的返回值导致低效操作在需要知道元素是否是新插入的场景下忽略insert的返回值意味着你可能需要额外调用一次find。// 低效 if (mySet.find(value) mySet.end()) { mySet.insert(value); // 处理新插入的情况 } // 高效 auto result mySet.insert(value); if (result.second) { // 处理新插入的情况result.first 是指向新元素的迭代器 }坑五在循环中删除元素时迭代器处理不当这是很多容器的通病但在set中由于迭代器相对稳定正确的处理模式是利用erase的返回值。setint s {1, 2, 3, 4, 5}; // 错误做法未定义行为 for (auto it s.begin(); it ! s.end(); it) { if (*it % 2 0) { s.erase(it); // it 失效了下一次循环的 it 行为未定义 } } // 正确做法 for (auto it s.begin(); it ! s.end(); ) { if (*it % 2 0) { it s.erase(it); // erase 返回下一个有效迭代器 } else { it; } }6. 性能测试与选型思考理论上的复杂度是O(log n)但实际表现如何我们通过一个简单的测试来感受一下set、unordered_set和vector在查找操作上的性能差异。这个测试虽然不严谨但能给我们一个直观的印象。#include iostream #include set #include unordered_set #include vector #include algorithm #include chrono #include random using namespace std; using namespace std::chrono; int main() { const int N 100000; // 元素数量 const int M 10000; // 查找次数 // 生成随机数 vectorint data(N); random_device rd; mt19937 gen(rd()); uniform_int_distribution dis(1, N * 10); for (int i 0; i N; i) { data[i] dis(gen); } // 准备容器 setint s; unordered_setint us; vectorint v; // 插入数据 for (int num : data) { s.insert(num); us.insert(num); v.push_back(num); } // 对vector排序以便使用binary_search sort(v.begin(), v.end()); // 生成待查找的随机数一半存在一半不存在 vectorint searchKeys(M); for (int i 0; i M; i) { if (i % 2 0) { searchKeys[i] data[dis(gen) % N]; // 存在的数 } else { searchKeys[i] dis(gen) N * 10; // 可能不存在的数 } } // 测试 set 查找 auto start high_resolution_clock::now(); int foundCount 0; for (int key : searchKeys) { if (s.find(key) ! s.end()) { foundCount; } } auto end high_resolution_clock::now(); auto duration_set duration_castmicroseconds(end - start); cout set find() time: duration_set.count() us, found: foundCount endl; // 测试 unordered_set 查找 start high_resolution_clock::now(); foundCount 0; for (int key : searchKeys) { if (us.find(key) ! us.end()) { foundCount; } } end high_resolution_clock::now(); auto duration_uset duration_castmicroseconds(end - start); cout unordered_set find() time: duration_uset.count() us, found: foundCount endl; // 测试 vector 的 binary_search start high_resolution_clock::now(); foundCount 0; for (int key : searchKeys) { if (binary_search(v.begin(), v.end(), key)) { foundCount; } } end high_resolution_clock::now(); auto duration_vec duration_castmicroseconds(end - start); cout vector binary_search() time: duration_vec.count() us, found: foundCount endl; return 0; }在我的测试环境10万数据1万次查找下结果大致如下具体数值因机器而异但关系稳定unordered_set最快通常在几百微秒级别。哈希表的O(1)查找名不虚传。set次之通常在几千微秒级别。O(log n)的查找在数据量大时依然高效。vectorbinary_search与set处于同一数量级有时甚至略快因为数组连续内存访问对CPU缓存更友好。但是vector的插入和删除成本远高于set。这个测试告诉我们如果只需要极快的查找且不关心顺序unordered_set是王者。如果需要有序性或者需要频繁的插入删除set是平衡的选择。如果数据基本固定只需要一次性排序后频繁查找排序后的vector配合binary_search可能是性能最好、内存最紧凑的方案但它失去了动态插入删除的高效性。选择容器永远是在功能需求是否需要有序、唯一、操作类型查找、插入、删除的频率和性能表现之间做权衡。没有最好的容器只有最适合当前场景的容器。7. 延伸阅读与set相关的其他容器掌握了set理解它的“兄弟姐妹”就很容易了。它们共享相似的设计理念和接口。std::multiset允许存储重复元素的“集合”。它的insert操作总是成功。find会返回指向第一个匹配元素的迭代器count会返回该元素出现的次数。equal_range方法在这里特别有用可以获取所有重复元素的范围。std::unordered_set(C11)基于哈希表的集合提供平均O(1)的查找、插入和删除。它不保证元素顺序。使用它需要你的元素类型有可用的哈希函数标准类型如int、string已提供自定义类型需要特化std::hash或提供自定义哈希函数。std::map/std::multimap如果你需要存储键值对key-value pairs而不是单独的键那么应该使用map键唯一或multimap键可重复。它们的底层也是红黑树保持了键的有序性。std::unordered_map(C11)基于哈希表的键值对容器提供平均O(1)的访问。当你需要set的功能但发现自定义类型的哈希函数比比较函数更容易实现时或者当你完全不需要顺序时unordered_set是你的下一个学习目标。回过头看set就像是一个严谨的图书管理员。它不允许两本完全相同的书唯一性并且总是按照特定的编号规则比较器把书整理得井井有条有序性。当你需要找一本书时它不会从第一本开始漫无目的地找而是根据编号规则快速定位到大概区域二分查找。这个特性使得它在处理需要“唯一标识”和“快速检索”的场景时成为了一个不可或缺的工具。理解它的原理和脾气你就能在合适的场合放心地使用它避免很多不必要的性能损耗和逻辑错误。
