std::ranges::copy, std::ranges::copy_if, std::ranges::copy_result, std::ranges::copy_if_result
De es.cppreference.net
| Definido en el encabezado <algorithm>
|
||
| Firma de 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 en el rango, definido por [first, last), a otro rango que comienza en result.
1) Copia todos los elementos en el rango
[first, last) comenzando desde first y avanzando 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 cuales el predicado
pred devuelve true. Se conserva el orden relativo de los elementos copiados. 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 de origen, como si se 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:
- No se pueden especificar listas de argumentos de plantilla explícitas al llamar a cualquiera de ellos.
- Ninguno de ellos es visible para la búsqueda dependiente de argumentos.
- Cuando cualquiera de ellos se encuentra mediante búsqueda no calificada normal 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 a copiar |
| r | - | el rango de elementos a copiar |
| result | - | el comienzo del rango de destino. |
| pred | - | predicado a aplicar a los elementos proyectados |
| proj | - | proyección a aplicar a los elementos |
Valor de retorno
Un 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 que el predicado devuelve true, dependiendo del predicado y los datos de entrada).Notas
En la práctica, las implementaciones de ranges::copy evitan múltiples asignaciones y usan funciones de copia por lotes como std::memmove si el tipo de valor es TriviallyCopyable y los tipos de iterador satisfacen contiguous_iterator.
Al copiar rangos superpuestos, ranges::copy es apropiado al copiar hacia la izquierda (el comienzo del rango de destino está fuera del rango de origen) mientras que ranges::copy_backward es apropiado al copiar hacia la derecha (el final del rango de destino está fuera del rango de origen).
Posible implementación
| copy (1)(2) |
|---|
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 (3)(4) |
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 para copiar el contenido de un std::vector a otro y mostrar el std::vector resultante.
Ejecutar 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));
// or, alternatively,
// std::vector<int> destination(source.size());
// std::ranges::copy(source.begin(), source.end(), destination.begin());
// either way is equivalent to
// std::vector<int> destination = source;
std::cout << "Destination contains: ";
std::ranges::copy(destination, std::ostream_iterator<int>(std::cout, " "));
std::cout << '\n';
std::cout << "Odd numbers in destination are: ";
std::ranges::copy_if(destination, std::ostream_iterator<int>(std::cout, " "),
[](int x) { return (x % 2) == 1; });
std::cout << '\n';
}
Salida:
Destination contains: 0 1 2 3 4 5 6 7 8 9
Odd numbers in destination are: 1 3 5 7 9
Véase también
(C++20) |
copia un rango de elementos en orden inverso (objeto función de algoritmo) |
(C++20) |
crea una copia de un rango que está invertido (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) |
asigna un cierto valor a un rango de elementos (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++11) |
copia un rango de elementos a una nueva ubicación (plantilla de función) |