std::ranges::copy, std::ranges::copy_if, std::ranges::copy_result, std::ranges::copy_if_result - cppreference.com

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

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

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;

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

#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';
}

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