public member type
<unordered_map>

std::unordered_multimap::begin

container iterator (1)
      iterator begin() noexcept;
const_iterator begin() const noexcept;
bucket iterator (2)
      local_iterator begin ( size_type n );
const_local_iterator begin ( size_type n ) const;
Return iterator to beginning
Returns an iterator pointing to the first element in the unordered_multimap container (1) or in one of its buckets (2).

Notice that an unordered_multimap object makes no guarantees on which specific element is considered its first element. But, in any case, the range that goes from its begin to its end covers all the elements in the container (or the bucket), until invalidated.

Parameters

n
Bucket number. This shall be lower than bucket_count.
It is an optional parameter that changes the behavior of this member function: if set, the iterator retrieved points to the first element of a bucket, otherwise it points to the first element of the container.
Member type size_type is an unsigned integral type.

Return Value

An iterator to the first element in the container (1) or the bucket (2).

All return types (iterator, const_iterator, local_iterator and const_local_iterator) are member types. In the unordered_multimap class template, these are forward iterator types.
Local iterators are of the same category as non-local iterators. Their value_type, difference_type, pointer and reference member types are also the same. But the iterators themselves are not necessarily of the same type.

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
27
28
29
// unordered_multimap::begin/end example
#include <iostream>
#include <string>
#include <unordered_map>

int main ()
{
  std::unordered_multimap<std::string,std::string> myumm = {
    {"apple","red"},
    {"apple","green"},
    {"orange","orange"},
    {"strawberry","red"}
  };

  std::cout << "myumm contains:";
  for ( auto it = myumm.begin(); it != myumm.end(); ++it )
    std::cout << " " << it->first << ":" << it->second;
  std::cout << std::endl;

  std::cout << "myumm's buckets contain:\n";
  for ( unsigned i = 0; i < myumm.bucket_count(); ++i) {
    std::cout << "bucket #" << i << " contains:";
    for ( auto local_it = myumm.begin(i); local_it!= myumm.end(i); ++local_it )
      std::cout << " " << local_it->first << ":" << local_it->second;
    std::cout << std::endl;
  }

  return 0;
}


Possible output:
myumm contains: apple:red apple:green orange:orange strawberry:red
myumm's buckets contain:
bucket #0 contains:
bucket #1 contains:
bucket #2 contains: apple:red apple:green
bucket #3 contains: orange:orange
bucket #4 contains: strawberry:red

Complexity

Constant.

Iterator validity

No changes.

See also

  • 9281021542 2018-02-20
  • 632231541 2018-02-20
  • 9751491540 2018-02-20
  • 8333621539 2018-02-20
  • 995001538 2018-02-20
  • 6477441537 2018-02-20
  • 511981536 2018-02-19
  • 2072881535 2018-02-19
  • 6024461534 2018-02-19
  • 7594061533 2018-02-19
  • 9311341532 2018-02-19
  • 4928331531 2018-02-19
  • 38561530 2018-02-19
  • 7776611529 2018-02-19
  • 3038041528 2018-02-19
  • 9566341527 2018-02-19
  • 3936031526 2018-02-19
  • 9531111525 2018-02-19
  • 291211524 2018-02-19
  • 8962001523 2018-02-19