std::multimap<Key,T,Compare,Allocator>::begin, std::multimap<Key,T,Compare,Allocator>::cbegin

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros(C++20)

Language support library

Concepts library(C++20)

Diagnostics library

Memory management library

Metaprogramming library(C++11)

General utilities library

Containers library

Iterators library

Ranges library(C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library(C++17)

Concurrency support library(C++11)

Execution control library(C++26)

Technical specifications

Symbols index

External libraries

 

Containers library

node-handle (C++17)

Sequence

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Associative

set

multiset

map

multimap

Unordered associative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptors

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Views

span (C++20)

mdspan (C++23)

Tables

Iterator invalidation

Member function table

Non-member function table

 

std::multimap

Member functions

multimap::multimap multimap::~multimap        multimap::operator= multimap::get_allocator

Iterators multimap::beginmultimap::cbegin (C++11) multimap::endmultimap::cend (C++11) multimap::rbeginmultimap::crbegin (C++11)    multimap::rendmultimap::crend (C++11) Capacity multimap::size multimap::max_size multimap::empty Observers multimap::key_comp multimap::value_comp Modifiers multimap::clear multimap::insert multimap::erase multimap::swap multimap::merge (C++17) multimap::insert_range (C++23) multimap::emplace (C++11) multimap::emplace_hint (C++11) multimap::extract (C++17) Lookup multimap::count multimap::find multimap::contains (C++20) multimap::equal_range multimap::lower_bound multimap::upper_bound

Non-member functions

operator==operator<=> (C++20) std::swap(std::multimap) erase_if(std::multimap) (C++20)   operator!=operator<operator>operator<=operator>= (until C++20)(until C++20)(until C++20)(until C++20)(until C++20)

Deduction guides(C++17)

 

iterator begin();	(1)	(noexcept since C++11) (constexpr since C++26)
const_iterator begin()const;	(2)	(noexcept since C++11) (constexpr since C++26)
const_iterator cbegin()constnoexcept;	(3)	(since C++11) (constexpr since C++26)

Returns an iterator to the first element of *this.

If *this is empty, the returned iterator will be equal to end().

Return value

Iterator to the first element.

Complexity

Constant.

Notes

libc++ backports cbegin() to C++98 mode.

Example

Run this code

#include <algorithm>#include <cassert>#include <cstddef>#include <iostream>#include <map>#include <string>   int main(){auto show_node =[](constauto& node, char ending ='\n'){std::cout<<"{ "<< node.first<<", "<< node.second<<" }"<< ending;};   std::multimap<std::size_t, std::string> mmap;assert(mmap.begin()== mmap.end());// OKassert(mmap.cbegin()== mmap.cend());// OK   mmap.insert({ sizeof(long), "LONG"}); show_node(*(mmap.cbegin()));assert(mmap.begin()!= mmap.end());// OKassert(mmap.cbegin()!= mmap.cend());// OK mmap.begin()->second ="long"; show_node(*(mmap.cbegin()));   mmap.insert({ sizeof(int), "int"}); show_node(*mmap.cbegin());   mmap.insert({ sizeof(short), "short"}); show_node(*mmap.cbegin());   mmap.insert({ sizeof(char), "char"}); show_node(*mmap.cbegin());   mmap.insert({{ sizeof(float), "float"}, { sizeof(double), "double"}});   std::cout<<"mmap = { ";std::for_each(mmap.cbegin(), mmap.cend(), [&](constauto& n){ show_node(n, ' ');});std::cout<<"};\n";}

Possible output:

{ 8, LONG } { 8, long } { 4, int } { 2, short } { 1, char } mmap = { { 1, char } { 2, short } { 4, int } { 4, float } { 8, long } { 8, double } };

See also

endcend (C++11)	returns an iterator to the end (public member function)
begincbegin (C++11)(C++14)	returns an iterator to the beginning of a container or array (function template)