Namespaces
Variants

std::unordered_map<Key,T,Hash,KeyEqual,Allocator>:: operator=

From cppreference.net

C++
Containers library
std::unordered_map
Member types
Member functions
Non-member functions
Deduction guides (C++17)
unordered_map & operator = ( const unordered_map & other ) ;
(1) (начиная с C++11)
(constexpr начиная с C++26)
(2)
unordered_map & operator = ( unordered_map && other ) ;
(начиная с C++11)
(до C++17)
unordered_map & operator = ( unordered_map && other )
noexcept ( /* см. ниже */ ) ;
(начиная с C++17)
(constexpr начиная с C++26)
unordered_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 , могут быть либо уничтожены, либо заменены посредством поэлементного копирующего присваивания.
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) Линейно по размеру * this и ilist .

Исключения

2)
noexcept спецификация:
noexcept ( std:: allocator_traits < Allocator > :: is_always_equal :: value

&& std:: is_nothrow_move_assignable < Hash > :: value

&& std:: is_nothrow_move_assignable < Pred > :: value )
(начиная с C++17)

Примечания

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

Пример

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

Запустить этот код 
#include <initializer_list>
#include <iostream>
#include <iterator>
#include <unordered_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::unordered_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 = { {3,3}, {2,2}, {1,1} }
y = { }
z = { }
Copy assignment copies data from x to y:
x = { {3,3}, {2,2}, {1,1} }
y = { {3,3}, {2,2}, {1,1} }
Move assignment moves data from x to z, modifying both x and z:
x = { }
z = { {3,3}, {2,2}, {1,1} }
Assignment of initializer_list w to z:
w = { {4,4}, {5,5}, {6,6}, {7,7} }
z = { {7,7}, {6,6}, {5,5}, {4,4} }

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

создаёт unordered_map
(public member function)