Namespaces
Variants

std::copy_backward

Depuis fr.cppreference.net
 
 
Bibliothèque d'algorithmes
Algorithmes contraints et algorithmes sur les plages (C++20)
Algorithmes contraints, par exemple ranges::copy, ranges::sort, ...
Opérations de séquence non modificatrices    
Opérations par lots
(C++17)
Opérations de recherche
Opérations de séquence modificatrices
Opérations de copie
(C++11)
(C++11)
Opérations d'échange
Opérations de transformation
Opérations de génération
Opérations de suppression
Opérations de changement d'ordre
(jusqu'à C++17)(C++11)
(C++20)(C++20)
Opérations d'échantillonnage
(C++17)

Tri et opérations connexes
Opérations de partitionnement
(C++11)    

Opérations de tri
Opérations de recherche binaire
(sur plages partitionnées)
Opérations ensemblistes (sur plages triées)
Opérations de fusion (sur plages triées)
Opérations de tas
Opérations minimum/maximum
(C++11)
(C++17)
Opérations de comparaison lexicographique
Opérations de permutation


 
Défini dans l'en-tête <algorithm>
template< class BidirIt1, class BidirIt2 >
BidirIt2 copy_backward( BidirIt1 first, BidirIt1 last, BidirIt2 d_last );
(constexpr depuis C++20)

Copie les éléments de la plage [firstlast) vers une autre plage se terminant à d_last. Les éléments sont copiés dans l'ordre inverse (le dernier élément est copié en premier), mais leur ordre relatif est préservé.

Le comportement est indéfini si d_last se trouve dans (firstlast]. std::copy doit être utilisé à la place de std::copy_backward dans ce cas.

Paramètres

first, last - la paire d'itérateurs définissant la plage source des éléments à copier
d_last - la fin de la plage de destination
Exigences de type
-
BidirIt doit répondre aux exigences de LegacyBidirectionalIterator.

Valeur de retour

Itérateur pointant vers le dernier élément copié.

Complexité

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

Notes

Lors de la copie de plages qui se chevauchent, std::copy est approprié lors de la copie vers la gauche (le début de la plage de destination est en dehors de la plage source) tandis que std::copy_backward est approprié lors de la copie vers la droite (la fin de la plage de destination est en dehors de la plage source).

Implémentation possible

template<class BidirIt1, class BidirIt2>
BidirIt2 copy_backward(BidirIt1 first, BidirIt1 last, BidirIt2 d_last)
{
    while (first != last)
        *(--d_last) = *(--last);
    return d_last;
}

Exemple

#include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>

int main()
{
    std::vector<int> source(4);
    std::iota(source.begin(), source.end(), 1); // fills with 1, 2, 3, 4
    
    std::vector<int> destination(6);
    
    std::copy_backward(source.begin(), source.end(), destination.end());
    
    std::cout << "destination contains: ";
    for (auto i: destination)
        std::cout << i << ' ';
    std::cout << '\n';
}

Résultat :

destination contains: 0 0 1 2 3 4

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliquer à Comportement tel que publié Comportement correct
LWG 1206 C++98 1. le comportement était bien défini si d_last == last
2. le comportement était indéfini si d_last == first
1. rendu indéfini
2. rendu bien défini

Voir aussi

copie une plage d'éléments vers un nouvel emplacement
(gabarit de fonction & objet de fonction d'algorithme)
copie une plage d'éléments dans l'ordre inverse
(objet de fonction d'algorithme)