std::swap_ranges - cppreference.com

De cppreference.com

Definido en el archivo de encabezado `<algorithm>`
`template< class ForwardIt1, class ForwardIt2 > ForwardIt2 swap_ranges( ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2 );`	(1)	(constexpr desde C++20)
`template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > ForwardIt2 swap_ranges( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2 );`	(2)	(desde C++17)

1) Intercambia elementos entre el rango [first1, last1) y otro rango de std::distance(first1, last1) elementos comenzando en first2.

2) Igual que (1), pero ejecutado de acuerdo con la política de ejecución policy.

Esta sobrecarga no participa en la resolución de sobrecarga a menos que std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> (hasta C++20) std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> (desde C++20) sea verdadera.

Si se cumple alguna de las siguientes condiciones, el comportamiento no está definido:

Los dos rangos se superponen.
Existe un par de iteradores correspondientes iter1 y iter2 en los dos rangos de modo que *iter1 no es Intercambiable con *iter2.

Parámetros

first1, last1	-	El primer rango de elementos a intercambiar.
first2	-	El comienzo del segundo rango de elementos a intercambiar.
policy	-	La política de ejecución a usar. Véase política de ejecución para más detalles.
Requisitos de tipo
-`ForwardIt1, ForwardIt2` debe satisfacer los requisitos de ForwardIterator.

Valor de retorno

Iterador al elemento después del último elemento intercambiado en el rango que comienza con first2.

Complejidad

Exactamente std::distance(first1, last1) intercambios.

Excepciones

La sobrecarga con un parámetro de plantilla llamado ExecutionPolicy (política de ejecución) reporta errores tales que:

Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y la política de ejecución es una de las tres políticas estándar, se llama a std::terminate. Para cualquier otra política de ejecución, el comportamiento está definido por la implementación.
Si el algoritmo falla al asignar memoria, se lanza std::bad_alloc.

Notas

Las implementaciones (p. ej., MSVC STL) pueden habilitar la vectorización cuando el tipo iterador satisface IteradorContiguoLegado y el intercambio de su tipo valor no llama a una función miembro especial no trivial ni a swap hallada por la búsqueda dependiente de argumento.

Posible implementación

template<class ForwardIt1, class ForwardIt2>
constexpr //< Desreferenciabilidad C++20
ForwardIt2 swap_ranges(ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2)
{
    for (; first1 != last1; ++first1, ++first2)
        std::iter_swap(first1, first2);
    
    return first2;
}

Ejemplo

Demuestra el intercambio de subrangos de diferentes contenedores.

#include <algorithm>
#include <iostream>
#include <list>
#include <vector>

auto print = [](auto comment, auto const& seq)
{
    std::cout << comment;
    for (const auto& e : seq)
        std::cout << e << ' ';
    std::cout << '\n';
};

int main()
{
    std::vector<char> v{'a', 'b', 'c', 'd', 'e'};
    std::list<char> l{'1', '2', '3', '4', '5'};
    
    print("Antes de swap_ranges:\n" "v: ", v);
    print("l: ", l);
    
    std::swap_ranges(v.begin(), v.begin() + 3, l.begin());
    
    print("Después de swap_ranges:\n" "v: ", v);
    print("l: ", l);
}

Salida:

Antes de swap_ranges:
v: a b c d e
l: 1 2 3 4 5
Después de swap_ranges:
v: 1 2 3 d e
l: a b c 4 5