std::unordered_map::begin,(3)

💅 std::unordered_map::begin,(3) 💅

okay bestie, welcome to the std::unordered_map::begin page from the C++ Standard Libary manual (yes, that's the spelling on the page, we're keeping it 💀). This is the begin iterator situation, and it's lowkey iconic 🦋

🌸 NAME 🌸

std::unordered_map::begin, — that's the official name, comma and all, no notes 💅

✨ Synopsis ✨

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

Returns an iterator to the first element of the unordered_map.

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

also the page has a visual called range-begin-end.svg — imagine the cutest little begin-to-end diagram 🎀

🎀 Parameters 🎀

(none) — no arguments, no stress, just vibes 🫶

💖 Return value 💖

An iterator to the first element. slay.

🦋 Complexity 🦋

Constant. periodt, it's giving instant.

🌈 Example 🌈

       // Run this code

        #include <cmath>
        #include <iostream>
        #include <unordered_map>

        struct Node { double x, y; };

        int main()
        {
            Node nodes[3] = {{1, 0}, {2, 0}, {3, 0}};

            // mag is a map mapping the address of a Node to its magnitude in
       the plane
            std::unordered_map<Node*, double> mag =
            {
                { nodes + 0, 1 },
                { nodes + 1, 2 },
                { nodes + 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
            }
        }

Possible output (copying the values exactly, bestie):

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

👑 See also 👑

the see-also list is a little chaotic, but every bit is here:

• end — returns an iterator to the end
• cend — (public member function)
• begin
• cbegin — returns an iterator to the beginning of a container or array
• (C++11) (function template)
• (C++14)

that's the whole page, bestie 🫶 source/version/date drop: it's from http://cppreference.com, dated 2024.06.10, page label std::unordered_map::begin,(3). go off and iterate responsibly 💖✨