##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::unordered_map::unordered_map

From cppreference.com
< cpp‎ | container‎ | unordered map

[edit template]

explicit unordered_map( size_type bucket_count = /*implementation-defined*/, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual(), const Allocator& alloc = Allocator() ); unordered_map( size_type bucket_count, const Allocator& alloc = Allocator() ); unordered_map( size_type bucket_count, const Hash& hash, const Allocator& alloc = Allocator() ); | (1) | (since C++11) (since C++14)
explicit unordered_map( const Allocator& alloc ); | (1) | (since C++11)
template< class InputIt > unordered_map( InputIt first, InputIt last, size_type bucket_count = /*implementation-defined*/, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual(), const Allocator& alloc = Allocator() ); template< class InputIt > unordered_map( InputIt first, InputIt last, size_type bucket_count, const Allocator& alloc = Allocator() ); template< class InputIt > unordered_map( InputIt first, InputIt last, size_type bucket_count, const Hash& hash, const Allocator& alloc = Allocator() ); | (2) | (since C++11) (since C++14)
unordered_map( const unordered_map& other ); | (3) | (since C++11)
unordered_map( const unordered_map& other, const Allocator& alloc ); | (3) | (since C++11)
unordered_map( unordered_map&& other ); | (4) | (since C++11)
unordered_map( unordered_map&& other, const Allocator& alloc ); | (4) | (since C++11)
unordered_map( std::initializer_list<value_type> init, size_type bucket_count = /*implementation-defined*/, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual(), const Allocator& alloc = Allocator() ); unordered_map( std::initializer_list<value_type> init, size_type bucket_count, const Allocator& alloc = Allocator() ); unordered_map( std::initializer_list<value_type> init, size_type bucket_count, const Hash& hash, const Allocator& alloc = Allocator() ); | (5) | (since C++11) (since C++14)

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.

1) default constructor. Constructs empty container.

2) constructs the container with the contents of the range `[first, last)`.

3) copy constructor. Constructs the container with the copy of the contents of `other`. If `alloc` is not provided, allocator is obtained by calling std::allocator_traits<allocator_type>::select_on_copy_construction(other).

4) move constructor. Constructs the container with the contents of `other` using move semantics. If `alloc` is not provided, allocator is obtained by move-construction from the allocator belonging to `other`.

5) constructs the container with the contents of the initializer list `init`.

### [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 to copy the elements from
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 `InputIterator`.

### [edit] Complexity

| This section is incomplete

1) constant

2) linear in distance between `first` and `last`

3) linear in size of `other`

4) constant. If `alloc` is given and alloc != other.get_allocator(), then linear.

5) linear in size of `init`

### [edit] Example

Run this code

    #include <unordered_map>
    #include <vector>
    #include <bitset>
    #include <string>
    #include <utility>

    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;
     }
    };

    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());

        // constructor for a custom type
        std::unordered_map<Key, std::string, KeyHash, KeyEqual> m6 = {
                { {"John", "Doe"}, "example"},
                { {"Mary", "Sue"}, "another"}
        };
    }

### [edit] See also

operator= | assigns values to the container (public member function) [edit]

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/container/unordered_map/unordered_map&oldid=50708"
Category:

- Todo without reason