Namespaces
Variants

std:: swap

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Definido en el encabezado <algorithm>
(hasta C++11)
Definido en el encabezado <utility>
(desde C++11)
Definido en el encabezado <string_view>
template < class T >
void swap ( T & a, T & b ) ;
(1) (condicionalmente noexcept desde C++11)
(constexpr desde C++20)
template < class T2, std:: size_t N >
void swap ( T2 ( & a ) [ N ] , T2 ( & b ) [ N ] ) ;
(2) (condicionalmente noexcept desde C++11)
(constexpr desde C++20)

Intercambia los valores dados.

1) Intercambia los valores a y b .

Esta sobrecarga participa en la resolución de sobrecarga solo si std:: is_move_constructible_v < T > && std:: is_move_assignable_v < T > es true .

(desde C++17)
2) Intercambia los arrays a y b . Equivalente a std:: swap_ranges ( a, a + N, b ) .

Esta sobrecarga participa en la resolución de sobrecarga solo si std:: is_swappable_v < T2 > es true .

(desde C++17)

Contenidos

Parámetros

a, b - los valores a intercambiar
Requisitos de tipo
-
T debe cumplir con los requisitos de CopyConstructible y CopyAssignable (hasta C++11) MoveConstructible y MoveAssignable (desde C++11) .
-
T2 debe cumplir con los requisitos de Swappable .

Valor de retorno

(ninguno)

Excepciones

1)

(ninguno)

(hasta C++11)
noexcept especificación:
noexcept (

std:: is_nothrow_move_constructible < T > :: value &&
std:: is_nothrow_move_assignable < T > :: value

)
(desde C++11)
2)
noexcept especificación:
noexcept ( noexcept ( swap ( * a, * b ) ) )
La búsqueda del identificador swap en la especificación de excepciones encuentra esta plantilla de función además de cualquier resultado encontrado por las reglas habituales de búsqueda, haciendo que la especificación de excepciones sea equivalente a C++17 std::is_nothrow_swappable . 		(desde C++11)
(hasta C++17)
noexcept especificación:
noexcept ( std:: is_nothrow_swappable_v < T2 > )
(desde C++17)

Complejidad

1) Constante.
2) Lineal en N .

Especializaciones

std::swap puede ser especializada en el espacio de nombres std para tipos definidos por el programa, pero tales especializaciones no son encontradas por ADL (el espacio de nombres std no es el espacio de nombres asociado para el tipo definido por el programa).

(hasta C++20)

La forma esperada de hacer que un tipo definido por el programa sea intercambiable es proporcionar una función no miembro swap en el mismo espacio de nombres que el tipo: consulte Swappable para más detalles.

Las siguientes sobrecargas ya están proporcionadas por la biblioteca estándar:

(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
especializa el algoritmo std::swap
(plantilla de función)
especializa el algoritmo std::swap
(plantilla de función)
especializa el algoritmo std::swap
(plantilla de función)
especializa el algoritmo std::swap
(plantilla de función)
especializa el algoritmo std::swap
(plantilla de función)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++20)
especializa el algoritmo std::swap
(plantilla de función)
(C++23)
especializa el algoritmo std::swap
(plantilla de función)
(C++23)
especializa el algoritmo std::swap
(plantilla de función)
(C++23)
especializa el algoritmo std::swap
(plantilla de función)
(C++23)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++14)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(C++17)
especializa el algoritmo std::swap
(plantilla de función)
(C++17)
especializa el algoritmo std::swap
(función)
(C++17)
especializa el algoritmo std::swap
(plantilla de función)
(C++23)
especializa el algoritmo std::swap
(plantilla de función)
(C++17)
especializa el algoritmo std::swap
(función)
(C++23)
especializa el algoritmo std::swap
(función)
(C++20)
especializa el algoritmo std::swap
(función)
(C++23)
especializa el algoritmo std::swap
(función)
(C++20)
especializa el algoritmo std::swap
(función)
(C++20)
especializa el algoritmo std::swap
(función)

Ejemplo

Ejecutar este código 
#include <algorithm>
#include <iostream>
namespace Ns
{
    class A
    {
        int id {};
        friend void swap(A& lhs, A& rhs)
        {
            std::cout << "swap(" << lhs << ", " << rhs << ")\n";
            std::swap(lhs.id, rhs.id);
        }
        friend std::ostream& operator<<(std::ostream& os, A const& a)
        {
            return os << "A::id=" << a.id;
        }
    public:
        A(int i) : id {i} {}
        A(A const&) = delete;
        A& operator = (A const&) = delete;
    };
}
int main()
{
    int a = 5, b = 3;
    std::cout << a << ' ' << b << '\n';
    std::swap(a, b);
    std::cout << a << ' ' << b << '\n';
    Ns::A p {6}, q {9};
    std::cout << p << ' ' << q << '\n';
//  std::swap(p, q); // error, los requisitos de tipo no se cumplen
    swap(p, q);      // OK, ADL encuentra la función `swap` amiga apropiada
    std::cout << p << ' ' << q << '\n';
}

Salida: 

5 3
3 5
A::id=6 A::id=9
swap(A::id=6, A::id=9)
A::id=9 A::id=6

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 227 C++98 T no se requería que fuera CopyConstructible o DefaultConstructible
(un objeto temporal de tipo T podría no poder construirse) 		T también se requiere que
sea CopyConstructible
LWG 809 C++98 los arreglos no podían intercambiarse se añadió la sobrecarga (2)
LWG 2554 C++11 intercambiar arreglos multidimensionales nunca
puede ser noexcept debido a problemas de búsqueda de nombres 		se hizo funcionar

Véase también

(C++20)
intercambia los valores de dos objetos
(objeto de punto de personalización)
intercambia los elementos apuntados por dos iteradores
(plantilla de función)
intercambia dos rangos de elementos
(plantilla de función)
(C++14)
reemplaza el argumento con un nuevo valor y devuelve su valor anterior
(plantilla de función)