std::swap

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)	(noexcept condicionalmente desde C++11) (constexpr desde C++20)
template< class T2, std::size_t N > void swap( T2 (&a)[N], T2 (&b)[N] );	(2)	(noexcept condicionalmente 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 arreglos 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)

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 de búsqueda habituales, 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 especializado 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).

(until 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:

std::swap (std::pair) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::tuple) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::shared_ptr) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::weak_ptr) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::unique_ptr) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::function) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::basic_string)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::array) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::deque)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::forward_list) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::list)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::vector)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::map)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::multimap)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::set)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::multiset)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::unordered_map) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::unordered_multimap) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::unordered_set) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::unordered_multiset) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::queue) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::priority_queue) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::stack) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::valarray) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::basic_stringbuf) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::basic_istringstream) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::basic_ostringstream) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::basic_stringstream) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::basic_filebuf) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::basic_ifstream) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::basic_ofstream) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::basic_fstream) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::basic_syncbuf) (C++20)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::basic_spanbuf) (C++23)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::basic_ispanstream) (C++23)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::basic_ospanstream) (C++23)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::basic_spanstream) (C++23)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::basic_regex) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::match_results) (C++11)	especializa el algoritmo `std::swap` (plantilla de función)
std::swap (std::thread) (C++11)	especializa el algoritmo std::swap (función)
std::swap (std::unique_lock) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::shared_lock) (C++14)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::promise) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::packaged_task) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::optional) (C++17)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::any) (C++17)	especializa el algoritmo std::swap (función)
std::swap (std::variant) (C++17)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::basic_stacktrace) (C++23)	especializa el algoritmo std::swap (plantilla de función)
swap (std::filesystem::path) (C++17)	especializa el algoritmo std::swap (función)
swap (std::expected) (C++23)	especializa el algoritmo std::swap (función)
swap (std::jthread) (C++20)	especializa el algoritmo std::swap (función)
swap (std::move_only_function) (C++23)	especializa el algoritmo std::swap (función)
swap (std::stop_source) (C++20)	especializa el algoritmo std::swap (función)
swap (std::stop_token) (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, type requirements are not satisfied
    swap(p, q);      // OK, ADL finds the appropriate friend `swap`
    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 arrays no podían intercambiarse	se añadió la sobrecarga (2)
LWG 2554	C++11	intercambiar arrays multidimensionales nunca puede ser noexcept debido a problemas de búsqueda de nombres	se hizo funcionar

Véase también

ranges::swap (C++20)	intercambia los valores de dos objetos (objeto de punto de personalización)
iter_swap	intercambia los elementos a los que apuntan dos iteradores (plantilla de función)
swap_ranges	intercambia dos rangos de elementos (plantilla de función & objeto función de algoritmo)
ranges::swap_ranges (C++20)
exchange (C++14)	reemplaza el argumento con un nuevo valor y devuelve su valor anterior (plantilla de función)

Soporte del compilador
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

es.cppreference.net

Namespaces

Variants