Namespaces
Variants

std::for_each_n

Von de.cppreference.net
 
 
Algorithmenbibliothek
Eingeschränkte Algorithmen und Algorithmen auf Bereichen (C++20)
Eingeschränkte Algorithmen, z. B. ranges::copy, ranges::sort, ...
Nicht modifizierende Sequenzoperationen    
Batch-Operationen
(C++17)
Suchoperationen
Modifizierende Sequenzoperationen
Kopieroperationen
(C++11)
(C++11)
Tauschoperationen
Transformationsoperationen
Erzeugungsoperationen
Entfernungsoperationen
Reihenfolgeändernde Operationen
(bis C++17)(C++11)
(C++20)(C++20)
Stichprobenoperationen
(C++17)

Sortier- und verwandte Operationen
Partitionierungsoperationen
(C++11)    

Sortieroperationen
Binäre Suchoperationen
(auf partitionierten Bereichen)
Mengenoperationen (auf sortierten Bereichen)
Mischoperationen (auf sortierten Bereichen)
Heap-Operationen
Minimum-/Maximumoperationen
(C++11)
(C++17)
Lexikografische Vergleichsoperationen
Permutationsoperationen


 
Definiert in Header <algorithm>
template< class InputIt, class Size, class UnaryFunc >
InputIt for_each_n( InputIt first, Size count, UnaryFunc f );
(1) (constexpr seit C++20)
template< class ExecutionPolicy,
          class ForwardIt, class Size, class UnaryFunc >
ForwardIt for_each_n( ExecutionPolicy&& policy,
                      ForwardIt first, Size count, UnaryFunc f );
(2) (seit C++17)

Wendet das gegebene aufrufbare Objekt f auf jedes Element im Zielbereich [first, std::next(first, count)) an. Falls f ein Ergebnis zurückgibt, wird das Ergebnis ignoriert.

1) f wird in der Reihenfolge ab first angewendet.
Falls UnaryFunc nicht MoveConstructible ist, ist das Verhalten undefiniert.
2) f wird möglicherweise nicht in der Reihenfolge angewendet. Der Algorithmus wird gemäß policy ausgeführt.
Im Gegensatz zu anderen parallelen Algorithmen darf for_each_n keine beliebigen Kopien von Elementen aus dem Zielbereich erstellen.
Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn der Wert des folgenden Ausdrucks true ist:

std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>

(bis C++20)

std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>

(seit C++20)
Falls UnaryFunc nicht CopyConstructible ist, ist das Verhalten undefiniert.

Falls count >= 0 nicht true ist, ist das Verhalten undefiniert.

Parameter

first - der Anfang des Zielbereichs
count - die Anzahl der Elemente im Zielbereich
f - Funktionsobjekt, das auf die Elemente angewendet werden soll

Die Signatur der Funktion sollte der folgenden entsprechen:

void fun(const Type &a);

Die Signatur muss kein const & besitzen.
Der Typ Type muss so sein, dass ein Objekt vom Typ InputIt dereferenziert und dann implizit in Type konvertiert werden kann.

policy - die Ausführungsrichtlinie, die verwendet werden soll
Typanforderungen
-
InputIt muss die Anforderungen von LegacyInputIterator erfüllen.
-
ForwardIt muss die Anforderungen von LegacyForwardIterator erfüllen.
-
Size muss in einen ganzzahligen Typ konvertierbar sein.

Rückgabewert

std::next(first, count)

Komplexität

Genau count Anwendungen von f.

Ausnahmen

2) Während des Ausführungsprozesses:
  • Wenn die für die Parallelisierung erforderlichen temporären Speicherressourcen nicht verfügbar sind, wird std::bad_alloc ausgelöst.
  • Wenn beim Zugriff auf Objekte über ein Algorithmusargument eine nicht abgefangene Ausnahme ausgelöst wird, wird das Verhalten durch die Ausführungsrichtlinie bestimmt (für Standardrichtlinien wird std::terminate aufgerufen).

Hinweise

Wenn der Iteratortyp (InputIt/ForwardIt) änderbar ist, kann f die Elemente im Zielbereich modifizieren.

Mögliche Implementierung

Siehe auch die Implementierung in libstdc++, libc++ und MSVC stdlib.

template<class InputIt, class Size, class UnaryFunc>
InputIt for_each_n(InputIt first, Size count, UnaryFunc f)
{
    for (Size i = 0; i < count; ++first, (void) ++i)
        f(*first);
    
    return first;
}

Beispiel

#include <algorithm>
#include <iostream>
#include <vector>

void println(const auto& v)
{
    for (auto count{v.size()}; const auto& e : v)
        std::cout << e << (--count ? ", " : "\n");
}

int main()
{
    std::vector<int> vi{1, 2, 3, 4, 5};
    println(vi);
    
    std::for_each_n(vi.begin(), 3, [](auto& n) { n *= 2; });
    println(vi);
}

Ausgabe:

1, 2, 3, 4, 5
2, 4, 6, 4, 5

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 3213
(P1718R2)
C++17 Size war nicht erforderlich, in einen ganzzahligen Typ konvertierbar zu sein erforderlich

Siehe auch

wendet ein Funktionsobjekt auf die ersten N Elemente einer Sequenz an
(Algorithmus-Funktionsobjekt)
wendet ein unäres Funktionsobjekt auf Elemente eines Bereichs
an(Funktionstemplate & Algorithmus-Funktionsobjekt)
wendet eine Funktion auf einen Bereich von Elementen an und speichert die Ergebnisse in einem Zielbereich
(Funktionstemplate & Algorithmus-Funktionsobjekt)
bereichsbasiertefor for-Schleife(C++11) führt eine Schleife über einen Bereich aus