命名空间
变体
操作

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

来自 cppreference.cn
< cpp‎ | container‎ | flat map

[编辑模板]
 
C++
 
容器库
 
std::flat_map
成员类型
成员函数
非成员函数
辅助类
标签
推导指引
 
flat_map()
    : flat_map(key_compare()) { }
 (1) (since C++23)
template< class Allocator >
flat_map( const flat_map&, const Allocator& alloc );
 (2) (since C++23)
template< class Allocator >
flat_map( flat_map&&, const Allocator& alloc );
 (3) (since C++23)
flat_map( key_container_type key_cont, mapped_container_type mapped_cont,
          const key_compare& comp = key_compare() );
 (4) (since C++23)
template< class Allocator >

flat_map( const key_container_type& key_cont,
          const mapped_container_type& mapped_cont,

          const Allocator& alloc );
 (5) (since 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) (since 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) (since 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) (since 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) (since C++23)
explicit flat_map( const key_compare& comp )
    : c(), compare(comp) { }
 (10) (since C++23)
template< class Allocator >
flat_map( const key_compare& comp, const Allocator& alloc );
 (11) (since C++23)
template< class Allocator >
explicit flat_map( const Allocator& alloc );
 (12) (since C++23)
template< class InputIter >

flat_map( InputIter first, InputIter last,
          const key_compare& comp = key_compare() )

    : c(), compare(comp);
 (13) (since C++23)
template< class InputIter, class Allocator >

flat_map( InputIter first, InputIter last,

          const key_compare& comp, const Allocator& alloc );
 (14) (since C++23)
template< class InputIter, class Allocator >
flat_map( InputIter first, InputIter last, const Allocator& alloc );
 (15) (since 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) (since 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) (since C++23)
template< container-compatible-range<value_type> R, class Allocator >
flat_map( std::from_range_t, R&& rg, const Allocator& alloc );
 (18) (since 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) (since 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) (since 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) (since C++23)
template< class InputIter, class Allocator >

flat_map( std::sorted_unique_t s, InputIter first, InputIter last,

          const Allocator& alloc );
 (22) (since C++23)
flat_map( std::initializer_list<value_type> init,

          const key_compare& comp = key_compare() )

    : flat_map(init.begin(), init.end(), comp) { }
 (23) (since C++23)
template< class Allocator >

flat_map( std::initializer_list<value_type> init, const key_compare& comp,

          const Allocator& alloc );
 (24) (since C++23)
template< class Allocator >
flat_map( std::initializer_list<value_type> init, const Allocator& alloc );
 (25) (since 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) (since 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) (since C++23)
template< class Allocator >

flat_map( std::sorted_unique_t s, std::initializer_list<value_type> init,

          const Allocator& alloc );
 (28) (since C++23)

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

1) 默认构造函数。构造一个空的容器适配器。
2) 复制构造函数。使用 c 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) 作为委托构造函数。然后，如同通过 insert_range(std::forward<R>(rg)); 一样，使用 rg 的内容初始化 c 。
17) 与 (16) 相同，使用它作为委托构造函数。
18,19) 与 (16) 相同。请参阅下面的分配器使用说明。
20) 如同通过 insert(first, last) 一样，使用范围 [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 是通过 uses-allocator 构造构建的。仅当 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.reqmts]/67 中的一般性声明做出此保证，并且正在通过 LWG issue 2321 考虑更直接的保证。

[编辑] 示例

本节尚不完整
原因：没有示例

[编辑] 参见

 为容器适配器赋值
(公共成员函数) [编辑]

Retrieved from "https://cppreference.cn/mwiki/index.php?title=cpp/container/flat_map/flat_map&oldid=171863"