std::ranges::copy_backward, std::ranges::copy_backward_result
De es.cppreference.net
| Definido en el encabezado <algorithm>
|
||
| Firma de llamada |
||
template< std::bidirectional_iterator I1, std::sentinel_for<I1> S1,
std::bidirectional_iterator I2 >
requires std::indirectly_copyable<I1, I2>
constexpr copy_backward_result<I1, I2>
copy_backward( I1 first, S1 last, I2 d_last );
|
(1) | (desde C++20) |
template< ranges::bidirectional_range R, std::bidirectional_iterator I >
requires std::indirectly_copyable<ranges::iterator_t<R>, I>
constexpr copy_backward_result<ranges::borrowed_iterator_t<R>, I>
copy_backward( R&& r, I d_last );
|
(2) | (desde C++20) |
| Tipos auxiliares |
||
template< class I1, class I2 >
using copy_backward_result = ranges::in_out_result<I1, I2>;
|
(3) | (desde C++20) |
1) Copia los elementos del rango, definido por
[first, last), a otro rango [d_last - N, d_last), donde N = ranges::distance(first, last). Los elementos se copian en orden inverso (el último elemento se copia primero), pero su orden relativo se conserva. El comportamiento no está definido si d_last está dentro de (first, last]. En tal caso, se puede usar std::ranges::copy en su lugar.2) Igual que (1), pero usa
r como rango fuente, como si usara ranges::begin(r) como first, y ranges::end(r) como last.Las entidades similares a funciones descritas en esta página son objetos función de algoritmo (informalmente conocidos como niebloids), es decir:
- Las listas explícitas de argumentos de plantilla no se pueden especificar al llamar a ninguna de ellas.
- Ninguna de ellas es visible para la búsqueda dependiente de argumentos.
- Cuando alguna de ellas es encontrada por búsqueda normal no cualificada como el nombre a la izquierda del operador de llamada a función, la búsqueda dependiente de argumentos se inhibe.
Parámetros
| first, last | - | el par iterador-centinela que define el rango de elementos desde el cual copiar |
| r | - | el rango de los elementos desde el cual copiar |
| d_last | - | el final del rango de destino |
Valor de retorno
{last, d_last - N}
Complejidad
Exactamente N asignaciones.
Notas
Al copiar rangos superpuestos, ranges::copy es apropiado cuando se copia hacia la izquierda (el inicio del rango de destino está fuera del rango fuente) mientras que ranges::copy_backward es apropiado cuando se copia hacia la derecha (el final del rango de destino está fuera del rango fuente).
Posible implementación
struct copy_backward_fn
{
template<std::bidirectional_iterator I1, std::sentinel_for<I1> S1,
std::bidirectional_iterator I2>
requires std::indirectly_copyable<I1, I2>
constexpr ranges::copy_backward_result<I1, I2>
operator()(I1 first, S1 last, I2 d_last) const
{
I1 last1 {ranges::next(first, std::move(last))};
for (I1 i {last1}; i != first;)
*--d_last = *--i;
return {std::move(last1), std::move(d_last)};
}
template<ranges::bidirectional_range R, std::bidirectional_iterator I>
requires std::indirectly_copyable<ranges::iterator_t<R>, I>
constexpr ranges::copy_backward_result<ranges::borrowed_iterator_t<R>, I>
operator()(R&& r, I d_last) const
{
return (*this)(ranges::begin(r), ranges::end(r), std::move(d_last));
}
};
inline constexpr copy_backward_fn copy_backward{};
|
Ejemplo
Ejecutar este código
#include <algorithm>
#include <iostream>
#include <ranges>
#include <string_view>
#include <vector>
void print(std::string_view rem, std::ranges::forward_range auto const& r)
{
for (std::cout << rem << ": "; auto const& elem : r)
std::cout << elem << ' ';
std::cout << '\n';
}
int main()
{
const auto src = {1, 2, 3, 4};
print("src", src);
std::vector<int> dst(src.size() + 2);
std::ranges::copy_backward(src, dst.end());
print("dst", dst);
std::ranges::fill(dst, 0);
const auto [in, out] =
std::ranges::copy_backward(src.begin(), src.end() - 2, dst.end());
print("dst", dst);
std::cout
<< "(in - src.begin) == " << std::distance(src.begin(), in) << '\n'
<< "(out - dst.begin) == " << std::distance(dst.begin(), out) << '\n';
}
Salida:
src: 1 2 3 4
dst: 0 0 1 2 3 4
dst: 0 0 0 0 1 2
(in - src.begin) == 2
(out - dst.begin) == 4
Véase también
(C++20)(C++20) |
copia un rango de elementos a una nueva ubicación (objeto función de algoritmo) |
(C++20) |
copia un número de elementos a una nueva ubicación (objeto función de algoritmo) |
(C++20)(C++20) |
copia un rango de elementos omitiendo aquellos que satisfacen criterios específicos (objeto función de algoritmo) |
(C++20)(C++20) |
copia un rango, reemplazando elementos que satisfacen criterios específicos con otro valor (objeto función de algoritmo) |
(C++20) |
crea una copia de un rango que está invertido (objeto función de algoritmo) |
(C++20) |
copia y rota un rango de elementos (objeto función de algoritmo) |
(C++20) |
crea una copia de algún rango de elementos que no contiene duplicados consecutivos (objeto función de algoritmo) |
(C++20) |
mueve un rango de elementos a una nueva ubicación (objeto función de algoritmo) |
(C++20) |
mueve un rango de elementos a una nueva ubicación en orden inverso (objeto función de algoritmo) |
| copia un rango de elementos en orden inverso (plantilla de función) |