deduction guides for std::unordered_multimap

C++

Language

Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

Containers library

array (C++11)

vector

deque

forward_list (C++11)

list

set

multiset

map

multimap

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

stack

queue

priority_queue

span (C++20)

std::unordered_multimap

Member functions

unordered_multimap::unordered_multimap

unordered_multimap::~unordered_multimap

unordered_multimap::operator=

unordered_multimap::get_allocator

Iterators

unordered_multimap::beginunordered_multimap::cbegin

unordered_multimap::endunordered_multimap::cend

Capacity

unordered_multimap::erase

unordered_multimap::size

unordered_multimap::max_size

Modifiers

unordered_multimap::clear

unordered_multimap::insert

unordered_multimap::emplace

unordered_multimap::emplace_hint

unordered_multimap::erase

unordered_multimap::swap

unordered_multimap::extract (C++17)

unordered_multimap::merge (C++17)

Lookup

unordered_multimap::count

unordered_multimap::find

unordered_multimap::contains (C++20)

unordered_multimap::equal_range

Bucket interface

unordered_multimap::begin(size_type)unordered_multimap::cbegin(size_type)

unordered_multimap::end(size_type)unordered_multimap::cend(size_type)

unordered_multimap::bucket_count

unordered_multimap::max_bucket_count

unordered_multimap::bucket_size

unordered_multimap::bucket

Hash policy

unordered_multimap::load_factor

unordered_multimap::max_load_factor

unordered_multimap::rehash

unordered_multimap::reserve

Observers

unordered_multimap::hash_function

unordered_multimap::key_eq

Deduction guides(C++17)

Defined in header <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_multimap(InputIt, InputIt, typename /*see below*/::size_type = /*see below*/, Hash = Hash(), Pred = Pred(), Alloc = Alloc()) -> unordered_multimap<iter_key_t<InputIt>, iter_val_t<InputIt>, Hash, Pred, Alloc>;	(1)	(since 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_multimap(std::initializer_list<std::pair<const Key, T>>, typename /*see below*/::size_type = /*see below*/, Hash = Hash(), Pred = Pred(), Alloc = Alloc()) -> unordered_multimap<Key, T, Hash, Pred, Alloc>;	(2)	(since C++17)
template<class InputIt, class Alloc> unordered_multimap(InputIt, InputIt, typename /*see below*/::size_type, Alloc) -> unordered_multimap<iter_key_t<InputIt>, iter_val_t<InputIt>, std::hash<iter_key_t<InputIt>>, std::equal_to<iter_key_t<InputIt>>, Alloc>;	(3)	(since C++17)
template<class InputIt, class Alloc> unordered_multimap(InputIt, InputIt, Alloc) -> unordered_multimap<iter_key_t<InputIt>, iter_val_t<InputIt>, std::hash<iter_key_t<InputIt>>, std::equal_to<iter_key_t<InputIt>>, Alloc>;	(4)	(since C++17)
template<class InputIt, class Hash, class Alloc> unordered_multimap(InputIt, InputIt, typename /*see below*/::size_type, Hash, Alloc) -> unordered_multimap<iter_key_t<InputIt>, iter_val_t<InputIt>, Hash, std::equal_to<iter_key_t<InputIt>>, Alloc>;	(5)	(since C++17)
template<class Key, class T, typename Alloc> unordered_multimap(std::initializer_list<std::pair<const Key, T>>, typename /*see below*/::size_type, Alloc) -> unordered_multimap<Key, T, std::hash<Key>, std::equal_to<Key>, Alloc>;	(6)	(since C++17)
template<class Key, class T, typename Alloc> unordered_multimap(std::initializer_list<std::pair<const Key, T>>, Alloc) -> unordered_multimap<Key, T, std::hash<Key>, std::equal_to<Key>, Alloc>;	(7)	(since C++17)
template<class Key, class T, class Hash, class Alloc> unordered_multimap(std::initializer_list<std::pair<const Key, T>>, typename /*see below*/::size_type, Hash, Alloc) -> unordered_multimap<Key, T, Hash, equal_to<Key>, Allocator>;	(8)	(since C++17)

where the type aliases iter_key_t, iter_val_t, iter_to_alloc_t are defined as if as follows

template<class InputIt> using iter_key_t = std::remove_const_t< typename std::iterator_traits<InputIt>::value_type::first_type>;		(exposition only)
template<class InputIt> using iter_val_t = typename std::iterator_traits<InputIt>::value_type::second_type;		(exposition only)
template<class InputIt> using iter_to_alloc_t = std::pair< std::add_const_t<typename std::iterator_traits<InputIt>::value_type::first_type>, typename std::iterator_traits<InputIt>::value_type::second_type >		(exposition only)

These deduction guide are provided for unordered_multimap to allow deduction from an iterator range (overloads (1,3-5)) and std::initializer_list (overloads (2,6-8)). These overloads only participate in overload resolution if InputIt satisfies InputIterator, Alloc satisfies Allocator, neither Hash nor Pred satisfy Allocator, and Hash is not an integral type.

Note: the extent to which the library determines that a type does not satisfy InputIterator is unspecified, except that as a minimum integral types do not qualify as input iterators. Likewise, the extent to which it determines that a type does not satisfy Allocator is unspecified, except that as a minimum the member type Alloc::value_type must exist and the expression std::declval<Alloc&>().allocate(std::size_t{}) must be well-formed when treated as an unevaluated operand.

The size_type parameter type in these guides in an refers to the size_type member type of the type deduced by the deduction guide.

Example

Run this code

#include <unordered_map>
int main() {
// std::unordered_multimap m1 = {{"foo", 1}, {"bar", 2}}; // Error: braced-init-list has no type
                                                          // cannot deduce pair<const Key, T> from
                                                          // {"foo", 1} or {"bar", 2}
   std::unordered_multimap m1 = std::initializer_list<
                        std::pair<char const* const, int>>({{"foo", 2}, {"bar", 3}}); // guide #2
   std::unordered_multimap m2(m1.begin(), m1.end()); // guide #1
}