# std::flat_multimap<Key,T,Compare,KeyContainer,MappedContainer>::operator=

From cppreference.com
< cpp‎ | container‎ | flat multimap

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

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

### Complexity

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

### Example

Run this code

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

    int main()
    {
        std::flat_multimap<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_multimap` (public member function)
replace | replaces the underlying containers (public member function)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/container/flat_multimap/operator%3D&oldid=169512"