std::ranges::copy, std::ranges::copy_if, std::ranges::copy_result, std::ranges::copy_if_result

De cppreference.com

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.

Contenido

[editar] 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.

[editar] 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.

[editar] 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).

[editar] 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).

[editar] 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;

[editar] 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

[editar] Véase también

ranges::copy_backward (C++20)	Copia un rango de elementos en orden inverso. (niebloid) [editar]
ranges::reverse_copy (C++20)	Crea una copia de un rango que está invertido. (niebloid) [editar]
ranges::copy_n (C++20)	Copia un número de elementos a una nueva ubicación. (niebloid) [editar]
ranges::fill (C++20)	Asigna un cierto valor a un rango de elementos. (niebloid) [editar]
ranges::remove_copyranges::remove_copy_if (C++20)(C++20)	Copia un rango de elementos, omitiendo aquellos que satisfacen un criterio específico (niebloid) [editar]
copycopy_if (C++11)	Copia un rango de elementos a una nueva ubicación. (plantilla de función) [editar]

Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/algorithm/ranges/copy&oldid=43513»

Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas

cppreference.com

Espacios de nombres

Variantes

Vistas

Acciones