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
Definido en el encabezado <algorithm>
template < class BidirIt1, class BidirIt2 >
BidirIt2 copy_backward ( BidirIt1 first, BidirIt1 last, BidirIt2 d_last ) ;
(constexpr desde C++20)

Copia los elementos del rango [ first , last ) a otro rango que termina en d_last . Los elementos se copian en orden inverso (el último elemento se copia primero), pero se preserva su orden relativo.

El comportamiento es indefinido si d_last está dentro del rango ( first , last ] . En ese caso, debe usarse std::copy en lugar de std::copy_backward .

Contenidos

Parámetros

first, last - el par de iteradores que define el rango fuente de elementos a copiar
d_last - el final del rango destino
Requisitos de tipo
-
BidirIt debe cumplir con los requisitos de LegacyBidirectionalIterator .

Valor de retorno

Iterador al último elemento copiado.

Complejidad

Exactamente std:: distance ( first, last ) asignaciones.

Notas

Al copiar rangos superpuestos, std::copy es apropiado al copiar hacia la izquierda (el inicio del rango destino está fuera del rango fuente) mientras que std::copy_backward es apropiado al copiar hacia la derecha (el final del rango destino está fuera del rango fuente).

Implementación posible

template<class BidirIt1, class BidirIt2>
BidirIt2 copy_backward(BidirIt1 first, BidirIt1 last, BidirIt2 d_last)
{
    while (first != last)
        *(--d_last) = *(--last);
    return d_last;
}

Ejemplo

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

Salida:

destination contains: 0 0 1 2 3 4

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 1206 C++98 1. el comportamiento estaba bien definido si d_last == last
2. el comportamiento no estaba definido si d_last == first
1. se hizo indefinido
2. se hizo bien definido

Véase también

copia un rango de elementos a una nueva ubicación
(plantilla de función)
copia un rango de elementos en orden inverso
(objeto función de algoritmo)