std::ranges::copy_backward, std::ranges::copy_backward_result
De cppreference.com
Definido en el archivo de encabezado <algorithm> | ||
Signatura de la llamada | ||
template< std::bidirectional_iterator I1, std::sentinel_for<I1> S1, std::bidirectional_iterator I2 > | (1) | (desde C++20) |
template< ranges::bidirectional_range R, std::bidirectional_iterator I > requires std::indirectly_copyable<ranges::iterator_t<R>, I> | (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 [result - N, result), donde N = ranges::distance(first, last). Los elementos se copian en orden inverso (el último elemento se copia primero), pero se conserva su orden relativo. El comportamiento no está definido si result 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 niebloids, es decir:
- Las listas de argumentos de plantilla explícitas no se pueden especificar al llamar a cualquiera de ellas.
- Ninguna de ellas es visible para la búsqueda dependiente de argumentos.
- Cuando alguna de ellas se encuentra mediante la búsqueda normal no calificada como el nombre a la izquierda del operador de llamada a función, se inhibe la búsqueda dependiente de argumentos.
En la práctica, pueden implementarse como objetos función o con extensiones de compilador especiales.
Contenido |
[editar] Parámetros
| first | - | El comienzo del rango de los elementos a copiar. |
| last | - | El final del rango de los elementos a copiar. |
| r | - | El rango de los elementos a copiar. |
| result | - | El final del rango de destino. |
[editar] Valor de retorno
{last, result - N}.
[editar] Complejidad
Exactamente N asignaciones.
[editar] Notas
Al copiar rangos superpuestos, ranges::copy es apropiado cuando se copia a la izquierda (el comienzo del rango de destino está fuera del rango de origen) mientras que ranges::copy_backward es apropiado cuando se copia a la derecha (el final del rango de destino está fuera del rango de origen).
[editar] 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 result) const { I1 last1 {ranges::next(first, std::move(last))}; for (I1 i {last1}; i != first;) *--result = *--i; return {std::move(last1), std::move(result)}; } 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 result) const { return (*this)(ranges::begin(r), ranges::end(r), std::move(result)); } }; inline constexpr copy_backward_fn copy_backward{}; |
[editar] Ejemplo
Ejecuta 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
[editar] Véase también
(C++20)(C++20) | Copia un rango de elementos a una nueva ubicación. (niebloid) |
(C++20) | Copia un número de elementos a una nueva ubicación. (niebloid) |
(C++20)(C++20) | Copia un rango de elementos, omitiendo aquellos que satisfacen un criterio específico (niebloid) |
(C++20)(C++20) | Copia un rango, reemplazando los elementos que satisfacen un criterio específico con otro valor. (niebloid) |
(C++20) | Crea una copia de un rango que está invertido. (niebloid) |
(C++20) | Copia y rota un rango de elementos. (niebloid) |
(C++20) | Crea una copia de algún rango de elementos que no contiene duplicados consecutivos. (niebloid) |
(C++20) | Mueve un rango de elementos a una nueva ubicación. (niebloid) |
(C++20) | Mueve un rango de elementos a una nueva ubicación en orden inverso. (niebloid) |
| Copia un rango de elementos en orden inverso. (plantilla de función) |
