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
Défini dans l'en-tête <algorithm>
template < class ForwardIt, class OutputIt >

OutputIt rotate_copy ( ForwardIt first, ForwardIt middle,

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

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

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

Copie la rotation vers la gauche de [ first , last ) vers d_first .

1) Copie les éléments de la plage [ first , last ) , de telle sorte que dans la plage de destination commençant à d_first , les éléments de [ first , middle ) soient placés après les éléments de [ middle , last ) tout en préservant l'ordre des éléments dans les deux plages.
2) Identique à (1) , mais exécuté selon la policy .
Cette surcharge participe à la résolution de surcharge seulement si toutes les conditions suivantes sont satisfaites :

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

(jusqu'à C++20)

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

(depuis C++20)

Si l'une des conditions suivantes est satisfaite, le comportement est indéfini :

  • [ first , middle ) ou [ middle , last ) n'est pas un intervalle valide .
  • Les intervalles source et destination se chevauchent.

Table des matières

Paramètres

first, last - la paire d'itérateurs définissant la plage source des éléments à copier
middle - un itérateur vers un élément dans [ first , last ) qui devrait apparaître au début de la nouvelle plage
d_first - début de la plage de destination
policy - la politique d'exécution à utiliser
Exigences de type
-
ForwardIt, ForwardIt1, ForwardIt2 doivent satisfaire aux exigences de LegacyForwardIterator .
-
OutputIt doit satisfaire aux exigences de LegacyOutputIterator .

Valeur de retour

Itérateur de sortie vers l'élément situé après le dernier élément copié.

Complexité

Exactement std:: distance ( first, last ) affectations.

Exceptions

La surcharge avec un paramètre de modèle nommé ExecutionPolicy signale les erreurs comme suit :

  • Si l'exécution d'une fonction invoquée dans le cadre de l'algorithme lève une exception et que ExecutionPolicy fait partie des politiques standard , std::terminate est appelé. Pour tout autre ExecutionPolicy , le comportement est défini par l'implémentation.
  • Si l'algorithme ne parvient pas à allouer de la mémoire, std::bad_alloc est levée.

Implémentation possible

Voir également les implémentations dans libstdc++ , libc++ , et MSVC STL . 

template<class ForwardIt, class OutputIt>
constexpr // depuis 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);
}

Exemple

Exécuter ce code 
#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';
    // copier directement le résultat de la rotation vers 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';
}

Sortie : 

3 4 5 1 2
1 2 3 4 5

Voir aussi

fait pivoter l'ordre des éléments dans une plage
(modèle de fonction)
(C++20)
copie et fait pivoter une plage d'éléments
(objet fonction algorithme)