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

 

C++

编译器支持

自由（freestanding）与宿主（hosted）

语言

标准库

标准库头文件

具名要求

特性测试宏 (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)

表格

迭代器失效

成员函数表格

非成员函数表格

 

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	-	用作初始化底层值容器的源容器
其他	-	另一个 flat_map，用作初始化底层容器元素的源
alloc	-	用于底层容器所有内存分配的分配器
comp	-	一个用于所有键比较的函数对象
first, last	-	定义要复制的元素的源 范围 的迭代器对
init	-	初始化列表，用于初始化底层容器的元素
rg	-	容器兼容范围（即，其元素可转换为 value_type 的 input_range），用作初始化底层容器的源
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=

向容器适配器赋值 (public member function)