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

Parámetros

Valor de retorno

Iterador de salida al elemento después del último elemento copiado.

Complejidad

Exactamente \(\scriptsize N\) N asignaciones.

Excepciones

La sobrecarga con un parámetro de plantilla llamado ExecutionPolicy reporta errores de la siguiente manera:

• Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y ExecutionPolicy es uno de los standard policies , std::terminate es llamado. Para cualquier otro ExecutionPolicy , el comportamiento está definido por la implementación.
• Si el algoritmo falla al asignar memoria, std::bad_alloc es lanzado.

Implementación posible

Consulte también las implementaciones en libstdc++ , libc++ , y MSVC STL .

template<class BidirIt, class OutputIt>
constexpr // desde C++20
OutputIt reverse_copy(BidirIt first, BidirIt last, OutputIt d_first)
{
    for (; first != last; ++d_first)
        *d_first = *(--last);
    return d_first;
}

Notas

Las implementaciones (por ejemplo, MSVC STL ) pueden habilitar la vectorización cuando ambos tipos de iteradores satisfacen LegacyContiguousIterator y tienen el mismo tipo de valor, y el tipo de valor es TriviallyCopyable .

Ejemplo

#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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

1. ↑ ^{1.0 1.1 1.2} LegacyOutputIterator no se requiere que soporte los operadores binarios + y - . Los usos de + y - aquí son solo expositivos: el cálculo real no necesita utilizarlos.

Véase también