std::multimap 的推导指引

出自cppreference.com
< cpp‎ | container‎ | multimap

[編輯模板]
 
C++
 
容器庫
 
std::multimap
成員函數
非成員函數
(C++20 前)(C++20 前)(C++20 前)(C++20 前)(C++20 前)
推導指引(C++17)
 
在標頭 <map> 定義
template< class InputIt,

          class Comp = std::less</*iter-key-t*/<InputIt>>,
          class Alloc = std::allocator</*iter-to-alloc-t*/<InputIt>> >
multimap( InputIt, InputIt, Comp = Comp(), Alloc = Alloc() )

    -> multimap</*iter-key-t*/<InputIt>, /*iter-val-t*/<InputIt>, Comp, Alloc>;
 (1) (C++17 起)
template< class Key,

          class T,
          class Comp = std::less<Key>,
          class Alloc = std::allocator<std::pair<const Key, T>> >
multimap( std::initializer_list<std::pair<Key, T>>, Comp = Comp(), Alloc = Alloc() )

    -> multimap<Key, T, Comp, Alloc>;
 (2) (C++17 起)
template< class InputIt, class Alloc >

multimap( InputIt, InputIt, Alloc )
    -> multimap</*iter-key-t*/<InputIt>, /*iter-val-t*/<InputIt>,

                std::less</*iter-key-t*/<InputIt>>, Alloc>;
 (3) (C++17 起)
template< class Key, class T, class Alloc >

multimap( std::initializer_list<std::pair<Key, T>>, Alloc )

    -> multimap<Key, T, std::less<Key>, Alloc>;
 (4) (C++17 起)
template< ranges::input_range R, class Compare = std::less</*range-key-t*/<R>,

          class Alloc = std::allocator</*range-to-alloc-t*/<R>> >
multimap( std::from_range_t, R&&, Compare = Compare(), Alloc = Alloc() )

    -> multimap</*range-key-t*/<R>, range_mapped_t<R>, Compare, Alloc>;
 (5) (C++23 起)
template< ranges::input_range R, class Alloc >

multimap( std::from_range_t, R&&, Alloc )
    -> multimap</*range-key-t*/<R>, range_mapped_t<R>,

       multimap std::less</*range-key-t*/<R>>, Alloc>;
 (6) (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 InputIt >

using /*iter-to-alloc-t*/ =
    std::pair<std::add_const_t<tuple_element_t<0, /*iter-val-t*/<InputIt>>>,

              std::tuple_element_t<1, /*iter-val-t*/<InputIt>>>;
 (僅用於闡述*)
template< ranges::input_range Range >

using /*range-key-t*/ =

    std::remove_const_t<typename ranges::range_value_t<Range>::first_type>;
 (C++23 起)
(僅用於闡述*)
template< ranges::input_range Range >

using /*range-mapped-t*/ =

    typename ranges::range_value_t<Range>::second_type;
 (C++23 起)
(僅用於闡述*)
template< ranges::input_range Range >

using /*range-to-alloc-t*/ =
    std::pair<std::add_const_t<typename ranges::range_value_t<Range>::first_type>,

              typename ranges::range_value_t<Range>::second_type>;
 (C++23 起)
(僅用於闡述*)
1-4) 為 multimap 提供了這些推導指引，以允許從迭代器範圍（重載 (1,3)）和 std::initializer_list（重載 (2,4)）推導。
5,6) 為 multimap 提供了這些推導指引，以允許從 std::from_range_t 標籤和一個 input_range 推導。

這些重載只有在 InputIt 滿足老式輸入迭代器 (LegacyInputIterator) 、Alloc 滿足分配器 (Allocator) 且 Comp 不滿足分配器 (Allocator) 時才會參與重載決議。

注意：庫確定類型是否滿足老式輸入迭代器 (LegacyInputIterator) 的程度是未指定的，但最低要求是整數類型不具備輸入迭代器的條件。類似地，確定類型是否滿足分配器 (Allocator) 是未指定的，但最低要求是成員類型 Alloc::value_type 必須存在，且表達式 std::declval<Alloc&>().allocate(std::size_t{}) 在作為不求值操作數時必須為良構。

[編輯] 註解

功能特性測試宏 值 標準 功能特性
__cpp_lib_containers_ranges 202202L (C++23) 按範圍構造和插入; 重載 (5,6)

[編輯] 示例

運行此代碼
#include <map>
 
int main()
{
    // std::multimap m1 = {{"foo", 1}, {"bar", 2}};
        // 错误：花括号初始化式列表无类型；
        // 不能从 {"foo", 1} 或 {"bar", 2} 推导 pair<const Key, T>
 
    std::multimap m1 = {std::pair{"foo", 2}, {"bar", 3}}; // 指引 #2
    std::multimap m2(m1.begin(), m1.end()); // 指引 #1
}

[編輯] 缺陷報告

下列更改行為的缺陷報告追溯地應用於以前出版的 C++ 標準。

缺陷報告 應用於 出版時的行為 正確行為
LWG 3025 C++17 初始化式列表的指導 (2,4) 接受 std::pair<const Key, T> 使用 std::pair<Key, T>
取自「https://zh.cppreference.com/mwiki/index.php?title=cpp/container/multimap/deduction_guides&oldid=82282」