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

CKTIS / C++

std::move_backward — déplacer une plage depuis la fin

std::move_backward affecte les éléments d’une plage en allant du dernier au premier, tout en conservant leur ordre dans la destination. Il permet de décaler vers la droite une plage qui se chevauche, en toute sécurité.

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

Syntaxe

#include <algorithm>

template<class BidirectionalIterator1, class BidirectionalIterator2>
constexpr BidirectionalIterator2 move_backward(
    BidirectionalIterator1 first,
    BidirectionalIterator1 last,
    BidirectionalIterator2 result);

std::move_backward, déclaré dans <algorithm>, affecte par déplacement les éléments de [first, last) dans une plage qui se termine juste avant result. Pour N éléments, la destination est [result - N, result). Le traitement en sens inverse ne renverse pas l’ordre des éléments.

Les deux types d’itérateurs doivent être bidirectionnels, et les éléments de destination doivent déjà exister et prendre en charge l’affectation par déplacement. L’algorithme n’agrandit pas le conteneur. Il effectue exactement N affectations et renvoie un itérateur sur le début de la plage de destination. La notation result - N décrit une position ; elle n’impose pas l’utilisation d’itérateurs à accès aléatoire.

Attention au chevauchement : result ne doit pas appartenir à (first, last] ; le non-respect de cette précondition entraîne un comportement indéfini. Pour des plages qui se chevauchent, utilisez cet algorithme pour décaler vers la droite et std::move à trois arguments pour décaler vers la gauche. std::move à un argument est un cast qui permet les déplacements, et non un algorithme de plage.

L’exemple décale trois entiers de deux positions vers la droite. Pour int, l’affectation par déplacement conserve la valeur de la source, ce qui rend le résultat déterministe. Ne supposez pas que ce comportement s’applique à des types de classe arbitraires.

Exemples

#include <algorithm>
#include <iostream>

int main() {
    int values[] = {1, 2, 3, 0, 0};
    auto first_moved = std::move_backward(values, values + 3, values + 5);

    std::cout << "start: " << (first_moved - values) << '\n';
    for (int i = 0; i < 5; ++i) {
        if (i != 0) std::cout << ' ';
        std::cout << values[i];
    }
    std::cout << '\n';
}

Résultat

start: 2
1 2 1 2 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