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
Definido en el encabezado <algorithm>
template < class BidirIt, class OutputIt >

OutputIt reverse_copy ( BidirIt first, BidirIt last,

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

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

ForwardIt d_first ) ;
(2) (desde C++17)
1) Dado N como std:: distance ( first, last ) . Copia los elementos del rango [ first , last ) (rango fuente) a otro rango de N elementos que comienza en d_first (rango destino) de tal manera que los elementos en el rango destino estén en orden inverso.
Se comporta como si ejecutara la asignación * ( d_first + N - 1 - i ) = * ( first + i ) [1] una vez para cada entero i en [ ​ 0 ​ , N ) .
Si los rangos de origen y destino se superponen, el comportamiento es indefinido.
2) Igual que (1) , pero ejecutado de acuerdo con la policy .
Esta sobrecarga participa en la resolución de sobrecarga solo si se cumplen todas las siguientes condiciones:

std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> es true .

(hasta C++20)

std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> es true .

(desde C++20)

Contenidos

Parámetros

first, last - el par de iteradores que define el rango fuente de elementos a copiar
d_first - el inicio del rango destino
Requisitos de tipo
-
BidirIt debe cumplir con los requisitos de LegacyBidirectionalIterator .
-
OutputIt debe cumplir con los requisitos de LegacyOutputIterator .
-
ForwardIt debe cumplir con los requisitos de LegacyForwardIterator .

Valor de retorno

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

Complejidad

Exactamente 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

Ejecutar este código 
#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);
}

Salida: 

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.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 2074 C++98 para cada i , la asignación era
* ( d_first + N - i ) = * ( first + i ) [1] 		corregido a
* ( d_first + N - 1 - i ) = * ( first + i ) [1]
LWG 2150 C++98 solo se requería asignar un elemento corregido el requisito
  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

invierte el orden de los elementos en un rango
(plantilla de función)
(C++20)
crea una copia de un rango que está invertido
(objeto función de algoritmo)