Namespaces
Variants

std::experimental::ranges:: for_each

From 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.

Table des matières

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)
boucle for sur plage (C++11) exécute une boucle sur une plage
applique un objet fonction unaire aux éléments d'une plage
(modèle de fonction)
(C++17)
applique un objet fonction aux N premiers éléments d'une séquence
(modèle de fonction)