std::flat_map::operator=(3)

🌸 NAME 🌸

Hey bestie! Welcome to the std::flat_map::operator=(3) page from the C++ Standard Libary 💅. This is literally the assignment-operator page for std::flat_map — the whole vibe is replacing what’s inside the container adaptor with whatever argument you hand it.

std::flat_map::operator= - std::flat_map::operator=

---

✨ Synopsis ✨

okay so here are the three overloads, all since C++23, and overloads (1) and (2) are implicitly declared:

flat_map& operator=( const flat_map& other );              (1) (since C++23)
                                                                         (implicitly declared)
flat_map& operator=( flat_map&& other );                   (2) (since C++23)
                                                                         (implicitly declared)
flat_map& operator=( std::initializer_list<value_type>     (3) (since C++23)
ilist );

Replaces the contents of the container adaptor with the contents of given argument.

1. Copy assignment operator. Replaces the contents with a copy of the contents of other. Effectively calls c = other.c; comp = other.comp;.
2. Move assignment operator. Replaces the contents with those of other using move semantics. Effectively calls c = std::move(other.c); comp = std::move(other.comp);.
3. Replaces the contents with those identified by initializer list ilist.

---

🎀 Parameters 🎀

• other — another container adaptor to be used as source
• ilist — initializer list to be used as source

---

🫶 Return value 🫶

*this — that’s it, that’s the return value ✨

---

🦋 Complexity 🦋

• 1,2) Equivalent to that of operator= of the underlying container.
• 3) Linear in the size of *this and ilist.

---

💖 Example 💖

The page says // Run this code, so here’s the exact code, bestie — no cap:

#include <flat_map>
#include <initializer_list>
#include <print>
#include <utility>

int main()
{
    std::flat_map<int, int> x{{1, 1}, {2, 2}, {3, 3}}, y, z;
    const auto w = {std::pair<const int, int>{4, 4}, {5, 5}, {6, 6}, {7, 7}};

    std::println("Initially:");
    std::println("x = {}", x);
    std::println("y = {}", y);
    std::println("z = {}", z);

    y = x; // overload (1)
    std::println("Copy assignment copies data from x to y:");
    std::println("x = {}", x);
    std::println("y = {}", y);

    z = std::move(x); // overload (2)
    std::println("Move assignment moves data from x to z, modifying both x and z:");
    std::println("x = {}", x);
    std::println("z = {}", z);

    z = w; // overload (3)
    std::println("Assignment of initializer_list w to z:");
    std::println("w = {}", w);
    std::println("z = {}", z);
}

🌟 Output 🌟

Initially:
x = {1: 1, 2: 2, 3: 3}
y = {}
z = {}
Copy assignment copies data from x to y:
x = {1: 1, 2: 2, 3: 3}
y = {1: 1, 2: 2, 3: 3}
Move assignment moves data from x to z, modifying both x and z:
x = {}
z = {1: 1, 2: 2, 3: 3}
Assignment of initializer_list w to z:
w = {4: 4, 5: 5, 6: 6, 7: 7}
z = {4: 4, 5: 5, 6: 6, 7: 7}

---

🌈 See also 🌈

• constructor — constructs the flat_map (public member function)
• replace — replaces the underlying containers (public member function)

---

source/version: http://cppreference.com · date: 2024.06.10 · page: std::flat_map::operator=(3) — mwah, bestie, go slay your assignments 💖