std::flat_m...t::operator=(3)

hey bestie!! 💖 this is the std::flat_multiset::operator= page, straight outta the C++ Standard Libary manual (yes, that’s how the header spells it — iconique typo energy, we’re keeping it 🫶).

💖 NAME 💖

std::flat_multiset::operator= - std::flat_multiset::operator= — yes, it’s the same thing on both sides, that’s literally how the NAME line is set up, no cap 💅.

✨ Synopsis ✨

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

okay so what does it do? It replaces the contents of the container adaptor with the contents of whatever argument you handed it. that’s the whole vibe ✨.

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 💫

It returns *this — the container adaptor itself, periodt 💅.

🔥 Complexity 🔥

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

🌸 Example 🌸

The page literally says // Run this code, and here’s the code, bestie:

#include <flat_set>
#include <initializer_list>
#include <print>

int main()
{
    std::flat_multiset<int> x{1, 2, 3}, y, z;
    const auto w = {4, 5, 6, 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, 2, 3}
y = {}
z = {}
Copy assignment copies data from x to y:
x = {1, 2, 3}
y = {1, 2, 3}
Move assignment moves data from x to z, modifying both x and z:
x = {}
z = {1, 2, 3}
Assignment of initializer_list w to z:
w = {4, 5, 6, 7}
z = {4, 5, 6, 7}

👀 See also 👀

• constructor — constructs the flat_multiset (public member function)
• replace — replaces the underlying container (public member function)

sourced from http://cppreference.com, dated 2024.06.10, and this is the std::flat_m...t::operator=(3) page — byeee bestie, mwah 💋✨