Namespaces
Variants

    std::experimental::ranges:: copy, std::experimental::ranges:: copy_if

    From es.cppreference.net
    C++
    Experimental
    Ranges
    Algorithms library
    Non-modifying sequence operations
    Modifying sequence operations
    Partitioning operations
    Sorting operations
    Binary search operations
    Set operations (on sorted ranges)
    Heap operations
    Minimum/maximum operations
    Permutations
    **Nota:** El texto ya está en inglés y contiene principalmente código C++ y términos técnicos específicos que no deben traducirse según las instrucciones proporcionadas. Los únicos elementos que podrían traducirse son las etiquetas HTML y atributos, pero las instrucciones especifican explícitamente no traducirlos.
    Definido en el encabezado <experimental/ranges/algorithm>
    template < InputIterator I, Sentinel < I > S, WeaklyIncrementable O >

    requires IndirectlyCopyable < I, O >
    ranges:: tagged_pair < tag:: in ( I ) , tag:: out ( O ) >

    copy ( I first, S last, O result ) ;
    		(1) (ranges TS)
    template < InputRange R, WeaklyIncrementable O >

    requires IndirectlyCopyable < ranges:: iterator_t < R > , O >
    ranges:: tagged_pair < tag:: in ( ranges:: safe_iterator_t < R > ) , tag:: out ( O ) >

    copy ( R && r, O result ) ;
    		(2) (ranges TS)
    template < InputIterator I, Sentinel < I > S, WeaklyIncrementable O,

    class Proj = ranges:: identity ,
    IndirectUnaryPredicate < projected < I, Proj >> Pred >
    requires IndirectlyCopyable < I, O >
    ranges:: tagged_pair < tag:: in ( I ) , tag:: out ( O ) >

    copy_if ( I first, S last, O result, Pred pred, Proj proj = Proj { } ) ;
    		(3) (ranges TS)
    template < InputRange R, WeaklyIncrementable O,

    class Proj = ranges:: identity ,
    IndirectUnaryPredicate < projected < ranges:: iterator_t < R > , Proj >> Pred >
    requires IndirectlyCopyable < iterator_t < R > , O >
    ranges:: tagged_pair < tag:: in ( ranges:: safe_iterator_t < R > ) , tag:: out ( O ) >

    copy_if ( R && r, O result, Pred pred, Proj proj = Proj { } ) ;
    		(4) (ranges TS)

    Copia elementos en el rango fuente ( [ first , last ) o r ) hacia el rango destino comenzando en result , iniciando desde el primer elemento en el rango fuente y procediendo hasta el último.

    1) Copia todos los elementos en el rango [ first , last ) . Para cada entero no negativo n < (last - first) , ejecuta * ( result + n ) = * ( first + n ) . El comportamiento es indefinido si result está dentro del rango [ first , last ) . En este caso, puede usarse ranges::copy_backward en su lugar.
    2) Igual que (1) , pero utiliza r como el rango fuente, como si fuera mediante ranges:: copy ( ranges:: begin ( r ) , ranges:: end ( r ) , result ) ; excepto que result podría no ser copiado.
    3) Solo copia los elementos para los cuales el predicado pred devuelve true cuando se aplica al valor del elemento proyectado por la proyección proj . Se preserva el orden de los elementos que son copiados. El comportamiento es indefinido si los rangos de origen y destino se superponen.
    4) Igual que (3) , pero utiliza r como el rango fuente, como si fuera mediante ranges:: copy_if ( ranges:: begin ( r ) , ranges:: end ( r ) , result, pred, proj ) ; excepto que result , pred y proj pueden no ser copiados.

    No obstante las declaraciones representadas anteriormente, el número real y el orden de los parámetros de plantilla para las declaraciones de algoritmos no está especificado. Por lo tanto, si se utilizan argumentos de plantilla explícitos al invocar un algoritmo, el programa probablemente no sea portable.

    Contenido

    Parámetros

    first, last - el rango de elementos a copiar
    r - el rango de elementos a copiar
    result - el inicio del rango de destino
    pred - predicado a aplicar a los elementos proyectados
    proj - proyección a aplicar a los elementos

    Valor de retorno

    Un objeto tagged_pair que contiene los siguientes dos miembros:

    • El primer miembro, con la etiqueta tag::in , es el iterador pasado-el-final del rango fuente (es decir, un iterador de tipo I que compara igual al centinela last ).
    • El segundo miembro, con la etiqueta tag::out , es el iterador pasado-el-final del rango resultado.

    Complejidad

    1) Exactamente ranges:: distance ( first, last ) asignaciones.
    2) Exactamente ranges:: distance ( r ) asignaciones.
    3) Exactamente ranges:: distance ( first, last ) aplicaciones de la proyección y predicado correspondientes.
    4) Exactamente ranges:: distance ( r ) aplicaciones de la proyección y predicado correspondientes.

    Posibles implementaciones

    Primera versión 
    template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O>
    requires IndirectlyCopyable<I, O>()
ranges::tagged_pair<tag::in(I), tag::out(O)>
    copy(I first, S last, O result)
{
    for (; first != last; ++first, (void)++result)
        *result = *first;
    return {first, result};
}
    Segunda versión 
    template<InputRange R, WeaklyIncrementable O>
    requires IndirectlyCopyable<ranges::iterator_t<R>, O>()
ranges::tagged_pair<tag::in(ranges::safe_iterator_t<R>), tag::out(O)>
    copy(R&& r, O result)
{
   return ranges::copy(ranges::begin(r), ranges::end(r), result);
}
    Tercera versión 
    template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O,
         class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<I, Proj>> Pred>
    requires IndirectlyCopyable<I, O>()
ranges::tagged_pair<tag::in(I), tag::out(O)>
    copy_if(I first, S last, O result, Pred pred, Proj proj = Proj{})
{
    for (; first != last; ++first)
        if (ranges::invoke(pred, ranges::invoke(proj, *first)))
        {
            *result = *first;
            ++result;
        }
    return {first, result};
}
    Cuarta versión 
    template<InputRange R, WeaklyIncrementable O,
         class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<ranges::iterator_t<R>, Proj>> Pred>
    requires IndirectlyCopyable<ranges::iterator_t<R>, O>()
ranges::tagged_pair<tag::in(ranges::safe_iterator_t<R>), tag::out(O)>
    copy_if(R&& r, O result, Pred pred, Proj proj = Proj{})
{
    return ranges::copy_if(ranges::begin(r), ranges::end(r), result, pred, proj);
}

    Ejemplo

    El siguiente código utiliza copy para copiar el contenido de un vector a otro y mostrar el vector resultante:

    Ejecutar este código 
    #include <experimental/ranges/algorithm>
#include <experimental/ranges/iterator>
#include <iostream>
#include <numeric>
#include <vector>
int main()
{
    // see https://es.cppreference.net/w/cpp/language/namespace_alias
    namespace ranges = std::experimental::ranges;
    std::vector<int> from_vector(10);
    std::iota(from_vector.begin(), from_vector.end(), 0);
    std::vector<int> to_vector;
    ranges::copy_if(from_vector.begin(), from_vector.end(),
                    ranges::back_inserter(to_vector),
                    [](const auto i)
                    {
                       return i % 3;
                    });
// or, alternatively,
//  std::vector<int> to_vector(from_vector.size());
//  std::copy(from_vector, to_vector.begin());
    std::cout << "to_vector contains: ";
    ranges::copy(to_vector, ranges::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
}

    Salida: 

    to_vector contains: 1 2 4 5 7 8

    Véase también

    (C++11)
    		 copia un rango de elementos a una nueva ubicación
    (plantilla de función & objeto función de algoritmo)
    (C++20)(C++20)
    		copia un rango de elementos en orden inverso
    (plantilla de función)
    		crea una copia de un rango que está invertido
    (plantilla de función)
    		copia un número de elementos a una nueva ubicación
    (plantilla de función)
    		asigna a un rango de elementos un valor determinado
    (plantilla de función)
    		copia un rango de elementos omitiendo aquellos que satisfacen criterios específicos
    (plantilla de función)