Namespaces
Variants

    std::experimental::ranges:: for_each

    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
    Definido en el encabezado <experimental/ranges/algorithm>
    template < InputIterator I, Sentinel < I > S, class Proj = ranges:: identity ,

    IndirectUnaryInvocable < projected < I, Proj >> Fun >
    ranges:: tagged_pair < tag:: in ( I ) , tag:: fun ( Fun ) >

    for_each ( I first, S last, Fun f, Proj proj = Proj { } ) ;
    		(1) (ranges TS)
    template < InputRange R, class Proj = ranges:: identity ,

    IndirectUnaryInvocable < projected < ranges:: iterator_t < R > , Proj >> Fun >
    ranges:: tagged_pair < tag:: in ( ranges:: safe_iterator_t < R > ) , tag:: fun ( Fun ) >

    for_each ( R && r, Fun f, Proj proj = Proj { } ) ;
    		(2) (ranges TS)
    1) Invoca el objeto de función dado f al resultado de invocar la proyección proj al desreferenciar cada iterador en el rango [ first , last ) (es decir, ranges:: invoke ( f, ranges:: invoke ( proj, * i ) ) ), en orden.
    2) Igual que (1) , pero utiliza r como el rango fuente, como si se usara ranges:: begin ( r ) como first y ranges:: end ( r ) como last .

    Para ambas sobrecargas, si el tipo de iterador es mutable, f puede modificar los elementos del rango a través del iterador desreferenciado. Si f devuelve un resultado, el resultado se ignora.

    A diferencia del resto de los algoritmos, a for_each no se le permite hacer copias de los elementos en la secuencia incluso si son trivialmente copiables.

    A diferencia de std::for_each (que solo requiere MoveConstructible ), estas funciones requieren que Fun cumpla con CopyConstructible .

    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 llamar a un algoritmo, el programa probablemente no sea portable.

    Contenido

    Parámetros

    first, last - el rango al que aplicar la función
    r - el rango al que aplicar la función
    f - objeto invocable que se aplicará a cada elemento proyectado en el rango
    proj - proyección que 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::fun , se inicializa desde std::move(f) (después de todas las aplicaciones del objeto función).

    Complejidad

    Exactamente last - first aplicaciones de f y proj .

    Implementación posible 

    template<InputIterator I, Sentinel<I> S, class Proj = ranges::identity,
         IndirectUnaryInvocable<ranges::projected<I, Proj>> Fun>
auto for_each(I first, S last, Fun f, Proj proj = Proj{}) 
    -> ranges::tagged_pair<tag::in(I), tag::fun(Fun)>
{
    for (; first != last; ++first)
        ranges::invoke(f, ranges::invoke(proj, *first));
    return {std::move(first), std::move(f)};
}

    Ejemplo

    Esta sección está incompleta
    Razón: sin ejemplo

    Véase también

    		 aplica una función a un rango de elementos
    (plantilla de función)
    rango-for bucle(C++11) ejecuta un bucle sobre un rango
    		aplica un objeto función unario a elementos de un rango
    (plantilla de función & objeto función de algoritmo)
    (C++20)
    (C++17)
    		 aplica un objeto función a los primeros N elementos de una secuencia
    (plantilla de función & objeto función de algoritmo)
    (C++20)