Spec-Zone.ru › C++

руководства по выводу типов для std::unordered_map

Определены в заголовке <unordered_map> 
template< class InputIt,
          class Hash = std::hash</*iter-key-t*/<InputIt>>,
          class Pred = std::equal_to</*iter-key-t*/<InputIt>>,
          class Alloc = std::allocator</*iter-to-alloc-t*/<InputIt>> >
unordered_map( InputIt, InputIt,
               typename /* see below */::size_type = /* see below */,
               Hash = Hash(), Pred = Pred(), Alloc = Alloc() )
    -> unordered_map</*iter-key-t*/<InputIt>, /*iter-val-t*/<InputIt>,
                     Hash, Pred, Alloc>;
(1) (начиная с C++17) 
template< class Key, class T, class Hash = std::hash<Key>,
          class Pred = std::equal_to<Key>,
          class Alloc = std::allocator<std::pair<const Key, T>> >
unordered_map( std::initializer_list<std::pair<Key, T>>,
               typename /* see below */::size_type = /* see below */,
               Hash = Hash(), Pred = Pred(), Alloc = Alloc() )
    -> unordered_map<Key, T, Hash, Pred, Alloc>;
(2) (начиная с C++17) 
template< class InputIt, class Alloc >
unordered_map( InputIt, InputIt, typename /* see below */::size_type, Alloc )
    -> unordered_map</*iter-key-t*/<InputIt>, /*iter-val-t*/<InputIt>,
                     std::hash</*iter-key-t*/<InputIt>>,
                     std::equal_to</*iter-key-t*/<InputIt>>, Alloc>;
(3) (начиная с C++17) 
template< class InputIt, class Alloc >
unordered_map( InputIt, InputIt, Alloc )
    -> unordered_map</*iter-key-t*/<InputIt>, /*iter-val-t*/<InputIt>,
                     std::hash</*iter-key-t*/<InputIt>>,
                     std::equal_to</*iter-key-t*/<InputIt>>, Alloc>;
(4) (начиная с C++17) 
template< class InputIt, class Hash, class Alloc >
unordered_map( InputIt, InputIt, typename /* see below */::size_type, Hash,
               Alloc )
    -> unordered_map</*iter-key-t*/<InputIt>, /*iter-val-t*/<InputIt>, Hash,
                     std::equal_to</*iter-key-t*/<InputIt>>, Alloc>;
(5) (начиная с C++17) 
template< class Key, class T, typename Alloc >
unordered_map( std::initializer_list<std::pair<Key, T>>,
               typename /* see below */::size_type, Alloc )
    -> unordered_map<Key, T, std::hash<Key>, std::equal_to<Key>, Alloc>;
(6) (начиная с C++17) 
template< class Key, class T, typename Alloc >
unordered_map( std::initializer_list<std::pair<Key, T>>, Alloc )
    -> unordered_map<Key, T, std::hash<Key>, std::equal_to<Key>, Alloc>;
(7) (начиная с C++17) 
template< class Key, class T, class Hash, class Alloc >
unordered_map( std::initializer_list<std::pair<Key, T>>,
               typename /* see below */::size_type, Hash, Alloc )
    -> unordered_map<Key, T, Hash, std::equal_to<Key>, Alloc>;
(8) (начиная с C++17) 
template< ranges::input_range R,
          class Hash = std::hash</*range-key-t*/<R>>,
          class Pred = std::equal_to</*range-key-t*/<R>>,
          class Alloc = std::allocator</*range-to-alloc-t*/<R>> >
unordered_map( std::from_range_t, R&&,
               typename /* see below */::size_type = /* see below */,
               Hash = Hash(), Pred = Pred(), Alloc = Alloc() )
    -> unordered_map</*range-key-t*/<R>, /*range-mapped-t*/<R>,
                     Hash, Pred, Alloc>;
(9) (начиная с C++23) 
template< ranges::input_range R, class Alloc >
unordered_map( std::from_range_t, R&&,
               typename /* see below */::size_type, Alloc )
    -> unordered_map</*range-key-t*/<R>, /*range-mapped-t*/<R>,
                     std::hash</*range-key-t*/<R>>,
                     std::equal_to</*range-key-t*/<R>>, Alloc>;
(10) (начиная с C++23) 
template< ranges::input_range R, class Alloc >
unordered_map( std::from_range_t, R&&, Alloc )
    -> unordered_map</*range-key-t*/<R>, /*range-mapped-t*/<R>,
                     std::hash</*range-key-t*/<R>>,
                     std::equal_to</*range-key-t*/<R>>, Alloc>;
(11) (начиная с C++23) 
template< ranges::input_range R, class Hash, class Alloc >
unordered_map( std::from_range_t, R&&, typename /* see below */::size_type,
               Hash, Alloc )
    -> unordered_map</*range-key-t*/<R>, /*range-mapped-t*/<R>, Hash,
                     std::equal_to</*range-key-t*/<R>>, Alloc>;
(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 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-8) Эти руководства по выводу типов предоставлены для unordered_map, чтобы обеспечить вывод типов по диапазону итераторов (перегрузки (1,3-5)) и std::initializer_list (перегрузки (2,6-8)).
9-12) Эти руководства по выводу типов предоставлены для unordered_map, чтобы обеспечить вывод типов по тегу std::from_range_t и input_range.

Эти перегрузки участвуют в разрешении перегрузки только в том случае, если InputIt удовлетворяет требованиям LegacyInputIterator, Alloc удовлетворяет требованиям Allocator, ни Hash, ни Pred не удовлетворяют требованиям Allocator, а Hash не является целочисленным типом.

Примечание: степень, в которой библиотека определяет, что тип не удовлетворяет требованиям LegacyInputIterator, не указана, за исключением того, что как минимум целочисленные типы не считаются входными итераторами. Аналогично, степень, в которой она определяет, что тип не удовлетворяет требованиям Allocator, не указана, за исключением того, что как минимум должен существовать тип-член Alloc::value_type, а выражение std::declval<Alloc&>().allocate(std::size_t{}) должно быть корректно сформировано при рассмотрении в качестве невычисляемого операнда.

Тип параметра size_type в этих руководствах относится к типу-члену size_type типа, выведенного руководством по выводу типов.

Примечания

Макрос проверки поддержки функции Значение Стандарт Функция
__cpp_lib_containers_ranges 202202L (C++23) Конструирование и вставка с поддержкой диапазонов; перегрузки (9-12)

Пример

#include <unordered_map>

int main()
{
    // std::unordered_map m1 = {{"foo", 1}, {"bar", 2}};
        // Error: braced-init-list has no type: cannot
        // deduce pair<Key, T> from {"foo", 1} or {"bar", 2}

    std::unordered_map m1 = {std::pair{"foo", 2}, {"bar", 3}}; // guide #2
    std::unordered_map m2(m1.begin(), m1.end()); // guide #1
}

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были применены ретроактивно к ранее опубликованным стандартам C++.

DR Применяется к Опубликованное поведение Корректное поведение
LWG 3025 C++17 руководства по списку инициализации (2) и (6-8) принимают std::pair<constKey,T> использовать std::pair<Key,T>

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/container/unordered_map/deduction_guides

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API