Namespaces
Variants

std:: reverse_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 BidirIt, class OutputIt >

OutputIt reverse_copy ( BidirIt first, BidirIt last,

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

ForwardIt reverse_copy ( ExecutionPolicy && policy,
BidirIt first, BidirIt last,

ForwardIt d_first ) ;
(2) (depuis C++17)
1) Étant donné N comme std:: distance ( first, last ) . Copie les éléments de la plage [ first , last ) (plage source) vers une autre plage de N éléments commençant à d_first (plage de destination) de telle sorte que les éléments dans la plage de destination soient dans l'ordre inverse.
Se comporte comme s'il exécutait l'assignation * ( d_first + N - 1 - i ) = * ( first + i ) [1] une fois pour chaque entier i dans [ ​ 0 ​ , N ) .
Si les plages source et destination se chevauchent, le comportement est indéfini.
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)

Table des matières

Paramètres

first, last - la paire d'itérateurs définissant la plage source des éléments à copier
d_first - le début de la plage de destination
Exigences de type
-
BidirIt doit satisfaire aux exigences de LegacyBidirectionalIterator .
-
OutputIt doit satisfaire aux exigences de LegacyOutputIterator .
-
ForwardIt doit satisfaire aux exigences de LegacyForwardIterator .

Valeur de retour

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

Complexité

Exactement N assignments.

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é.

Implémentation possible

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

template<class BidirIt, class OutputIt>
constexpr // since C++20
OutputIt reverse_copy(BidirIt first, BidirIt last, OutputIt d_first)
{
    for (; first != last; ++d_first)
        *d_first = *(--last);
    return d_first;
}
**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++. Seul le texte en dehors de ces balises aurait dû être traduit, mais dans cet extrait, il n'y a pas de texte à traduire en dehors du code.

Notes

Les implémentations (par exemple MSVC STL ) peuvent activer la vectorisation lorsque les deux types d'itérateurs satisfont LegacyContiguousIterator et ont le même type de valeur, et que le type de valeur est TriviallyCopyable .

Exemple

Exécuter ce code 
#include <algorithm>
#include <iostream>
#include <vector>
int main()
{
    auto print = [](const std::vector<int>& v)
    {
        for (const auto& value : v)
            std::cout << value << ' ';
        std::cout << '\n';
    };
    std::vector<int> v{1, 2, 3};
    print(v);
    std::vector<int> destination(3);
    std::reverse_copy(std::begin(v), std::end(v), std::begin(destination));
    print(destination);
    std::reverse_copy(std::rbegin(v), std::rend(v), std::begin(destination));
    print(destination);
}

Sortie : 

1 2 3 
3 2 1 
1 2 3

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 Applicable à Comportement publié Comportement corrigé
LWG 2074 C++98 pour chaque i , l'affectation était
* ( d_first + N - i ) = * ( first + i ) [1] 		corrigé en
* ( d_first + N - 1 - i ) = * ( first + i ) [1]
LWG 2150 C++98 un seul élément devait être affecté a corrigé l'exigence
  1. ↑ 1.0 1.1 1.2 LegacyOutputIterator n'est pas requis de supporter les opérateurs binaires + et - . Les utilisations de + et - ici sont uniquement à titre d'exposition : le calcul réel n'a pas besoin de les utiliser.

Voir aussi

inverse l'ordre des éléments dans une plage
(modèle de fonction)
(C++20)
crée une copie inversée d'une plage
(objet fonction algorithme)