Namespaces
Variants

    std::pair<T1,T2>::swap

    De es.cppreference.net
     
    C++
    Soporte de compiladores
    Independiente y alojado
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos nombrados
    Macros de prueba de características (C++20)
    Biblioteca de soporte del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnóstico
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de utilidades generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numérica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de soporte de concurrencia (C++11)
    Biblioteca de control de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de utilidades
    Soporte del lenguaje
    Soporte de tipos (tipos básicos, RTTI)
    Macros de prueba de características de la biblioteca (C++20)
    Utilidades de programa
    Funciones variádicas
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Soporte de corrutinas (C++20)
    Soporte de contratos (C++26)
    Comparación de tres vías
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Utilidades generales
    Operadores relacionales (obsoleto en C++20)
     
    std::pair
     
    void swap( pair& other ) noexcept(/* see below */);
    		(1) (desde C++11)
    (constexpr desde C++20)    		 
    constexpr void swap( const pair& other ) const noexcept(/* see below */);
    		(2) (desde C++23)

    Intercambia first con other.first y second con other.second, como si se usara using std::swap; swap(first, other.first); swap(second, other.second);.

    Si alguna swap llamada a función seleccionada está mal formada o no intercambia el valor del miembro, el comportamiento no está definido.

    		(hasta C++23)
    1) El programa está mal formado si std::is_swappable_v<T1> o std::is_swappable_v<T2> no son true.
    2) El programa está mal formado si std::is_swappable_v<const T1> o std::is_swappable_v<const T2> no son true.

    Si alguna swap llamada a función seleccionada no intercambia el valor del miembro, el comportamiento no está definido.

    		(desde C++23)

    Parámetros

    otro - par de valores a intercambiar

    Excepciones

    noexcept especificación:
    noexcept (

    noexcept ( swap ( first, other. first ) ) &&
    noexcept ( swap ( second, other. second ) )

    )

    En la expresión anterior, el identificador swap se busca de la misma manera que el utilizado por el trait de C++17 std::is_nothrow_swappable .

    		(hasta C++17)
    1)
    noexcept especificación:
    noexcept (

    std:: is_nothrow_swappable_v < first_type > &&
    std:: is_nothrow_swappable_v < second_type >

    )
    2)
    noexcept especificación:
    noexcept (

    std:: is_nothrow_swappable_v < const first_type > &&
    std:: is_nothrow_swappable_v < const second_type >

    )
    		(desde C++17)

    Ejemplo

    Ejecutar este código 
    #include <iostream>
#include <utility>
#include <string>
int main()
{
    std::pair<int, std::string> p1(10, "test"), p2;
    p2.swap(p1);
    std::cout << "(" << p2.first << ", " << p2.second << ")\n";
#if __cpp_lib_ranges_zip >= 202110L
    // Usando la sobrecarga calificada const de swap de C++23
    // (swap ya no propaga la constancia del pair)
    int i1 = 10, i2{};
    std::string s1("test"), s2;
    const std::pair<int&, std::string&> r1(i1, s1), r2(i2, s2);
    r2.swap(r1);
    std::cout << "(" << i2 << ", " << s2 << ")\n";
#endif
}

    Salida posible: 

    (10, test)
(10, test)

    Informes de defectos

    Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a estándares C++ previamente publicados.

    DR Aplicado a Comportamiento publicado Comportamiento corregido
    LWG 2456 C++11 la noexcept especificación está mal formada se hizo funcionar

    Véase también

    		intercambia los valores de dos objetos
    (plantilla de función)
    		intercambia el contenido de dos tuple s
    (función miembro pública de std::tuple<Types...> )