Namespaces
Variants

    std::experimental::ranges:: for_each

    From fr.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
    Défini dans l'en-tête <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) Invoque l'objet fonction donné f sur le résultat de l'invocation de la projection proj lors du déréférencement de chaque itérateur dans la plage [ first , last ) (c'est-à-dire, ranges:: invoke ( f, ranges:: invoke ( proj, * i ) ) ), dans l'ordre.
    2) Identique à (1) , mais utilise r comme plage source, comme si on utilisait ranges:: begin ( r ) comme first et ranges:: end ( r ) comme last .

    Pour les deux surcharges, si le type d'itérateur est mutable, f peut modifier les éléments de la plage via l'itérateur déréférencé. Si f retourne un résultat, ce résultat est ignoré.

    Contrairement aux autres algorithmes, for_each n'est pas autorisé à effectuer des copies des éléments de la séquence, même s'ils sont trivialement copiables.

    Contrairement à std::for_each (qui nécessite seulement MoveConstructible ), ces fonctions exigent que Fun modélise CopyConstructible .

    Nonobstant les déclarations dépeintes ci-dessus, le nombre réel et l'ordre des paramètres de template pour les déclarations d'algorithmes ne sont pas spécifiés. Ainsi, si des arguments de template explicites sont utilisés lors de l'appel d'un algorithme, le programme est probablement non portable.

    Contenu

    Paramètres

    first, last - la plage sur laquelle appliquer la fonction
    r - la plage sur laquelle appliquer la fonction
    f - objet appelable à appliquer à chaque élément projeté dans la plage
    proj - projection à appliquer aux éléments

    Valeur de retour

    Un objet tagged_pair contenant les deux membres suivants :

    • Le premier membre, avec l'étiquette tag::in , est l'itérateur de fin de la plage source (c'est-à-dire un itérateur de type I qui compare égal au sentinel last ).
    • Le deuxième membre, avec l'étiquette tag::fun , est initialisé à partir de std::move(f) (après toutes les applications de l'objet fonction).

    Complexité

    Exactement last - first applications de f et proj .

    Implémentation possible 

    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)};
}

    Exemple

    Cette section est incomplète
    Raison : aucun exemple

    Voir aussi

    		 applique une fonction à une plage d'éléments
    (modèle de fonction)
    plage-for boucle(C++11) exécute une boucle sur une plage
    		applique un objet fonction aux éléments d'une plage
    (modèle de fonction & objet fonction d'algorithme)
    (C++20)
    (C++17)
    		 applique un objet fonction aux N premiers éléments d'une séquence
    (modèle de fonction & objet fonction d'algorithme)
    (C++20)