Namespaces
Variants

    std::map<Key,T,Compare,Allocator>:: operator=

    From ru.cppreference.net

    C++
    Containers library
    std::map
    Member functions
    Non-member functions
    (until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
    Deduction guides (C++17)
    map & operator = ( const map & other ) ;
    		(1) (constexpr начиная с C++26)
    (2)
    map & operator = ( map && other ) ;
    		(начиная с C++11)
    (до C++17)
    map & operator = ( map && other )
    noexcept ( /* см. ниже */ ) ;
    		(начиная с C++17)
    (constexpr начиная с C++26)
    map & operator = ( std:: initializer_list < value_type > ilist ) ;
    		(3) (начиная с C++11)
    (constexpr начиная с C++26)

    Заменяет содержимое контейнера.

    Пусть traits будет std:: allocator_traits < allocator_type > :

    1) Оператор копирующего присваивания. Заменяет содержимое копией содержимого other .

    Если traits :: propagate_on_container_copy_assignment :: value равно true , аллокатор * this заменяется копией аллокатора other . Если после присваивания аллокатор * this будет сравниваться как неравный своему старому значению, старый аллокатор используется для освобождения памяти, затем новый аллокатор используется для её выделения перед копированием элементов. В противном случае память, принадлежащая * this , может быть повторно использована, когда это возможно. В любом случае, элементы, изначально принадлежавшие * this , могут быть либо уничтожены, либо заменены поэлементным копирующим присваиванием.

    		(начиная с C++11)
    2) Оператор перемещающего присваивания. Заменяет содержимое на содержимое other используя семантику перемещения (т.е. данные из other перемещаются в этот контейнер). other после этого находится в допустимом, но неопределённом состоянии.
    Если traits :: propagate_on_container_move_assignment :: value равно true , аллокатор * this заменяется копией аллокатора other . Если значение равно false и аллокаторы * this и other не эквивалентны, * this не может принять владение памятью, принадлежащей other , и должен перемещать каждый элемент по отдельности, выделяя дополнительную память с использованием собственного аллокатора при необходимости. В любом случае, все элементы, изначально принадлежавшие * this , либо уничтожаются, либо заменяются посредством поэлементного перемещения.
    3) Заменяет содержимое на элементы, указанные в списке инициализации ilist .

    Содержание

    Параметры

    other - другой контейнер для использования в качестве источника данных
    ilist - список инициализации для использования в качестве источника данных

    Возвращаемое значение

    * this

    Сложность

    1) Линейно по размеру * this и other .
    2) Линейно по размеру * this за исключением случаев, когда аллокаторы не сравниваются как равные и не распространяются, в этом случае линейно по размеру * this и other .
    3) O(N·log(N)) в общем случае, где N равно size ( ) + ilist. size ( ) . Линейная сложность, если ilist отсортирован относительно value_comp() .

    Исключения

    2)
    noexcept спецификация:
    noexcept ( std:: allocator_traits < Allocator > :: is_always_equal :: value
    && std:: is_nothrow_move_assignable < Compare > :: value )
    		(начиная с C++17)

    Примечания

    После перемещающего присваивания контейнера (перегрузка (2)), если только поэлементное перемещающее присваивание не принудительно из‑за несовместимых аллокаторов, ссылки, указатели и итераторы, которые изначально ссылались на элементы в other, остаются действительными, но ссылаются на элементы, которые теперь находятся в *this. Текущий стандарт даёт эту гарантию через общее утверждение в [container.reqmts]/67, и более прямая гарантия рассматривается через LWG issue 2321.

    Пример

    Следующий код использует operator = для присваивания одного std::map другому:

    Запустить этот код 
    #include <initializer_list>
#include <iostream>
#include <iterator>
#include <map>
#include <utility>
void print(const auto comment, const auto& container)
{
    auto size = std::size(container);
    std::cout << comment << "{ ";
    for (const auto& [key, value] : container)
        std::cout << '{' << key << ',' << value << (--size ? "}, " : "} ");
    std::cout << "}\n";
}
int main()
{
    std::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::cout << "Initially:\n";
    print("x = ", x);
    print("y = ", y);
    print("z = ", z);
    std::cout << "Copy assignment copies data from x to y:\n";
    y = x;
    print("x = ", x);
    print("y = ", y);
    std::cout << "Move assignment moves data from x to z, modifying both x and z:\n";
    z = std::move(x);
    print("x = ", x);
    print("z = ", z);
    std::cout << "Assignment of initializer_list w to z:\n";
    z = w;
    print("w = ", w);
    print("z = ", z);
}

    Вывод: 

    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} }

    Смотрите также

    		конструирует map
    (публичная функция-член)