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)

 

<tbody> </tbody>

Definido en el archivo de encabezado <concepts>
inline namespace /* no especificado */ { inline constexpr /* 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 */ constexpr void 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ón const de un tipo clase literal semiregular (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_view const name, 
           std::ranges::common_range auto const& p, 
           std::ranges::common_range auto const& q)
{
    std::cout << name << "1{ ";
    for (auto const& i : p) std::cout << i << ' ';
    std::cout << "}, " << name << "2{ ";
    for (auto const& i : q) std::cout << i << ' ';
    std::cout << "}\n";
}

void print(std::string_view const 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)