std::unordered_set<Key,Hash,KeyEqual,Allocator>::insert

std::pair<iterator,bool> insert( const value_type& value );	(1)	(自 C++11 起)
std::pair<iterator,bool> insert( value_type&& value );	(2)	(自 C++11 起)
iterator insert( const_iterator hint, const value_type& value );	(3)	(自 C++11 起)
iterator insert( const_iterator hint, value_type&& value );	(4)	(自 C++11 起)
template< class InputIt > void insert( InputIt first, InputIt last );	(5)	(自 C++11 起)
void insert( std::initializer_list<value_type> ilist );	(6)	(自 C++11 起)
insert_return_type insert( node_type&& nh );	(7)	(自 C++17 起)
iterator insert( const_iterator hint, node_type&& nh );	(8)	(自 C++17 起)
template< class K > std::pair<iterator, bool> insert( K&& obj );	(9)	(自 C++23 起)
template< class K > iterator insert( const_iterator hint, K&& obj );	(10)	(自 C++23 起)

将元素插入到容器中，如果容器尚未包含具有等效键的元素。

1,2) 插入 value。

3,4) 插入 value，使用 hint 作为非强制性建议，指示搜索应从何处开始。

5) 从范围 [first, last) 插入元素。如果范围内的多个元素具有比较等效的键，则未指定插入哪个元素（待定 LWG2844）。

6) 从初始化列表 ilist 插入元素。如果范围内的多个元素具有比较等效的键，则未指定插入哪个元素（待定 LWG2844）。

7) 如果 nh 是一个空节点句柄，则不执行任何操作。否则，如果容器尚未包含与 nh.key() 等效的键的元素，则将 nh 拥有的元素插入到容器中。如果 nh 不为空且 get_allocator() != nh.get_allocator()，则行为未定义。

8) 如果 nh 是一个空节点句柄，则不执行任何操作并返回末尾迭代器。否则，如果容器尚未包含与 nh.key() 等效的键的元素，则将 nh 拥有的元素插入到容器中，并返回指向具有与 nh.key() 等效的键的元素的迭代器（无论插入成功还是失败）。如果插入成功，则 nh 被移动，否则它保留对元素的所有权。hint 用作非强制性建议，指示搜索应从何处开始。如果 nh 不为空且 get_allocator() != nh.get_allocator()，则行为未定义。

9) 如果 *this 已经包含一个与 obj 透明比较等效的元素，则不执行任何操作。否则，构造一个类型为 value_type 的对象 u，其值为 std::forward<K>(obj)，然后将 u 插入到 *this 中。如果 equal_range(u) != hash_function()(obj) || contains(u) 为 true，则行为未定义。value_type 必须可就地构造到来自 std::forward<K>(obj) 的 unordered_set 中。仅当 Hash::is_transparent 和 KeyEqual::is_transparent 有效且各自表示一种类型时，此重载才参与重载解析。这假设这样的 Hash 可以使用 K 和 Key 类型调用，并且 KeyEqual 是透明的，这共同允许在不构造 Key 实例的情况下调用此函数。

10) 如果 *this 已经包含一个与 obj 透明比较等效的元素，则不执行任何操作。

否则，构造一个类型为 value_type 的对象 u，其值为 std::forward<K>(obj)，然后将 u 插入到 *this 中。模板:hint 用作非强制性建议，指示搜索应从何处开始。如果 equal_range(u) != hash_function()(obj) || contains(u) 为 true，则行为未定义。value_type 必须可就地构造到来自 std::forward<K>(obj) 的 unordered_set 中。仅当此重载参与重载解析时

std::is_convertible_v<K&&, const_iterator> 和 std::is_convertible_v<K&&, iterator> 均为 false，并且
Hash::is_transparent 和 KeyEqual::is_transparent 有效且各自表示一种类型。这假设这样的 Hash 可以使用 K 和 Key 类型调用，并且 KeyEqual 是透明的，

这共同允许在不构造 Key 实例的情况下调用此函数。

如果在操作之后，新元素数量大于旧元素数量 max_load_factor() * bucket_count()，则会发生重哈希。
如果发生重哈希（由于插入），则所有迭代器都将失效。否则（不重哈希），迭代器不会失效。如果插入成功，则在节点句柄中持有时获得的元素的指针和引用将失效，并且在该元素被提取之前获得的指针和引用将变为有效。(自 C++17 起)

[编辑] 参数

hint	-	迭代器，用作关于内容插入位置的建议
value	-	要插入的元素值
first, last	-	定义要插入元素的源范围的迭代器对
ilist	-	要从中插入值的初始化列表
nh	-	兼容的节点句柄
obj	-	任何可以与键透明比较的类型的值
类型要求
- `InputIt` 必须满足 LegacyInputIterator 的要求。

[编辑] 返回值

1,2) 一个由指向插入元素的迭代器（或阻止插入的元素）和 bool 值组成的对，当且仅当发生插入时，该值设置为 true。

3,4) 指向插入元素的迭代器，或指向阻止插入的元素。

5,6) （无）

7) insert_return_type 类型的对象，其成员初始化如下

如果 nh 为空，则 inserted 为 false，position 为 end()，并且 node 为空。
否则，如果发生插入，则 inserted 为 true，position 指向插入的元素，并且 node 为空。
如果插入失败，则 inserted 为 false，node 具有 nh 的先前值，并且 position 指向具有与 nh.key() 等效的键的元素。

8) 如果 nh 为空，则为末尾迭代器；如果发生插入，则为指向插入元素的迭代器；如果插入失败，则为指向具有与 nh.key() 等效的键的元素的迭代器。

9) 一个由指向插入元素的迭代器（或阻止插入的元素）和 bool 值组成的对，当且仅当发生插入时，该值设置为 true。

10) 指向插入元素的迭代器，或指向阻止插入的元素。

[编辑] 异常

1-4) 如果任何操作抛出异常，则插入无效。

[编辑] 复杂度

1-4) 平均情况：O(1)，最坏情况 O(size())。

5,6) 平均情况：O(N)，其中 N 是要插入的元素数量。最坏情况：O(N * size() + N)。

7-10) 平均情况：O(1)，最坏情况 O(size())。

[编辑] 注意

提示插入 (3,4) 不返回布尔值，以便与顺序容器（例如 std::vector::insert）上的位置插入签名兼容。这使得创建通用插入器（例如 std::inserter）成为可能。检查提示插入是否成功的一种方法是在之前和之后比较 size()。

特性测试宏	值	Std	特性
`__cpp_lib_associative_heterogeneous_insertion`	`202311L`	(C++26)	用于有序和无序关联容器中剩余成员函数的异构重载。(9,10)

[编辑] 示例

运行此代码

#include <array>
#include <iostream>
#include <unordered_set>
 
std::ostream& operator<<(std::ostream& os, std::unordered_set<int> const& s)
{
    for (os << '[' << s.size() << "] { "; int i : s)
        os << i << ' ';
    return os << "}\n";
}
 
int main ()
{
    std::unordered_set<int> nums{2, 3, 4};
 
    std::cout << "1) Initially: " << nums << std::boolalpha;
    auto p = nums.insert(1); // insert element, overload (1)
    std::cout << "2) '1' was inserted: " << p.second << '\n';
    std::cout << "3) After insertion: " << nums;
 
    nums.insert(p.first, 0); // insert with hint, overload (3)
    std::cout << "4) After insertion: " << nums;
 
    std::array<int, 4> a = {10, 11, 12, 13};
    nums.insert(a.begin(), a.end()); // insert range, overload (5)
    std::cout << "5) After insertion: " << nums;
 
    nums.insert({20, 21, 22, 23}); // insert initializer_list, (6)
    std::cout << "6) After insertion: " << nums;
 
    std::unordered_set<int> other_nums = {42, 43};
    auto node = other_nums.extract(other_nums.find(42));
    nums.insert(std::move(node)); // insert node, overload (7)
    std::cout << "7) After insertion: " << nums;
 
    node = other_nums.extract(other_nums.find(43));
    nums.insert(nums.begin(), std::move(node)); // insert node with hint, (8)
    std::cout << "8) After insertion: " << nums;
}

可能的输出

1) Initially: [3] { 4 3 2 }
2) '1' was inserted: true
3) After insertion: [4] { 1 2 3 4 }
4) After insertion: [5] { 0 1 2 3 4 }
5) After insertion: [9] { 13 12 11 10 4 3 2 1 0 }
6) After insertion: [13] { 23 22 13 12 11 10 21 4 20 3 2 1 0 }
7) After insertion: [14] { 42 23 22 13 12 11 10 21 4 20 3 2 1 0 }
8) After insertion: [15] { 43 42 23 22 13 12 11 10 21 4 20 3 2 1 0 }

[编辑] 参见

emplace	就地构造元素 (公共成员函数) [编辑]
emplace_hint	使用提示就地构造元素 (公共成员函数) [编辑]
inserter	创建从参数推断类型的 std::insert_iterator (函数模板) [编辑]

编译器支持
独立和宿主
语言
标准库
标准库头文件
具名要求
特性测试宏 (C++20)
语言支持库
概念库 (C++20)
诊断库
内存管理库
元编程库 (C++11)
通用工具库
容器库
迭代器库
范围库 (C++20)
算法库
字符串库
文本处理库
数值库
日期和时间库
输入/输出库
文件系统库 (C++17)
并发支持库 (C++11)
执行控制库 (C++26)
技术规范
符号索引
外部库

序列
array (C++11)
vector
vector<bool>
inplace_vector (C++26)
hive (C++26)
deque
forward_list (C++11)
list
关联
set
multiset
map
multimap
无序关联
unordered_set (C++11)
unordered_multiset (C++11)
unordered_map (C++11)
unordered_multimap (C++11)
适配器
stack
queue
priority_queue
flat_set (C++23)
flat_multiset (C++23)
flat_map (C++23)
flat_multimap (C++23)
视图
span (C++20)
mdspan (C++23)
表格
迭代器失效
成员函数表
非成员函数表

cppreference.cn

命名空间

变体

视图

操作