std::unordered_map<Key,T,Hash,KeyEqual,Allocator>::unordered_map
(1) | ||
unordered_map() : unordered_map(size_type(/* implementation-defined */)) {} |
(since C++11) (until C++20) |
|
unordered_map(); |
(since C++20) | |
explicit unordered_map( size_type bucket_count, const Hash& hash = Hash(), |
(2) | (since C++11) |
unordered_map( size_type bucket_count, const Allocator& alloc ) |
(3) | (since C++14) |
unordered_map( size_type bucket_count, const Hash& hash, |
(4) | (since C++14) |
explicit unordered_map( const Allocator& alloc ); |
(5) | (since C++11) |
template< class InputIt > unordered_map( InputIt first, InputIt last, |
(6) | (since C++11) |
template< class InputIt > unordered_map( InputIt first, InputIt last, |
(7) | (since C++14) |
template< class InputIt > unordered_map( InputIt first, InputIt last, |
(8) | (since C++14) |
unordered_map( const unordered_map& other ); |
(9) | (since C++11) |
unordered_map( const unordered_map& other, const Allocator& alloc ); |
(10) | (since C++11) |
unordered_map( unordered_map&& other ); |
(11) | (since C++11) |
unordered_map( unordered_map&& other, const Allocator& alloc ); |
(12) | (since C++11) |
unordered_map( std::initializer_list<value_type> init, size_type bucket_count = /* implementation-defined */, |
(13) | (since C++11) |
unordered_map( std::initializer_list<value_type> init, size_type bucket_count, |
(14) | (since C++14) |
unordered_map( std::initializer_list<value_type> init, size_type bucket_count, |
(15) | (since C++14) |
template< container-compatible-range<value_type> R > unordered_map( std::from_range_t, R&& rg, |
(16) | (since C++23) |
template< container-compatible-range<value_type> R > unordered_map( std::from_range_t, R&& rg, |
(17) | (since C++23) |
template< container-compatible-range<value_type> R > unordered_map( std::from_range_t, R&& rg, |
(18) | (since C++23) |
Constructs new container from a variety of data sources. Optionally uses user supplied bucket_count as a minimal number of buckets to create, hash as the hash function, equal as the function to compare keys and alloc as the allocator.
[
first,
last)
. Sets max_load_factor() to 1.0. If multiple elements in the range have keys that compare equivalent, it is unspecified which element is inserted (pending LWG2844).
The template parameter |
(since C++23) |
The template parameter |
(since C++23) |
Contents |
[edit] Parameters
alloc | - | allocator to use for all memory allocations of this container |
bucket_count | - | minimal number of buckets to use on initialization. If it is not specified, implementation-defined default value is used |
hash | - | hash function to use |
equal | - | comparison function to use for all key comparisons of this container |
first, last | - | the range [ first, last) to copy the elements from
|
rg | - | a container compatible range, that is, an input_range whose elements are convertible to value_type
|
other | - | another container to be used as source to initialize the elements of the container with |
init | - | initializer list to initialize the elements of the container with |
Type requirements | ||
-InputIt must meet the requirements of LegacyInputIterator.
|
[edit] Complexity
[edit] Exceptions
Calls to Allocator::allocate
may throw.
[edit] Notes
other
remain valid, but refer to elements that are now in *this. The current standard makes this guarantee via the blanket statement in [container.reqmts]/67, and a more direct guarantee is under consideration via LWG issue 2321.
Although not formally required until C++23, some implementations have already put the template parameter Allocator
into non-deduced contexts in earlier modes.
Feature-test macro | Value | Std | Feature |
---|---|---|---|
__cpp_lib_containers_ranges |
202202L | (C++23) | Ranges-aware construction and insertion; overloads (16-18) |
[edit] Example
#include <bitset> #include <string> #include <unordered_map> #include <utility> #include <vector> struct Key { std::string first; std::string second; }; struct KeyHash { std::size_t operator()(const Key& k) const { return std::hash<std::string>()(k.first) ^ (std::hash<std::string>()(k.second) << 1); } }; struct KeyEqual { bool operator()(const Key& lhs, const Key& rhs) const { return lhs.first == rhs.first && lhs.second == rhs.second; } }; struct Foo { Foo(int val_) : val(val_) {} int val; bool operator==(const Foo &rhs) const { return val == rhs.val; } }; template<> struct std::hash<Foo> { std::size_t operator()(const Foo &f) const { return std::hash<int>{}(f.val); } }; int main() { // default constructor: empty map std::unordered_map<std::string, std::string> m1; // list constructor std::unordered_map<int, std::string> m2 = { {1, "foo"}, {3, "bar"}, {2, "baz"} }; // copy constructor std::unordered_map<int, std::string> m3 = m2; // move constructor std::unordered_map<int, std::string> m4 = std::move(m2); // range constructor std::vector<std::pair<std::bitset<8>, int>> v = {{0x12, 1}, {0x01,-1}}; std::unordered_map<std::bitset<8>, double> m5(v.begin(), v.end()); // Option 1 for a constructor with a custom Key type // Define the KeyHash and KeyEqual structs and use them in the template std::unordered_map<Key, std::string, KeyHash, KeyEqual> m6 = { {{"John", "Doe"}, "example"}, {{"Mary", "Sue"}, "another"} }; // Option 2 for a constructor with a custom Key type. // Define a const == operator for the class/struct and specialize std::hash // structure in the std namespace std::unordered_map<Foo, std::string> m7 = { {Foo(1), "One"}, {2, "Two"}, {3, "Three"} }; // Option 3: Use lambdas // Note that the initial bucket count has to be passed to the constructor struct Goo { int val; }; auto hash = [](const Goo &g){ return std::hash<int>{}(g.val); }; auto comp = [](const Goo &l, const Goo &r){ return l.val == r.val; }; std::unordered_map<Goo, double, decltype(hash), decltype(comp)> m8(10, hash, comp); }
[edit] Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR | Applied to | Behavior as published | Correct behavior |
---|---|---|---|
LWG 2193 | C++11 | the default constructor (1) was explicit | made non-explicit |
[edit] See also
assigns values to the container (public member function) |