std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>::flat_map - cppreference.com

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

来自cppreference.com

[编辑模板]
 
C++
 
容器库
 
std::flat_map
成员类型
成员函数
非成员函数
辅助类
标签
推导指引
 
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。然后对底层范围 [begin(), end()) 按 value_comp() 排序。最后，如同以如下代码擦除重复元素：
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) Same as (23). 参见下文的分配器用法注解。
26) 初始化式列表构造函数。以初始化式列表 init 的内容构造底层容器，使用 (20) 作为委托构造函数。
27,28) Save as (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 - 用作初始化各底层容器的源的容器兼容范围（即各个元素可以转换为 value_type 的 input_range）
fr - 区分标签，指示应当按范围构造所含成员
s - 区分标签，指示输入序列按 value_comp() 有序且其所有元素均唯一
类型要求
-
InputIt 必须满足老式输入迭代器 (LegacyInputIterator) 。
-
Compare 必须满足比较 (Compare) 。
-
Allocator 必须满足分配器 (Allocator) 。

复杂度

1) 常数。
2) 与 other 的大小成线性。
3) 与被包装容器的对应移动构造函数相同，即为常数或与 cont 的大小成线性。
4-6) 如果 cont 按 value_comp() 有序，则与 N 成线性，否则为 𝓞(N·log(N))，其中 N 为此次调用前 key_cont.size() 的值。
7-9) 与被包装容器的对应移动构造函数相同，即为常数或与 cont 的大小成线性。
10-12) 常数。
13-15) 如果输入范围 [first, last) 按 value_comp() 有序，则与 N 成线性，否则为 𝓞(N·log(N))，其中 N 为此次调用前 key_cont.size() 的值。
16-19) 如果输入范围 rg 按 value_comp() 有序，则与 N 成线性，否则为 𝓞(N·log(N))，其中 N 为此次调用前 key_cont.size() 的值。
20-22) 与 [first, last) 的大小成线性。
23-25) 如果 init 的各元素按 value_comp() 有序，则与 N 成线性，否则为 𝓞(N·log(N))，其中 N 为此次调用前 key_cont.size() 的值。
26-28) 与 init 的大小成线性。

异常

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

注解

在容器移动构造（重载 (3)）后，指向 other 的引用及迭代器（除了尾迭代器）保持合法，但将指代现于 *this 中的元素。当前标准由 [container.requirements.general]/12 中的总括陈述作出此保证，而 LWG 问题 2321 正在考虑更严格的保证。

示例

本节未完成
原因：暂无示例

参阅