std::ranges::swap

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.

[editar] 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.

[editar] 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.

[editar] Ejemplo

#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);
}

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

[editar] Véase también