std::reverse_copy

template< class BidirIt, class OutputIt >
OutputIt reverse_copy( BidirIt first, BidirIt last,
                       OutputIt d_first );

template< class ExecutionPolicy, class BidirIt, class ForwardIt >
ForwardIt reverse_copy( ExecutionPolicy&& policy,
                        BidirIt first, BidirIt last,
                        ForwardIt d_first );

Paramètres

Valeur de retour

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

Complexité

Exactement \(\scriptsize N\) 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;
}

` 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

#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);
}

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.

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