Namespaces
Variants

    std::tuple<Types...>::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 de 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 de 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 de lenguaje
    Soporte de tipos (tipos básicos, RTTI)
    Macros de prueba de características de 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::tuple
     
    Definido en el encabezado <tuple> 
    void swap( tuple& other ) noexcept(/* see below */);
    		(1) (desde C++11)
    (constexpr desde C++20) 
    constexpr void swap( const tuple& other ) noexcept(/* see below */) const;
    		(2) (desde C++23)

    Llama a swap (que puede ser std::swap, o podría encontrarse mediante ADL) para cada elemento en *this y su elemento correspondiente en other.

    Si alguna llamada a la función swap seleccionada está mal formada, o no intercambia los elementos correspondientes de ambas tuplas, el comportamiento no está definido.

    		(hasta C++23)

    Si alguna llamada a la función swap seleccionada no intercambia los elementos correspondientes de ambas tuplas, el comportamiento no está definido.

    1) El programa está mal formado si (std::is_swappable_v<Types> && ...) no es true.
    2) El programa está mal formado si (std::is_swappable_v<const Types> && ...) no es true.
    		(desde C++23)

    Parámetros

    otro - tupla de valores a intercambiar

    Valor de retorno

    (ninguno)

    Excepciones

    noexcept especificación:
    noexcept (

    noexcept ( swap ( std:: declval < T0 & >> ( ) , std:: declval < T0 & > ( ) ) ) &&
    noexcept ( swap ( std:: declval < T1 & >> ( ) , std:: declval < T1 & > ( ) ) ) &&
    noexcept ( swap ( std:: declval < T2 & >> ( ) , std:: declval < T2 & > ( ) ) ) &&
    ...

    )

    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 < Types > && ... ) )
    2)
    noexcept especificación:
    noexcept ( ( std:: is_nothrow_swappable_v < const Types > && ... ) )
    		(desde C++17)

    Ejemplo

    Ejecutar este código 
    #include <iostream>
#include <string>
#include <tuple>
int main()
{
    std::tuple<int, std::string, float> p1{42, "ABCD", 2.71}, p2;
    p2 = std::make_tuple(10, "1234", 3.14);
    auto print_p1_p2 = [&](auto rem)
    {
        std::cout << rem
                  << "p1 = {" << std::get<0>(p1)
                  << ", "     << std::get<1>(p1)
                  << ", "     << std::get<2>(p1) << "}, "
                  << "p2 = {" << std::get<0>(p2)
                  << ", "     << std::get<1>(p2)
                  << ", "     << std::get<2>(p2) << "}\n";
    };
    print_p1_p2("Before p1.swap(p2): ");
    p1.swap(p2);
    print_p1_p2("After  p1.swap(p2): ");
    swap(p1, p2);
    print_p1_p2("After swap(p1, p2): ");
}

    Salida: 

    Before p1.swap(p2): p1 = {42, ABCD, 2.71}, p2 = {10, 1234, 3.14}
After  p1.swap(p2): p1 = {10, 1234, 3.14}, p2 = {42, ABCD, 2.71}
After swap(p1, p2): p1 = {42, ABCD, 2.71}, p2 = {10, 1234, 3.14}

    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 funcional

    Véase también

    (C++11)
    		especializa el algoritmo std::swap
    (plantilla de función)
    (C++11)
    		intercambia los contenidos
    (función miembro pública de std::pair<T1,T2> )