std::ranges::swap

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios 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 apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Biblioteca de macros de prueba de característica(C++20) Servicios del programa Apoyo de corrutinas(C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits(C++20) bitset hash (C++11) Operadores relacionales(en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Definido en el archivo de encabezado <concepts>
inlinenamespace/* no especificado */{     inlineconstexpr/* no especificado */ swap =/* no especificado */; }		(desde C++20) (objeto punto de personalización)
Signatura de la llamada
template<class T, class U >     requires /* véase más abajo */ constexprvoid swap(T&& t, U&& u)noexcept(/* véase más abajo */);

Intercambia los valores referenciados por t y u.

Una llamada a ranges::swap:

1. es equivalente en expresión a (void)swap(std::forward<T>(t), std::forward<U>(u)), si esa expresión es válida, donde la resolución de sobrecarga se realiza con los siguientes candidatos:
   • template<class T>void swap(T&, T&)= delete;
   • template<class T, std::size_t N>void swap(T(&)[N], T(&)[N])= delete;
   • cualquier declaración de swap encontrada por la búsqueda dependiente de argumento.

   Si la función seleccionada por la resolución de sobrecarga no intercambia los valores referenciados por t y u, el programa está mal formado; no se requiere diagnóstico.

2. De lo contrario, es equivalente en expresión a (void)ranges::swap_ranges(t, u) excepto que noexcept(ranges::swap(t), ranges::swap(u)) es igual a noexcept(ranges::swap(*t, *u)), si T y U son referencias a l-valor a tipos array de igual extensión (pero posiblemente de tipos de elementos diferentes) y ranges::swap(*t, *u) es una expresión válida;
3. De lo contrario, intercambia los valores referenciados como si lo fuera por V v(std::move(t)); t = std::move(u); u = std::move(v);, si T y U son ambas V& para algún tipo V que satisface a std::move_constructible<V> y a std::assignable_from<V&, V>.
   • Si la llamada potencialmente lanza se especifica por las operaciones descritas anteriormente.
   • La llamada es una subexpresión constante si ambas operaciones descritas anteriormente y las operaciones realizadas con u y v intercambiadas son usables en una evaluación constante.

   Si alguno de los conceptos no se modela,, el programa está mal formado; no se requiere diagnóstico.

4. En todos los otros casos, una llamada a ranges::swap está mal formada, lo que puede resultar en falla en la sustitución cuando ranges::swap(t, u) aparece en el contexto inmediato de la instanciación de una plantilla.

Equivalente en expresión

La expresión e es equivalente-en-expresión a la expresión f, si e y f tienen los mismos efectos, ambas potencialmente lanzan o ambas potencialmente no lanzan (es decir, noexcept(e)==noexcept(f)), y ambas son subexpresiones constantes o ambas no son subexpresiones constantes.

Objetos de punto de personalización

El nombre ranges::swap denota un objeto de punto de personalización, que es un objeto funciónconst de un tipo clase literalsemiregular (denotado, a efectos de exposición, como swap_ftor). Todos los ejemplares de swap_ftor son iguales. Por lo tanto, ranges::swap puede copiarse libremente y sus copias pueden usarse indistintamente.

Dado un conjunto de tipos Args..., si std::declval<Args>()... cumple con los requerimientos para los argumentos de ranges::swap mencionado anteriormente, swap_ftor satisfará a std::invocable<const swap_ftor&, Args...>. De lo contrario, ningún operador de llamada a función de swap_ftor participa en la resolución de sobrecarga.

Ejemplo

Ejecuta este código

#include <array>#include <concepts>#include <iostream>#include <ranges>#include <string_view>#include <vector>   void print(std::string_viewconst name, std::ranges::common_rangeautoconst& p, std::ranges::common_rangeautoconst& q){std::cout<< name <<"1{ ";for(autoconst& i : p)std::cout<< i <<' ';std::cout<<"}, "<< name <<"2{ ";for(autoconst& i : q)std::cout<< i <<' ';std::cout<<"}\n";}   void print(std::string_viewconst name, int p, int q){std::cout<< name <<"1 = "<< p <<", "<< name <<"2 = "<< q <<'\n';}   int main(){std::vector a1{10,11,12}, a2{13,14}; std::ranges::swap(a1, a2); print("a", a1, a2);   std::array b1{15,16,17}, b2{18,19,20}; std::ranges::swap(b1, b2); print("b", b1, b2);   // std::array c1{1,2,3}; std::array c2{4,5};// std::ranges::swap(c1, c2); // ERROR: tipos no coinciden   int d1[]{21,22,23}, d2[]{24,25,26}; std::ranges::swap(d1, d2); print("d", d1, d2);   // int e1[]{1,2,3}, e2[]{4,5};// std::ranges::swap(e1, e2); // ERROR: tipos no coinciden   // char f1[]{1,2,3};// int f2[]{4,5,6};// std::ranges::swap(f1, f2); // ERROR: tipos no coinciden   int g1{27}, g2{28}; std::ranges::swap(g1, g2); print("g", g1, g2);}

Salida:

a1{ 13 14 }, a2{ 10 11 12 } b1{ 18 19 20 }, b2{ 15 16 17 } d1{ 24 25 26 }, d2{ 21 22 23 } g1 = 28, g2 = 27

Véase también

swappableswappable_with (C++20)	Especifica que un tipo puede ser intercambiado o que dos tipos pueden ser intercambiados uno con el otro. (concepto)
swap	Intercambia los valores de dos objetos (plantilla de función)