Namespaces
Variants

std:: copy_backward

From cppreference.net
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
copy_backward
(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
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
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 [ first , last ) vers une autre plage se terminant à d_last . Les éléments sont copiés en ordre inverse (le dernier élément est copié en premier), mais leur ordre relatif est préservé.

Le comportement n'est pas défini si d_last se trouve dans l'intervalle ( first , last ] . std::copy doit être utilisé à la place de std::copy_backward dans ce cas.

Table des matières

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 satisfaire aux exigences de LegacyBidirectionalIterator .

Valeur de retour

Itérateur 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 d'une 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 d'une 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;
}
**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises `
` et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte environnant aurait été traduit s'il y en avait eu.

Exemple

#include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
int main()
{
    std::vector<int> source(4);
    std::iota(source.begin(), source.end(), 1); // remplit avec 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';
}

Sortie :

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 Appliqué à Comportement tel que publié Comportement corrigé
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
(fonction template)
copie une plage d'éléments dans l'ordre inverse
(objet fonction algorithme)