std::ranges::for_each_n, std::ranges::for_each_n_result
Von cppreference.com
| Definiert in Header <algorithm> |
||
| Aufruf-Signatur |
||
| template< std::input_iterator I, class Proj = std::identity, std::indirectly_unary_invocable<std::projected<I, Proj>> Fun > |
(1) | (seit C++20) |
| Hilfstypen |
||
| template< class I, class F > using for_each_n_result = ranges::in_fun_result<I, F>; |
(2) | (seit C++20) |
1) Wendet das gegebene Funktionsobjekt f auf das projizierte Ergebnis durch proj des Dereferenzierens jedes Iterators im Bereich
[first, first + n) in Reihenfolge an.Wenn der Iteratortyp veränderlich ist, kann f die Elemente des Bereichs über den dereferenzierten Iterator modifizieren. Wenn f ein Ergebnis zurückgibt, wird das Ergebnis ignoriert. Wenn n kleiner als null ist, ist das Verhalten undefiniert.
Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithmus-Funktionsobjekte (informell als niebloids bekannt), d.h.
- Können explizite Template-Argumentlisten bei keinem von ihnen angegeben werden.
- Keiner von ihnen ist für Argument-abhängige Suche sichtbar.
- Wenn einer von ihnen durch normale unqualifizierte Suche als Name links vom Funktionsaufrufoperator gefunden wird, wird die Argument-abhängige Suche unterdrückt.
Inhalt |
[edit] Parameter
| first | - | Iterator, der den Anfang des Bereichs bezeichnet, auf den die Funktion angewendet werden soll. |
| n | - | Die Anzahl der Elemente, auf die die Funktion angewendet werden soll. |
| f | - | Die Funktion, die auf den projizierten Bereich angewendet werden soll [first, first + n). |
| proj | - | Projektion, die auf die Elemente angewendet wird |
[edit] Rückgabewert
Ein Objekt {first + n, std::move(f)}, wobei first + n je nach Iteratorkategorie als std::ranges::next(std::move(first), n) ausgewertet werden kann.
[edit] Komplexität
Genau n Anwendungen von f und proj.
[edit] Mögliche Implementierung
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> n, Fun fun, Proj proj = Proj{}) const { for (; n-- > 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 {};
[edit] Beispiel
Führen Sie diesen Code aus
#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, auto const& 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); }
Ausgabe
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'}[edit] Siehe auch
Bereichs-for-Schleife(C++11) |
führt Schleife über einen Bereich aus |
| (C++20) |
wendet ein unäres Funktionsobjekt auf Elemente aus einem Bereich an (Algorithmus-Funktionsobjekt) |
| (C++17) |
Wendet ein Funktionsobjekt auf die ersten N Elemente einer Sequenz an (Funktionstempelat) |
| wendet ein unäres Funktionsobjekt auf Elemente aus einem Bereich an (Funktion-Template) |
