std::unordered_map<Key,T,Hash,KeyEqual,Allocator>::swap - cppreference.com

De cppreference.com

</tbody> <tbody class="t-dcl-rev "> </tbody><tbody>

`void swap( unordered_map& other );`		(desde C++11) (hasta C++17)
`void swap( unordered_map& other ) noexcept(/* véase más abajo */);`		(desde C++17)

Intercambia el contenido del contenedor con el de other. No invoca ninguna operación de movimiento, copia o intercambio en los elementos individuales.

Todas las referencias y los iteradores se mantienen válidos. Se invalida el iterador después del final.

Hash y KeyEqual deben ser Swappable, y se intercambian usando llamadas no-calificada a una función no miembro swap.

Si std::allocator_traits<allocator_type>::propagate_on_container_swap::value es verdadero, entonces los asignadores de memoria se intercambian usando una llamada no-calificada a una función no miembro swap. De lo contrario, no se intercambian (y si get_allocator() != other.get_allocator(), el comportamiento no está definido).

(desde C++11)

Parámetros

other

El contenedor con el cual intercambiar el contenido.

Valor de retorno

(Ninguno)

Excepciones

Cualquier excepción lanzada por el intercambio de los objetos Hash o KeyEqual.

(hasta C++17)

Especificación

noexcept

: (desde C++11)

`noexcept(std::allocator_traits<Allocator>::is_always_equal::value && std::is_nothrow_swappable<Hash>::value && std::is_nothrow_swappable<key_equal>::value)`

(desde C++17)

Complejidad

Constante.

Ejemplo

#include <iostream>
#include <string>
#include <utility>
#include <unordered_map>

// imprimir un std::pair
template <class Os, class U, class V>
Os& operator<<(Os& os, const std::pair<U, V>& p) {
    return os << p.first << ":" << p.second;
}

// imprimir un contenedor
template <class Os, class Co>
Os& operator<<(Os& os, const Co& co) {
    os << "{";
    for (auto const& i : co) { os << ' ' << i; }
    return os << " }\n";
}

int main()
{
    std::unordered_map<std::string, std::string>
        m1 { {"γ", "gama"}, {"β", "beta"}, {"α", "alfa"}, {"γ", "gama"}, },
        m2 { {"ε", "epsilon"}, {"δ", "delta"}, {"ε", "epsilon"} };

    const auto& ref = *(m1.begin());
    const auto iter = std::next(m1.cbegin());

    std::cout << "──────── antes del intercambio ────────\n"
              << "m1: " << m1 << "m2: " << m2 << "ref: " << ref
              << "\niter: " << *iter << '\n';

    m1.swap(m2);

    std::cout << "──────── después del intercambio ────────\n"
              << "m1: " << m1 << "m2: " << m2 << "ref: " << ref
              << "\niter: " << *iter << '\n';

    // Ten en cuenta que cada iterador que se refiere a un elemento en un contenedor
    // antes del intercambio se refiere al mismo elemento en otro contenedor después
    // del intercambio.  Lo mismo es verdad para las referencias.
}

Posible salida: