C++ Academy · Lektion

Numerische Algorithmen: accumulate, reduce, transform_reduce

Aggregieren Sie numerische Bereiche mit accumulate, reduce und dem parallelisierungsfreundlichen transform_reduce.

Numerische Algorithmen: accumulate, reduce, transform_reduce ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Der <numeric>-Header

Numerische Algorithmen arbeiten mit Bereichen von Zahlen. Sie befinden sich in <numeric>.

std::accumulate

Die klassische Reduktion. Summiert standardmäßig – übergeben Sie eine benutzerdefinierte binäre Operation für andere Reduktionen.

#include <numeric>
std::vector<int> v = {1, 2, 3, 4, 5};
int sum = std::accumulate(v.begin(), v.end(), 0);
// sum = 15

Benutzerdefinierte Reduktion

Geben Sie einen Anfangswert und eine binäre Operation an.

int product = std::accumulate(v.begin(), v.end(), 1,
    std::multiplies<int>{});
// product = 120

Der Typ des Anfangswerts ist wichtig

Der Typ des Akkumulators wird aus dem Anfangswert abgeleitet. Geben Sie 0.0 an, um Werte vom Typ double in einem double zu akkumulieren.

std::vector<double> v = {1.5, 2.5, 3.5};
double sum_d = std::accumulate(v.begin(), v.end(), 0.0);    // 7.5
int    sum_i = std::accumulate(v.begin(), v.end(), 0);      // truncates to 6

std::reduce (C++17)

Wie accumulate, aber die Operation muss assoziativ und kommutativ sein – dadurch ist eine parallele Auswertung möglich.

#include <numeric>
#include <execution>
std::vector<int> v(1000);
int sum = std::reduce(std::execution::par,
    v.begin(), v.end(), 0);

reduce vs accumulate

Zwei Unterschiede:

reduce kann parallel ausgeführt werden
reduce garantiert keine Reihenfolge der Operationen – das ist für + und * unproblematisch, funktioniert aber bei nichtassoziativen Operationen wie der Stringverkettung nicht

std::transform_reduce (C++17)

Kombiniert eine Transformation und eine Reduktion in einem Durchlauf. Schneller und ausdrucksstärker als ein separates transform plus reduce.

// Dot product
std::vector<int> a = {1, 2, 3}, b = {4, 5, 6};
int dot = std::transform_reduce(
    a.begin(), a.end(), b.begin(),
    0,
    std::plus<int>{},          // reduce
    std::multiplies<int>{}     // transform
);
// dot = 1*4 + 2*5 + 3*6 = 32

std::inner_product

Der ältere Verwandte von transform_reduce. Berechnet das innere Produkt (Skalarprodukt) zweier Bereiche. Weniger allgemein, aber mit einer einfacheren API.

std::partial_sum

Schreibt laufende Summen in einen Ausgabebereich.

std::vector<int> v = {1, 2, 3, 4};
std::vector<int> sums(4);
std::partial_sum(v.begin(), v.end(), sums.begin());
// sums = {1, 3, 6, 10}

std::adjacent_difference

Das Gegenstück zu partial_sum – schreibt die Differenzen zwischen aufeinanderfolgenden Elementen.

std::vector<int> v = {1, 3, 6, 10};
std::vector<int> diffs(4);
std::adjacent_difference(v.begin(), v.end(), diffs.begin());
// diffs = {1, 2, 3, 4}

Besonderheit bei Gleitkommazahlen

Bei Gleitkommazahlen ist die Reihenfolge der Akkumulation wegen der Rundung wichtig. reduce kann aufgrund seiner nicht festgelegten Auswertungsreihenfolge leicht andere Ergebnisse als accumulate liefern.

Praxisanwendungen

Numerische Algorithmen bilden die Grundlage für:

Summen- und Produktberechnungen
Statistische Aggregationen (Mittelwert, Varianz)
Skalarprodukte und Normen in der linearen Algebra
Kumulative Summen für Präfixabfragen

Schnelltest

Welcher C++17-Algorithmus führt mit einem einzigen Funktionsaufruf eine parallele Reduktion eines Bereichs durch?

Zusammenfassung

<numeric> stellt accumulate, reduce, transform_reduce, partial_sum und adjacent_difference für numerische Reduktionen und Präfixoperationen bereit. Wählen Sie reduce für Parallelität und accumulate für eine deterministische Reihenfolge.

Häufig gestellte Fragen

Ist die Lektion „Numerische Algorithmen: accumulate, reduce, transform_reduce“ kostenlos?

Ja — der vollständige Text von „Numerische Algorithmen: accumulate, reduce, transform_reduce“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Numerische Algorithmen: accumulate, reduce, transform_reduce“?

Aggregieren Sie numerische Bereiche mit accumulate, reduce und dem parallelisierungsfreundlichen transform_reduce. Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C++ Academy zu starten?

Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Numerische Algorithmen: accumulate, reduce, transform_reduce“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?

Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Nicht verändernde Algorithmen: find, count, all_of
Verändernde Algorithmen: transform, copy_if, replace
Sortieren und Partitionieren: sort, stable_partition
Numerische Algorithmen: accumulate, reduce, transform_reduce

← Zurück zu C++ Academy