std::ranges::copy, std::ranges::copy_if, std::ranges::copy_result, std::ranges::copy_if_result
De cppreference.com
<tbody>
</tbody>
| Definido en el archivo de encabezado <algorithm>
|
||
| Signatura de la llamada |
||
template< std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O > requires std::indirectly_copyable<I, O> constexpr copy_result<I, O> copy( I first, S last, O result ); |
(1) | (desde C++20) |
template< ranges::input_range R, std::weakly_incrementable O > requires std::indirectly_copyable<ranges::iterator_t<R>, O> constexpr copy_result<ranges::borrowed_iterator_t<R>, O> copy( R&& r, O result ); |
(2) | (desde C++20) |
template< std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred > requires std::indirectly_copyable<I, O> constexpr copy_if_result<I, O> copy_if( I first, S last, O result, Pred pred, Proj proj = {} ); |
(3) | (desde C++20) |
template< ranges::input_range R, std::weakly_incrementable O, class Proj = std::identity, std::indirect_unary_predicate< std::projected<ranges::iterator_t<R>, Proj>> Pred > requires std::indirectly_copyable<ranges::iterator_t<R>, O> constexpr copy_if_result<ranges::borrowed_iterator_t<R>, O> copy_if( R&& r, O result, Pred pred, Proj proj = {} ); |
(4) | (desde C++20) |
| Tipos auxiliares |
||
template< class I, class O > using copy_result = ranges::in_out_result<I, O>; |
(5) | (desde C++20) |
template< class I, class O > using copy_if_result = ranges::in_out_result<I, O>; |
(6) | (desde C++20) |
Copia los elementos del rango definido por [first, last) a otro rango que comienza en result.
1) Copia todos los elementos en el rango
[first, last) iniciando con first y procediendo hasta last - 1.El comportamiento no está definido si result está dentro del rango [first, last). En este caso, se puede usar ranges::copy_backward en su lugar.3) Solo copia los elementos para los que el predicado
pred devuelve true. Se conserva el orden relativo de los elementos que se copian. El comportamiento no está definido si los rangos de origen y destino se superponen.2,4) Igual que (1,3), 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.
Parámetros
| first, last | - | El rango de los elementos a copiar. |
| r | - | El rango de los elementos a copiar. |
| result | - | El comienzo del rango de destino. |
| pred | - | El predicado a aplicar a los elementos proyectados. |
| proj | - | La proyección a aplicar a los elementos. |
Valor de retorno
Un objeto de tipo ranges::in_out_result que contiene un iterador de entrada igual a last y un iterador de salida más allá del último elemento copiado.
Complejidad
1-2) Exactamente
last - first asignaciones.3-4) Exactamente
last - first aplicaciones del predicado y la proyección, entre 0 y last - first asignaciones (asignación para cada elemento para el cual el predicado devuelve true, según el predicado y los datos de entrada).Notas
En la práctica, las implementaciones de ranges::copy evitan asignaciones múltiples y usan funciones de copia masiva como std::memmove si el tipo de valor es TriviallyCopyable y el los tipos iterador satisfacen contiguous_iterator.
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).
Posible implementación
| copy |
|---|
struct copy_fn
{
template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O>
requires std::indirectly_copyable<I, O>
constexpr ranges::copy_result<I, O> operator()(I first, S last, O result) const
{
for (; first != last; ++first, (void)++result)
*result = *first;
return {std::move(first), std::move(result)};
}
template<ranges::input_range R, std::weakly_incrementable O>
requires std::indirectly_copyable<ranges::iterator_t<R>, O>
constexpr ranges::copy_result<ranges::borrowed_iterator_t<R>, O>
operator()(R&& r, O result) const
{
return (*this)(ranges::begin(r), ranges::end(r), std::move(result));
}
};
inline constexpr copy_fn copy;
|
| copy_if |
struct copy_if_fn
{
template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O,
class Proj = std::identity,
std::indirect_unary_predicate<std::projected<I, Proj>> Pred>
requires std::indirectly_copyable<I, O>
constexpr ranges::copy_if_result<I, O>
operator()(I first, S last, O result, Pred pred, Proj proj = {}) const
{
for (; first != last; ++first)
if (std::invoke(pred, std::invoke(proj, *first)))
{
*result = *first;
++result;
}
return {std::move(first), std::move(result)};
}
template<ranges::input_range R, std::weakly_incrementable O,
class Proj = std::identity,
std::indirect_unary_predicate<
std::projected<ranges::iterator_t<R>, Proj>> Pred>
requires std::indirectly_copyable<ranges::iterator_t<R>, O>
constexpr ranges::copy_if_result<ranges::borrowed_iterator_t<R>, O>
operator()(R&& r, O result, Pred pred, Proj proj = {}) const
{
return (*this)(ranges::begin(r), ranges::end(r),
std::move(result),
std::ref(pred), std::ref(proj));
}
};
inline constexpr copy_if_fn copy_if;
|
Ejemplo
El siguiente código usa ranges::copy tanto para copiar el contenido de un std::vector a otro como para mostrar el std::vector resultante:
Ejecuta este código
#include <algorithm>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
int main()
{
std::vector<int> source(10);
std::iota(source.begin(), source.end(), 0);
std::vector<int> destination;
std::ranges::copy(source.begin(), source.end(),
std::back_inserter(destination));
// o alternativamente,
// std::vector<int> destination(source.size());
// std::ranges::copy(source.begin(), source.end(), destination.begin());
// de cualquier manera es equivalente a
// std::vector<int> destination = source;
std::cout << "El destino contiene: ";
std::ranges::copy(destination, std::ostream_iterator<int>(std::cout, " "));
std::cout << '\n';
std::cout << "Los números impares en el destino son: ";
std::ranges::copy_if(destination, std::ostream_iterator<int>(std::cout, " "),
[](int x) { return (x % 2) == 1; });
std::cout << '\n';
}
Salida:
El destino contiene: 0 1 2 3 4 5 6 7 8 9
Los números impares en el destino son: 1 3 5 7 9
Véase también
(C++20) |
Copia un rango de elementos en orden inverso. (niebloid) |
(C++20) |
Crea una copia de un rango que está invertido. (niebloid) |
(C++20) |
Copia un número de elementos a una nueva ubicación. (niebloid) |
(C++20) |
Asigna un cierto valor a un rango de elementos. (niebloid) |
(C++20)(C++20) |
Copia un rango de elementos, omitiendo aquellos que satisfacen un criterio específico (niebloid) |
(C++11) |
Copia un rango de elementos a una nueva ubicación. (plantilla de función) |