std::flat_multimap 的推导指引

来自cppreference.com

[编辑模板]
 
C++
 
容器库
 
std::flat_multimap
成员类型
成员函数
非成员函数
辅助类
标签
推导指引
 
在标头 <flat_map> 定义 
template< class KeyContainer, class MappedContainer,
          class Compare = std::less<typename KeyContainer::value_type> >
flat_multimap( KeyContainer, MappedContainer, Compare = Compare() )
    -> flat_multimap<typename KeyContainer::value_type,
                     typename MappedContainer::value_type,
                     Compare, KeyContainer, MappedContainer>;
(1) (C++23 起) 
template< class KeyContainer, class MappedContainer, class Allocator >
flat_multimap( KeyContainer, MappedContainer, Allocator )
    -> flat_multimap<typename KeyContainer::value_type,
                     typename MappedContainer::value_type,
                     std::less<typename KeyContainer::value_type>,
                     KeyContainer, MappedContainer>;
(2) (C++23 起) 
template< class KeyContainer, class MappedContainer,
          class Compare, class Allocator >
flat_multimap( KeyContainer, MappedContainer, Compare, Allocator )
    -> flat_multimap<typename KeyContainer::value_type,
                     typename MappedContainer::value_type,
                     Compare, KeyContainer, MappedContainer>;
(3) (C++23 起) 
template< class KeyContainer, class MappedContainer,
          class Compare = std::less<typename KeyContainer::value_type> >
flat_multimap( std::sorted_equivalent_t, KeyContainer, MappedContainer,
               Compare = Compare() )
    -> flat_multimap<typename KeyContainer::value_type,
                     typename MappedContainer::value_type,
                     Compare, KeyContainer, MappedContainer>;
(4) (C++23 起) 
template< class KeyContainer, class MappedContainer, class Allocator >
flat_multimap( std::sorted_equivalent_t, KeyContainer, MappedContainer,
               Allocator )
    -> flat_multimap<typename KeyContainer::value_type,
                     typename MappedContainer::value_type,
                     std::less<typename KeyContainer::value_type>,
                     KeyContainer, MappedContainer>;
(5) (C++23 起) 
template< class KeyContainer, class MappedContainer,
          class Compare, class Allocator>
flat_multimap( std::sorted_equivalent_t, KeyContainer, MappedContainer,
               Compare, Allocator )
    -> flat_multimap<typename KeyContainer::value_type,
                     typename MappedContainer::value_type,
                     Compare, KeyContainer, MappedContainer>;
(6) (C++23 起) 
template< class InputIt,
          class Compare = std::less</*iter-key-t*/<InputIt>> >
flat_multimap( InputIt, InputIt, Compare = Compare() )
    -> flat_multimap</*iter-key-t*/<InputIt>,
                     /*iter-mapped-t*/<InputIt>, Compare>;
(7) (C++23 起) 
template< class InputIt,
          class Compare = std::less</*iter-key-t*/<InputIt>> >
flat_multimap( std::sorted_equivalent_t, InputIt, InputIt,
               Compare = Compare() )
    -> flat_multimap</*iter-key-t*/<InputIt>,
                     /*iter-mapped-t*/<InputIt>, Compare>;
(8) (C++23 起) 
template< ranges::input_range R,
          class Compare = std::less</*range-key-t*/<R>>,
          class Allocator = allocator<byte> >
flat_multimap( std::from_range_t, R&&, Compare = Compare(),
               Allocator = Allocator() )
    -> flat_multimap</*range-key-t*/<R>, /*range-mapped-t*/<R>, Compare,
                     std::vector</*range-key-t*/<R>,
                                 /*alloc-rebind*/<Allocator,
                                                  /*range-key-t*/<R>>>,
                     std::vector</*range-mapped-t*/<R>,
                                 /*alloc-rebind*/<Allocator,
                                                  /*range-mapped-t*/<R>>>>;
(9) (C++23 起) 
template< ranges::input_range R, class Allocator >
flat_multimap( std::from_range_t, R&&, Allocator )
    -> flat_multimap</*range-key-t*/<R>, /*range-mapped-t*/<R>,
                     std::less</*range-key-t*/<R>>,
                     std::vector</*range-key-t*/<R>,
                                 /*alloc-rebind*/<Allocator,
                                                  /*range-key-t*/<R>>>,
                     std::vector</*range-mapped-t*/<R>,
                                 /*alloc-rebind*/<Allocator,
                                                  /*range-mapped-t*/<R>>>>;
(10) (C++23 起) 
template< class Key, class T, class Compare = std::less<Key> >
flat_multimap( std::initializer_list<pair<Key, T>>, Compare = Compare() )
    -> flat_multimap<Key, T, Compare>;
(11) (C++23 起) 
template< class Key, class T, class Compare = std::less<Key> >
flat_multimap( std::sorted_equivalent_t, std::initializer_list<pair<Key, T>>,
               Compare = Compare() )
    -> flat_multimap<Key, T, Compare>;
(12) (C++23 起)
仅用于阐释的辅助类型别名
 
template< class InputIt >
using /*iter-val-t*/ =
    typename std::iterator_traits<InputIt>::value_type;
(仅用于阐述*) 
template< class InputIt >
using /*iter-key-t*/ =
    std::remove_const_t< std::tuple_element_t<0, /*iter-val-t*/<InputIt>>>;
(仅用于阐述*) 
template< class InputIt >
using /*iter-mapped-t*/ =
    std::tuple_element_t<1, /*iter-val-t*/<InputIt>>;
(仅用于阐述*) 
template< class Allocator, class T >
using /*alloc-rebind*/ = 
    typename std::allocator_traits<Allocator>::template rebind_alloc<T>;
(仅用于阐述*) 
template< ranges::input_range Range >
using /*range-key-t*/ =
    std::remove_const_t<typename ranges::range_value_t<Range>::first_type>;
(仅用于阐述*) 
template< ranges::input_range Range >
using /*range-mapped-t*/ =
    typename ranges::range_value_t<Range>::second_type;
(仅用于阐述*)

为 提供这些推导指引以从下列各项推导：

1) 一个键容器，一个被映射容器和一个比较器。
2) 一个键容器，一个被映射容器和一个分配器。
3) 一个键容器，一个被映射容器，一个比较器和一个分配器。
4) std::sorted_equivalent_t 标签，一个键容器，一个被映射容器和一个比较器。
5) std::sorted_equivalent_t 标签，一个键容器，一个被映射容器和一个分配器。
6) std::sorted_equivalent_t 标签，一个键容器，一个被映射容器，一个比较器和一个分配器。
7) 一个迭代器范围和一个比较器。
8) std::sorted_equivalent_t 标签，一个迭代器范围和一个比较器。
9) std::from_range_t 标签，一个 input_range 范围，一个比较器和一个分配器。
10) std::from_range_t 标签，一个 input_range 范围和一个分配器。
11) std::initializer_list 和一个比较器。
12) std::sorted_equivalent_t 标签，std::initializer_list 和一个比较器。

这些重载只有在 InputIt 满足老式输入迭代器 (LegacyInputIterator) ，Alloc 满足分配器 (Allocator) ，并且 Comp 不满足分配器 (Allocator) 时才会参与重载决议.

注意：库确定类型是否满足老式输入迭代器 (LegacyInputIterator) 的程度是未指定的，但最低要求是整数类型不具备输入迭代器的条件。类似地，确定类型是否满足分配器 (Allocator) 是未指定的，但最低要求是成员类型 Alloc::value_type 必须存在，且表达式 std::declval<Alloc&>().allocate(std::size_t{}) 在作为不求值操作数时必须为良构。

示例

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