public member function
<unordered_map>

std::unordered_map::unordered_map

empty (1)
explicit unordered_map ( size_type n = /* see below */,
                         const hasher& hf = hasher(),
                         const key_equal& eql = key_equal(),
                         const allocator_type& alloc = allocator_type() );
explicit unordered_map ( const allocator_type& alloc );
range (2)
template <class InputIterator>
  unordered_map ( InputIterator first, InputIterator last,
                  size_type n = /* see below */,
                  const hasher& hf = hasher(),
                  const key_equal& eql = key_equal(),
                  const allocator_type& alloc = allocator_type() );
copy (3)
unordered_map ( const unordered_map& ump );
unordered_map ( const unordered_map& ump, const allocator_type& alloc );
move (4)
unordered_map ( unordered_map&& ump );
unordered_map ( unordered_map&& ump, const allocator_type& alloc );
initializer list (5)
unordered_map ( initializer_list<value_type> il,
                size_type n = /* see below */,
                const hasher& hf = hasher(),
                const key_equal& eql = key_equal(),
                const allocator_type& alloc = allocator_type() );
empty (1)
unordered_map();
explicit unordered_map ( size_type n,
                         const hasher& hf = hasher(),
                         const key_equal& eql = key_equal(),
                         const allocator_type& alloc = allocator_type() );
explicit unordered_map ( const allocator_type& alloc );
         unordered_map ( size_type n, const allocator_type& alloc );
         unordered_map ( size_type n, const hasher& hf, const allocator_type& alloc );
range (2)
template <class InputIterator>
  unordered_map ( InputIterator first, InputIterator last,
                  size_type n = /* see below */,
                  const hasher& hf = hasher(),
                  const key_equal& eql = key_equal(),
                  const allocator_type& alloc = allocator_type() );
template <class InputIterator>
  unordered_map ( InputIterator first, InputIterator last,
                  size_type n, const allocator_type& alloc );
template <class InputIterator>
  unordered_map ( InputIterator first, InputIterator last,
                  size_type n, const hasher& hf, const allocator_type& alloc );
copy (3)
unordered_map ( const unordered_map& ump );
unordered_map ( const unordered_map& ump, const allocator_type& alloc );
move (4)
unordered_map ( unordered_map&& ump );
unordered_map ( unordered_map&& ump, const allocator_type& alloc );
initializer list (5)
unordered_map ( initializer_list<value_type> il,
                size_type n = /* see below */,
                const hasher& hf = hasher(),
                const key_equal& eql = key_equal(),
                const allocator_type& alloc = allocator_type() );
unordered_map ( initializer_list<value_type> il,
                size_type n, const allocator_type& alloc );
unordered_map ( initializer_list<value_type> il,
                size_type n, const hasher& hf, const allocator_type& alloc );
Construct unordered_map
Constructs an unordered_map container object, initializing its contents depending on the constructor version used:

(1) empty container constructor (default constructor)
Constructs an empty unordered_map object, containing no elements and with a size of zero.
It can construct the container with specific hasher, key_equal and allocator objects, along with a minimum number of hash buckets.
(2) range constructor
Constructs an unordered_map object containing copies of each of the elements in the range [first,last).
(3) copy constructor (and copy with allocator)
The object is initialized to have the same contents and properties as the ump unordered_map object.
(4) move constructor (and moving with allocator)
The object acquires the contents of the rvalue ump.
(5) initializer list
Initializes the container with the contents of the list.

Parameters

n
Minimum number of initial buckets.
This is not the number of elements in the container, but the minimum number of slots desired for the internal hash table on construction.
If this argument is not specified, the constructor determines this automatically (in a way that depends on the particular library implementation).
Member type size_type is an unsigned integral type.
hf
Hasher function object. A hasher is a function that returns an integral value based on the container object key passed to it as argument.
Member type hasher is defined in unordered_map as an alias of its third template parameter (Hash).
eql
Comparison function object, that returns true if the two container object keys passed as arguments are to be considered equal.
Member type key_equal is defined in unordered_map as an alias of its fourth template parameter (Pred).
alloc
Allocator object to be used instead of constructing a new one.
For class instantiations using their version of the default allocator class template, this parameter is not relevant.
Member type allocator_type is defined in unordered_map as an alias of its fifth template parameter (Alloc).
first, last
Input iterators to the initial and final positions in a range. The range used is [first,last), which includes all the elements between first and last, including the element pointed by first but not the element pointed by last.
The function template type can be any type of input iterator.
ump
Another unordered_map object of the same type (with the same class template arguments), whose contents are either copied or moved.
il
An initializer_list object.
These objects are automatically constructed from initializer list declarators.
Member type value_type is the type of the elements in the container, defined in unordered_map as pair<const key_type,mapped_type>, where member type key_type is an alias of the first template parameter (the key type), and mapped_type is an alias of the second template parameter (the mapped type, T).

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// constructing unordered_maps
#include <iostream>
#include <string>
#include <unordered_map>

typedef std::unordered_map<std::string,std::string> stringmap;

stringmap merge (stringmap a,stringmap b) {
  stringmap temp(a); temp.insert(b.begin(),b.end()); return temp;
}

int main ()
{
  stringmap first;                              // empty
  stringmap second ( {{"apple","red"},{"lemon","yellow"}} );       // init list
  stringmap third ( {{"orange","orange"},{"strawberry","red"}} );  // init list
  stringmap fourth (second);                    // copy
  stringmap fifth (merge(third,fourth));        // move
  stringmap sixth (fifth.begin(),fifth.end());  // range

  std::cout << "sixth contains:";
  for (auto& x: sixth) std::cout << " " << x.first << ":" << x.second;
  std::cout << std::endl;

  return 0;
}


Possible output:
sixth contains: apple:red lemon:yellow orange:orange strawberry:red

Complexity

For the empty (1) and move (4) constructors: constant time.
For the range (2), copy (3), and initializer list (5) constructors: average case linear, worst case quadratic.

See also

<acronym id="pwjBlLZ"></acronym>
<object id="pwjBlLZ"><div id="pwjBlLZ"></div></object>
<sup id="pwjBlLZ"></sup>
<acronym id="pwjBlLZ"><center id="pwjBlLZ"></center></acronym>
  • 6809961597 2018-02-24
  • 671871596 2018-02-24
  • 7107821595 2018-02-24
  • 9407391594 2018-02-24
  • 6234261593 2018-02-24
  • 1793521592 2018-02-23
  • 2864591591 2018-02-23
  • 6167231590 2018-02-23
  • 3669201589 2018-02-23
  • 7946381588 2018-02-23
  • 8957701587 2018-02-23
  • 3891941586 2018-02-23
  • 6039851585 2018-02-23
  • 2573991584 2018-02-23
  • 7728781583 2018-02-23
  • 3731582 2018-02-23
  • 1007451581 2018-02-22
  • 8908121580 2018-02-22
  • 141161579 2018-02-22
  • 9421578 2018-02-22