Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::rotate — réordonner cycliquement une plage

std::rotate de <algorithm> réordonne une plage sur place : la partie qui commence à middle est déplacée avant celle qui commence à first. L’ordre de chaque partie est préservé et la fonction renvoie un itérateur vers leur nouvelle frontière.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

#include <algorithm>
template<class ForwardIterator>
constexpr ForwardIterator rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);

std::rotate(first, middle, last) effectue une rotation à gauche de [first, last) : il inverse l’ordre des parties [first, middle) et [middle, last), tout en préservant l’ordre des éléments à l’intérieur de chacune. Aucun élément n’est supprimé ; si la seconde partie n’est pas vide, l’élément à middle devient le premier.

Les deux parties doivent être des plages valides. L’opération nécessite des itérateurs modifiables satisfaisant au moins les exigences des itérateurs forward, des éléments échangeables, ainsi que la prise en charge de la construction par déplacement et de l’affectation par déplacement. Un itérateur input ne suffit pas. L’algorithme effectue au plus autant d’échanges qu’il y a d’éléments dans la plage entière.

Le résultat indique la frontière entre la seconde partie déplacée et la première : sa distance depuis first est égale à la longueur initiale de [middle, last). La notation first + (last - middle) de la spécification décrit cette position ; elle n’impose pas des itérateurs à accès aléatoire. Si first == middle, le résultat est last ; si middle == last, le résultat est first. Dans les deux cas, la séquence reste inchangée.

L’exemple fait tourner cinq nombres de deux positions vers la gauche et affiche l’indice de la frontière renvoyée. La surcharge sans politique d’exécution présentée ici est disponible en C++23. Le projet de norme cité est un document évolutif, et non une édition C++23 figée.

Exemples

#include <algorithm>
#include <array>
#include <cstddef>
#include <iostream>
#include <iterator>

int main() {
    std::array<int, 5> values{1, 2, 3, 4, 5};
    auto boundary = std::rotate(values.begin(), values.begin() + 2, values.end());

    for (std::size_t i = 0; i < values.size(); ++i) {
        if (i != 0) std::cout << ' ';
        std::cout << values[i];
    }
    std::cout << '\n';
    std::cout << "boundary index: "
              << std::distance(values.begin(), boundary) << '\n';
}

Résultat

3 4 5 1 2
boundary index: 3

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources