Namespaces
Variants

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

From cppreference.net
C++
Utilities library
std::pair
(1)
void swap ( pair & other ) noexcept ( /* ver más abajo */ ) ;
(desde C++11)
(hasta C++20)
constexpr void swap ( pair & other ) noexcept ( /* ver más abajo */ ) ;
(desde C++20)
constexpr void swap ( const pair & other ) const noexcept ( /* ver más abajo */ ) ;
(2) (desde C++23)

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

Si alguna de las llamadas a la función swap seleccionada está mal formada o no intercambia el valor del miembro, el comportamiento es indefinido.

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

Si alguna de las llamadas a la función swap seleccionada no intercambia el valor del miembro, el comportamiento es indefinido.

(desde C++23)

Contenidos

Parámetros

otro - par de valores a intercambiar

Valor de retorno

(ninguno)

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 los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 2456 C++11 la especificación noexcept 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...> )