std::map<Key,T,Compare,Allocator>::begin, std::map<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)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Execution support library (C++26)

Technical specifications

Symbols index

External libraries

 

Containers library

Sequence

array (C++11)

vector

vector<bool>

inplace_vector (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::map

Member functions

map::map map::~map               map::operator= map::get_allocator

Element access map::at map::operator[] Iterators map::beginmap::cbegin (C++11) map::endmap::cend (C++11) map::rbeginmap::crbegin (C++11)      map::rendmap::crend (C++11) Capacity map::size map::max_size map::empty Observers map::key_comp map::value_comp Modifiers map::clear map::insert map::erase map::swap map::extract (C++17) map::merge (C++17) map::insert_range (C++23) map::insert_or_assign (C++17) map::emplace (C++11) map::emplace_hint (C++11) map::try_emplace (C++17) Lookup map::count map::find map::contains (C++20) map::equal_range map::lower_bound map::upper_bound

Non-member functions

operator==operator<=> (C++20) std::swap(std::map) erase_if(std::map) (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)
const_iterator begin() const;	(2)	(noexcept since C++11)
const_iterator cbegin() const noexcept;	(3)	(since C++11)

Returns an iterator to the first element of the map.

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

Parameters

(none)

Return value

Iterator to the first element.

Complexity

Constant.

Notes

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

Example

Run this code

#include <iostream>
#include <map>
 
int main()
{
    std::map<int, float> num_map;
    num_map[4] = 4.13;
    num_map[9] = 9.24;
    num_map[1] = 1.09;
    // Calls num_map.begin() and num_map.end()
    for (auto it = num_map.begin(); it != num_map.end(); ++it)
        std::cout << it->first << ", " << it->second << '\n';
}

Output:

1, 1.09
4, 4.13
9, 9.24

Example using a custom comparison function

Run this code

#include <cmath>
#include <iostream>
#include <map>
 
struct Point { double x, y; };
 
// Compare the x-coordinates of two Point pointers.
struct PointCmp
{
    bool operator()(const Point* lhs, const Point* rhs) const
    {
        return lhs->x < rhs->x; 
    }
};
 
int main()
{
    // Note that although the x-coordinates are out of order, the
    // map will be iterated through by increasing x-coordinates.
    Point points[3] = {{2, 0}, {1, 0}, {3, 0}};
 
    // mag is a map sending the address of node to its magnitude in the x-y plane.
    // Although the keys are pointers-to-Point, we want to order the map by the
    // x-coordinates of the points and NOT by the addresses of the Points. This
    // is done by using the PointCmp class's comparison method.
    std::map<Point*, double, PointCmp> mag(
        {{points, 2}, {points + 1, 1}, {points + 2, 3}}
    );
 
    // Change each y-coordinate from 0 to the magnitude.
    for (auto iter = mag.begin(); iter != mag.end(); ++iter)
    {
        auto cur = iter->first; // Pointer to Node
        cur->y = mag[cur]; // Could also have used cur->y = iter->second;
    }
 
    // Update and print the magnitude of each node.
    for (auto iter = mag.begin(); iter != mag.end(); ++iter)
    {
        auto cur = iter->first;
        mag[cur] = std::hypot(cur->x, cur->y);
        std::cout << "The magnitude of (" << cur->x << ", " << cur->y << ") is ";
        std::cout << iter->second << '\n';
    }
 
    // Repeat the above with the range-based for loop.
    for (auto i : mag)
    {
        auto cur = i.first;
        cur->y = i.second;
        mag[cur] = std::hypot(cur->x, cur->y);
        std::cout << "The magnitude of (" << cur->x << ", " << cur->y << ") is ";
        std::cout << mag[cur] << '\n';
        // Note that in contrast to std::cout << iter->second << '\n'; above, 
        // std::cout << i.second << '\n'; will NOT print the updated magnitude.
        // If auto &i : mag was used instead, it will print the updated magnitude.
    }
}

Output:

The magnitude of (1, 1) is 1.41421
The magnitude of (2, 2) is 2.82843
The magnitude of (3, 3) is 4.24264
The magnitude of (1, 1.41421) is 1.73205
The magnitude of (2, 2.82843) is 3.4641
The magnitude of (3, 4.24264) is 5.19615

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)