std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>::flat_map

 

C++

编译器支持

独立和托管

语言

标准库

标准库头文件

命名要求

功能测试宏 (C++20)

语言支持库

概念库 (C++20)

元编程库 (C++11)

诊断库

通用实用程序库

字符串库

容器库

迭代器库

范围库 (C++20)

算法库

数值库

本地化库

输入/输出库

文件系统库 (C++17)

正则表达式库 (C++11)

并发支持库 (C++11)

执行支持库 (C++26)

技术规范

符号索引

外部库

 

容器库

序列

数组 (C++11)

向量

向量<bool>

就地向量 (C++26)

双端队列

前向链表 (C++11)

列表

关联式

集合

多重集合

映射

多重映射

无序关联式

无序集合 (C++11)

无序多重集合 (C++11)

无序映射 (C++11)

无序多重映射 (C++11)

适配器

堆栈

队列

优先队列

扁平集合 (C++23)

扁平多重集合 (C++23)

扁平映射 (C++23)

扁平多重映射 (C++23)

视图

跨度 (C++20)

mdspan (C++23)

表格

迭代器失效

成员函数表

非成员函数表

 

std::flat_map

成员类型

成员函数

flat_map::flat_map flat_map::operator= 元素访问 flat_map::at flat_map::operator[] 迭代器 flat_map::beginflat_map::cbegin flat_map::endflat_map::cend flat_map::rbeginflat_map::crbegin flat_map::rendflat_map::crend 查找 flat_map::count flat_map::find flat_map::contains flat_map::equal_range    flat_map::lower_bound flat_map::upper_bound 容量 flat_map::size flat_map::max_size flat_map::empty 修改器 flat_map::clear flat_map::erase flat_map::swap flat_map::emplace flat_map::extract flat_map::replace flat_map::insert flat_map::insert_range flat_map::insert_or_assign flat_map::emplace_hint flat_map::try_emplace 观察者 flat_map::key_comp flat_map::keys flat_map::value_comp flat_map::values

非成员函数

operator==operator<=>         swap(std::flat_map) erase_if(std::flat_map)

辅助类

uses_allocator<std::flat_map>

标签

sorted_unique       sorted_unique_t

推导指南

 

flat_map()     : flat_map(key_compare()) { }	(1)	(自 C++23 起)
template< class Allocator > flat_map( const flat_map&, const Allocator& alloc );	(2)	(自 C++23 起)
template< class Allocator > flat_map( flat_map&&, const Allocator& alloc );	(3)	(自 C++23 起)
flat_map( key_container_type key_cont, mapped_container_type mapped_cont,           const key_compare& comp = key_compare() );	(4)	(自 C++23 起)
template< class Allocator > flat_map( const key_container_type& key_cont,           const mapped_container_type& mapped_cont,           const Allocator& alloc );	(5)	(自 C++23 起)
template< class Allocator > flat_map( const key_container_type& key_cont,           const mapped_container_type& mapped_cont,           const key_compare& comp, const Allocator& alloc );	(6)	(自 C++23 起)
flat_map( std::sorted_unique_t, key_container_type key_cont,           mapped_container_type mapped_cont,           const key_compare& comp = key_compare() );	(7)	(自 C++23 起)
template< class Allocator > flat_map( std::sorted_unique_t, const key_container_type& key_cont,           const mapped_container_type& mapped_cont, const Allocator& alloc );	(8)	(自 C++23 起)
template< class Allocator > flat_map( std::sorted_unique_t, const key_container_type& key_cont,           const mapped_container_type& mapped_cont,           const key_compare& comp, const Allocator& alloc );	(9)	(自 C++23 起)
explicit flat_map( const key_compare& comp )     : c(), compare(comp) { }	(10)	(自 C++23 起)
template< class Allocator > flat_map( const key_compare& comp, const Allocator& alloc );	(11)	(自 C++23 起)
template< class Allocator > explicit flat_map( const Allocator& alloc );	(12)	(自 C++23 起)
template< class InputIter > flat_map( InputIter first, InputIter last,           const key_compare& comp = key_compare() )     : c(), compare(comp);	(13)	(自 C++23 起)
template< class InputIter, class Allocator > flat_map( InputIter first, InputIter last,           const key_compare& comp, const Allocator& alloc );	(14)	(自 C++23 起)
template< class InputIter, class Allocator > flat_map( InputIter first, InputIter last, const Allocator& alloc );	(15)	(自 C++23 起)
template< container-compatible-range<value_type> R > flat_map( std::from_range_t, R&& rg, const key_compare& comp )     : flat_map(comp);	(16)	(自 C++23 起)
template< container-compatible-range<value_type> R > flat_map( std::from_range_t fr, R&& rg )     : flat_map(fr, std::forward<R>(rg), key_compare()) { }	(17)	(自 C++23 起)
template< container-compatible-range<value_type> R, class Allocator > flat_map( std::from_range_t, R&& rg, const Allocator& alloc );	(18)	(自 C++23 起)
template< container-compatible-range<value_type> R, class Allocator > flat_map( std::from_range_t, R&& rg, const key_compare& comp,           const Allocator& alloc );	(19)	(自 C++23 起)
template< class InputIter > flat_map( std::sorted_unique_t s, InputIter first, InputIter last,           const key_compare& comp = key_compare() )     : c(), compare(comp);	(20)	(自 C++23 起)
template< class InputIter, class Allocator > flat_map( std::sorted_unique_t s, InputIter first, InputIter last,           const key_compare& comp, const Allocator& alloc );	(21)	(自 C++23 起)
template< class InputIter, class Allocator > flat_map( std::sorted_unique_t s, InputIter first, InputIter last,           const Allocator& alloc );	(22)	(自 C++23 起)
flat_map( std::initializer_list<value_type> init,           const key_compare& comp = key_compare() )     : flat_map(init.begin(), init.end(), comp) { }	(23)	(自 C++23 起)
template< class Allocator > flat_map( std::initializer_list<value_type> init, const key_compare& comp,           const Allocator& alloc );	(24)	(自 C++23 起)
template< class Allocator > flat_map( std::initializer_list<value_type> init, const Allocator& alloc );	(25)	(自 C++23 起)
flat_map( std::sorted_unique_t s, std::initializer_list<value_type> init,           const key_compare& comp = key_compare() )     : flat_map(s, init.begin(), init.end(), comp) { }	(26)	(自 C++23 起)
template< class Allocator > flat_map( std::sorted_unique_t s, std::initializer_list<value_type> init,           const key_compare& comp, const Allocator& alloc );	(27)	(自 C++23 起)
template< class Allocator > flat_map( std::sorted_unique_t s, std::initializer_list<value_type> init,           const Allocator& alloc );	(28)	(自 C++23 起)

使用各种数据源构造新的容器适配器，并且可以选择使用用户提供的比较函数对象 comp 和/或分配器 alloc。

1) 默认构造函数。构造一个空的容器适配器。

2) 复制构造函数。使用 other.c 的内容副本构造 c，使用 other.compare 构造 compare。请参见下面的 分配器使用说明。

3) 移动构造函数。使用移动语义，使用 other 的内容构造容器适配器。请参见下面的 分配器使用说明。

4) 首先，使用 std::move(key_cont) 初始化 c.keys，使用 std::move(mapped_cont) 初始化 c.values，使用 comp 初始化 compare。然后，根据 value_comp() 对底层范围 [begin(), end()) 进行排序。最后，像下面这样删除重复元素：
auto zv = views::zip(c.keys, c.values);
auto it = ranges::unique(zv, key_equiv(compare)).begin();
auto dist = distance(zv.begin(), it);
c.keys.erase(c.keys.begin() + dist, c.keys.end());
c.values.erase(c.values.begin() + dist, c.values.end());.

5) 与 (4) 相同，等效于 flat_map(key_cont, mapped_cont);。请参见下面的 分配器使用说明。

6) 与 (4) 相同，等效于 flat_map(key_cont, mapped_cont, comp);。请参见下面的 分配器使用说明。

7) 使用 std::move(key_cont) 初始化 c.keys，使用 std::move(mapped_cont) 初始化 c.values，使用 comp 初始化 compare。

8) 与 (7) 相同，等效于 flat_map(s, key_cont, mapped_cont);。请参见下面的 分配器使用说明。

9) 与 (7) 相同，等效于 flat_map(s, key_cont, mapped_cont, comp);。请参见下面的 分配器使用说明。

10) 构造一个空的容器适配器。

11,12) 构造一个空的容器适配器。请参见下面的 分配器使用说明。

13) 使用范围 [first, last) 的内容构造容器适配器，等效于 insert(first, last);。

14,15) 与 (13) 相同。请参见下面的 分配器使用说明。

16) 使用范围 rg 的内容构造容器适配器。首先，使用 (10) 作为 委托构造函数。然后使用 rg 的内容初始化 c，就好像通过 insert_range(std::forward<R>(rg)); 那样。

17) 与 (16) 相同，使用它作为 委托构造函数。

18,19) 与 (16) 相同。请参见下面的 分配器使用说明。

20) 使用范围 [first, last) 的内容构造底层容器，就好像通过 insert(first, last) 那样。

21,22) 与 (20) 相同。请参见下面的 分配器使用说明。

23) 一个 初始化列表构造函数。使用 init 初始化列表的内容构造底层容器，使用 (13) 作为 委托构造函数。

24,25) 与 (23) 相同。请参见下面的 分配器使用说明。

26) 一个 初始化列表构造函数。使用 init 初始化列表的内容构造底层容器，使用 (20) 作为 委托构造函数。

27,28) 与 (26) 相同。请参见下面的 分配器使用说明。

对于重载 (13-15,20-22) 的说明：如果 [first, last) 不是一个 有效范围，则行为未定义。

对于重载 (4-6,13-19,23-25) 的说明：如果范围中的多个元素具有比较相等的键，则插入哪个元素是未指定的（待处理 LWG2844）。

分配器使用说明

构造函数 (2,3,5,6,8,9,11,12,14,15,17,19,21,22,24,25,27,28) 等效于相应的非分配器构造函数，不同之处在于底层容器 c.keys 和 c.values 是使用 使用分配器构造 的。只有当 std::uses_allocator_v<container_type, Allocator> 为 true 时，这些重载才会参与重载解析。

参数

key_cont	-	用作源来初始化底层键容器的容器
mapped_cont	-	用作源来初始化底层值容器的容器
other	-	另一个用作源来初始化底层容器元素的 flat_map
alloc	-	用于所有底层容器的内存分配的分配器
comp	-	用于所有键比较的函数对象
first, last	-	用于复制元素的范围
init	-	用于初始化底层容器元素的初始化列表
rg	-	一个 容器兼容范围（即，一个 input_range，其元素可转换为 value_type）用作源来初始化底层容器
fr	-	一个 消歧标签，表示包含的成员应使用范围进行构造
s	-	一个 消歧标签，表示输入序列已根据 value_comp() 排序，并且所有元素都是唯一的
类型要求
- InputIt 必须满足 LegacyInputIterator 的要求。
- Compare 必须满足 Compare 的要求。
- Allocator 必须满足 Allocator 的要求。

复杂度

1) 常量。

2) other 大小线性。

3) 与包装容器的相应移动构造函数相同，即 cont 大小线性或常量。

4-6) 如果 cont 根据 value_comp() 排序，则在 \(\scriptsize N\)N 中为线性，否则为 \(\scriptsize \mathcal{O}(N\cdot\log{(N)})\)𝓞(N·log(N))，其中 \(\scriptsize N\)N 是此调用之前 key_cont.size() 的值。

7-9) 与封装容器的相应移动构造函数相同，即 cont 的大小为常数或线性。

10-12) 常数。

13-15) 如果输入范围 [first, last) 根据 value_comp() 排序，则在 \(\scriptsize N\)N 中为线性，否则为 \(\scriptsize \mathcal{O}(N\cdot\log{(N)})\)𝓞(N·log(N))，其中 \(\scriptsize N\)N 是此调用之前 key_cont.size() 的值。

16-19) 如果输入范围 rg 根据 value_comp() 排序，则在 \(\scriptsize N\)N 中为线性，否则为 \(\scriptsize \mathcal{O}(N\cdot\log{(N)})\)𝓞(N·log(N))，其中 \(\scriptsize N\)N 是此调用之前 key_cont.size() 的值。

20-22) [first, last) 的大小线性。

23-25) 如果 init 的元素根据 value_comp() 排序，则在 \(\scriptsize N\)N 中为线性，否则为 \(\scriptsize \mathcal{O}(N\cdot\log{(N)})\)𝓞(N·log(N))，其中 \(\scriptsize N\)N 是此调用之前 key_cont.size() 的值。

26-28) init 的大小线性。

异常

对 Allocator::allocate 的调用可能会抛出异常。

注释

在容器移动构造（重载 (3)）之后，对 other 的引用、指针和迭代器（除末尾迭代器外）保持有效，但指向现在位于 *this 中的元素。当前标准通过 [container.reqmts]/67 中的笼统声明来保证这一点，而更直接的保证正在通过 LWG issue 2321 进行考虑。

另请参阅

operator=

将值赋给容器适配器 (公有成员函数)