std::ranges::for_each_n, std::ranges::for_each_n_result
Depuis fr.cppreference.net
| Défini dans l'en-tête <algorithm>
|
||
| Signature d'appel |
||
template< std::input_iterator I, class Proj = std::identity,
std::indirectly_unary_invocable<std::projected<I, Proj>> Fun >
constexpr for_each_n_result<I, Fun>
for_each_n( I first, std::iter_difference_t<I> count,
Fun f, Proj proj = {} );
|
(1) | (depuis C++20) |
template< /*execution-policy*/ Ep,
std::random_access_iterator I, class Proj = identity,
std::indirectly_unary_invocable<std::projected<I, Proj>> Fun >
I for_each_n( Ep&& policy, I first, iter_difference_t<I> count,
Fun f, Proj proj = {} );
|
(2) | (depuis C++26) |
| Types auxiliaires |
||
template< class I, class F >
using for_each_n_result = ranges::in_fun_result<I, F>;
|
(3) | (depuis C++20) |
Pour la définition de /*execution-policy*/, voir cette page.
Applique l'objet invocable donné f à chaque élément (projeté par proj) dans l'intervalle cible [first, ranges::next(first, count)). Si f renvoie un résultat, le résultat est ignoré.
1)
f est appliqué dans l'ordre de first.2)
f peut ne pas être appliqué dans l'ordre. L'algorithme est exécuté selon policy. Contrairement aux autres algorithmes parallèles,
for_each_n n'est pas autorisé à faire des copies arbitraires d'éléments de l'intervalle cible.Si count >= 0 n'est pas true, le comportement est indéfini.
Les entités de type fonction décrites sur cette page sont objets fonction d'algorithme (informellement appelés niebloids), c'est-à-dire :
- Les listes d'arguments de modèle explicites ne peuvent pas être spécifiées lors de l'appel de l'un d'eux.
- Aucun d'eux n'est visible par recherche dépendante des arguments.
- Lorsque l'un d'eux est trouvé par recherche non qualifiée normale comme le nom à gauche de l'opérateur d'appel de fonction, recherche dépendante des arguments est inhibée.
Paramètres
| first | - | le début de la plage cible |
| count | - | le nombre d'éléments dans la plage cible |
| f | - | l'objet invocable à appliquer aux éléments (projetés) |
| proj | - | la projection à appliquer aux éléments |
| policy | - | la politique d'exécution à utiliser |
Valeur de retour
1)
{ranges::next(first, count), std::move(f)}2)
ranges::next(first, count)Complexité
Exactement count applications de f et proj.
Exceptions
2) Pendant le processus d'exécution :
- Si les ressources mémoire temporaires nécessaires à la parallélisation ne sont pas disponibles, std::bad_alloc est levée.
- Si une exception non capturée est levée lors de l'accès aux objets via un argument d'algorithme, le comportement est déterminé par la politique d'exécution (pour politiques standard, std::terminate est invoqué).
Notes
Si la projection retourne une référence mutable, f peut modifier les éléments dans la plage cible.
Implémentation possible
struct for_each_n_fn
{
template<std::input_iterator I, class Proj = std::identity,
std::indirectly_unary_invocable<std::projected<I, Proj>> Fun>
constexpr for_each_n_result<I, Fun>
operator()(I first, std::iter_difference_t<I> count,
Fun fun, Proj proj = Proj{}) const
{
for (; count-- > 0; ++first)
std::invoke(fun, std::invoke(proj, *first));
return {std::move(first), std::move(fun)};
}
};
inline constexpr for_each_n_fn for_each_n{};
Exemple
Exécutez ce code
#include <algorithm>
#include <array>
#include <iostream>
#include <ranges>
#include <string_view>
struct P
{
int first;
char second;
friend std::ostream& operator<<(std::ostream& os, const P& p)
{
return os << '{' << p.first << ",'" << p.second << "'}";
}
};
auto print = [](std::string_view name, const auto& v)
{
std::cout << name << ": ";
for (auto n = v.size(); const auto& e : v)
std::cout << e << (--n ? ", " : "\n");
};
int main()
{
std::array a {1, 2, 3, 4, 5};
print("a", a);
// Negate first three numbers:
std::ranges::for_each_n(a.begin(), 3, [](auto& n) { n *= -1; });
print("a", a);
std::array s { P{1,'a'}, P{2, 'b'}, P{3, 'c'}, P{4, 'd'} };
print("s", s);
// Negate data members “P::first” using projection:
std::ranges::for_each_n(s.begin(), 2, [](auto& x) { x *= -1; }, &P::first);
print("s", s);
// Capitalize data members “P::second” using projection:
std::ranges::for_each_n(s.begin(), 3, [](auto& c) { c -= 'a' - 'A'; }, &P::second);
print("s", s);
}
Sortie :
a: 1, 2, 3, 4, 5
a: -1, -2, -3, 4, 5
s: {1,'a'}, {2,'b'}, {3,'c'}, {4,'d'}
s: {-1,'a'}, {-2,'b'}, {3,'c'}, {4,'d'}
s: {-1,'A'}, {-2,'B'}, {3,'C'}, {4,'d'}
Voir aussi
(C++17) |
applique un objet fonction aux N premiers éléments d'une séquence (modèle de fonction) |
| applique unobjet fonction unaireaux éléments d'uneplage (modèle de fonction&objet fonction d'algorithme) | |
(C++20) |
|
boucleforfor par plage(C++11)
|
exécute une boucle sur une plage |