Namespaces
Variants

std:: rotate_copy

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Definido en el encabezado <algorithm>
template < class ForwardIt, class OutputIt >

OutputIt rotate_copy ( ForwardIt first, ForwardIt middle,

ForwardIt last, OutputIt d_first ) ;
(1) (constexpr desde C++20)
template < class ExecutionPolicy,

class ForwardIt1, class ForwardIt2 >
ForwardIt2 rotate_copy ( ExecutionPolicy && policy,
ForwardIt1 first, ForwardIt1 middle,

ForwardIt1 last, ForwardIt2 d_first ) ;
(2) (desde C++17)

Copia la rotación hacia la izquierda de [ first , last ) a d_first .

1) Copia los elementos del rango [ first , last ) , de tal manera que en el rango destino que comienza en d_first , los elementos en [ first , middle ) se colocan después de los elementos en [ middle , last ) mientras se preserva el orden de los elementos en ambos rangos.
2) Igual que (1) , pero ejecutado de acuerdo con la policy .
Esta sobrecarga participa en la resolución de sobrecarga solo si se cumplen todas las siguientes condiciones:

std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> es true .

(hasta C++20)

std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> es true .

(desde C++20)

Si se satisface cualquiera de las siguientes condiciones, el comportamiento es indefinido:

  • [ first , middle ) o [ middle , last ) no es un rango válido .
  • Los rangos de origen y destino se superponen.

Contenidos

Parámetros

first, last - el par de iteradores que define el rango fuente de elementos a copiar
middle - un iterador a un elemento en [ first , last ) que debe aparecer al inicio del nuevo rango
d_first - inicio del rango de destino
policy - la política de ejecución a utilizar
Requisitos de tipo
-
ForwardIt, ForwardIt1, ForwardIt2 deben cumplir con los requisitos de LegacyForwardIterator .
-
OutputIt debe cumplir con los requisitos de LegacyOutputIterator .

Valor de retorno

Iterador de salida al elemento después del último elemento copiado.

Complejidad

Exactamente std:: distance ( first, last ) asignaciones.

Excepciones

La sobrecarga con un parámetro de plantilla llamado ExecutionPolicy reporta errores de la siguiente manera:

  • Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y ExecutionPolicy es uno de los standard policies , std::terminate es llamado. Para cualquier otro ExecutionPolicy , el comportamiento está definido por la implementación.
  • Si el algoritmo falla al asignar memoria, std::bad_alloc es lanzado.

Implementación posible

Consulte también las implementaciones en libstdc++ , libc++ , y MSVC STL . 

template<class ForwardIt, class OutputIt>
constexpr // desde C++20
OutputIt rotate_copy(ForwardIt first, ForwardIt middle,
                     ForwardIt last, OutputIt d_first)
{
    d_first = std::copy(middle, last, d_first);
    return std::copy(first, middle, d_first);
}

Ejemplo

Ejecutar este código 
#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>
int main()
{
    std::vector<int> src{1, 2, 3, 4, 5};
    std::vector<int> dest(src.size());
    auto pivot = std::find(src.begin(), src.end(), 3);
    std::rotate_copy(src.begin(), pivot, src.end(), dest.begin());
    for (int i : dest)
        std::cout << i << ' ';
    std::cout << '\n';
    // copiar el resultado de la rotación directamente a std::cout
    pivot = std::find(dest.begin(), dest.end(), 1);
    std::rotate_copy(dest.begin(), pivot, dest.end(),
                     std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
}

Salida: 

3 4 5 1 2
1 2 3 4 5

Véase también

rota el orden de elementos en un rango
(plantilla de función)
(C++20)
copia y rota un rango de elementos
(objeto función algoritmo)