C++-Standardbibliothek<numeric>

In der täglichen C++-Entwicklung stoßen wir oft auf die folgenden Anforderungen:

  • Summe / Produkt eines Arrays berechnen
  • Präfixsummen für Bereichsabfragen berechnen
  • Stapelweise akkumulieren, um eine neue Sequenz zu erzeugen
  • Inneres Produkt (Skalarprodukt) zwischen Vektoren berechnen

Wenn du es immer noch von Hand schreibstforSchleife, dann<numeric>Das sind genau die Standardbibliothekswerkzeuge, die du beherrschen solltest.

In der C++-Standardbibliothek<numeric>Die Header-Datei stellt eine Reihe von Funktionsvorlagen für numerische Berechnungen bereit. Diese Funktionen können verschiedene numerische Operationen auf Elemente in einem Container ausführen, wie Summierung, Produkt, Minimum, Maximum usw. Diese Funktionsvorlagen sind extrem leistungsstark und können auf jeden Containertyp angewendet werden, einschließlich Arrays, Vektoren, Listen und so weiter.

Bei Verwendung<numeric>Bevor du die Funktionen in der Header-Datei verwendest, musst du diese Header-Datei in dein C++-Programm einbinden:

#include <numeric>

Häufig verwendete Funktionen

  • <numeric>ist, wie C++ mitnumerischer Sequenzberechnung umgeht.Es ist die zentrale Header-Datei, die sich auf Operationen wie Reduktion, Akkumulation und Differenz konzentriert und mit allen STL-Containern kompatibel ist;
  • Grundlegende Funktionen (accumulate/partial_sum/iotaEs ist der Kern von C++98/11 und erfüllt die meisten herkömmlichen Anforderungen an numerische Berechnungen;
  • neu in C++17 hinzugefügtreduce/inclusive_scanParallele Funktionen wie diese können bei großen Datenmengen die Recheneffizienz erheblich verbessern und müssen mit parallelen Ausführungsrichtlinien verwendet werden.
Funktionsname C++-Version Kernfunktionalität Vereinfachter Funktionsprototyp (mitvector<int>als Beispiel) typische Anwendungsfälle
accumulate C++98 Berechnet die kumulative Summe einer Sequenz (eine benutzerdefinierte binäre Operation kann angegeben werden) int accumulate(iterator beg, iterator end, int init); Array-Summe berechnen, Statistiken akkumulieren
inner_product C++98 Berechnet das innere Produkt zweier Sequenzen (entsprechende Elemente multiplizieren und dann akkumulieren; benutzerdefinierte Operationen können angegeben werden) int inner_product(iter1 b1, iter1 e1, iter2 b2, int init); Vektor-Skalarprodukt, gewichtete Summe
partial_sum C++98 Präfixsummen einer Sequenz berechnen (das n-te Ergebnis = Summe der ersten n Elemente, anpassbare Operation) void partial_sum(iter b, iter e, iter res); Präfixsummen-Array generieren, kumulative Statistiken
adjacent_difference C++98 Differenzen zwischen benachbarten Elementen einer Sequenz berechnen (das n-te Ergebnis = elem[n] - elem[n-1], anpassbare Operation) void adjacent_difference(iter b, iter e, iter res); Differenzen berechnen, Sequenzänderungen erkennen
iota C++11 Füllt eine Sequenz mit kontinuierlich ansteigenden Werten (beginnend bei init, jeweils um 1 erhöht) void iota(iter b, iter e, T init); Erzeugt eine Folge aufeinanderfolgender Ganzzahlen, initialisiert geordnete Container
reduce C++17 Parallele Version von accumulate (ähnlich zu accumulate, unterstützt parallele Ausführung, ungeordnete Reduktion) T reduce(iter b, iter e, T init = T{}); Parallele Summierung für große Datenmengen, verbessert die Recheneffizienz
transform_reduce C++17 Transformation + Reduktion (zuerst die Elemente transformieren, dann akkumulieren, unterstützt parallele Ausführung) T transform_reduce(iter1 b1, iter1 e1, iter2 b2, T init); Paralleles Skalarprodukt, Summe nach der Transformation
inclusive_scan C++17 Parallele Präfixsumme (einschließlich des aktuellen Elements, ähnlich zu partial_sum, unterstützt parallele Ausführung) void inclusive_scan(iter b, iter e, iter res); Parallele Erzeugung von Präfixsummen-Arrays
exclusive_scan C++17 Parallele Version der Präfixsumme (ohne aktuelles Element; das n-te Ergebnis = Summe der ersten n-1 Elemente) void exclusive_scan(iter b, iter e, iter res, T init); Parallele Erzeugung von Präfixsummen, die das aktuelle Element nicht einschließen

1. accumulate

accumulateDie Funktion wird verwendet, um die Summe aller Elemente in einem Container zu berechnen. Sie nimmt drei Parameter entgegen: den begin-Iterator des Containers, den end-Iterator und den Anfangswert.

Syntax:

template <InputIterator Iter, class T>
T accumulate(Iter first, Iter last, T init);

Beispiel:

Beispiel

#include <iostream>
#include <numeric>
#include <vector>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    int sum = std::accumulate(v.begin(), v.end(), 0);
    std::cout << "Summe: " << sum << std::endl; // Ausgabe: Sum: 15
    return 0;
}

2. inner_product

inner_productDie Funktion wird verwendet, um die Summe der Produkte der entsprechenden Elemente in zwei Containern zu berechnen.

Syntax:

template <InputIterator1 Iter1, InputIterator2 Iter2, class T>
T inner_product(Iter1 first1, Iter1 last1, Iter2 first2, T init);

Beispiel:

Beispiel

#include <iostream>
#include <numeric>
#include <vector>

int main() {
    std::vector<int> v1 = {1, 2, 3};
    std::vector<int> v2 = {4, 5, 6};
    int product_sum = std::inner_product(v1.begin(), v1.end(), v2.begin(), 0);
    std::cout << "Product Sum: " << product_sum << std::endl; // Ausgabe: Product Sum: 32
    return 0;
}

3. partial_sum

partial_sumDie Funktion berechnet die Teilsummen der Elemente in einem Container und speichert die Ergebnisse in einem anderen Container.

Syntax:

template <InputIterator InIter, OutputIterator OutIter>
OutIter partial_sum(InIter first, InIter last, OutIter result);

Beispiel:

Beispiel

#include <iostream>
#include <numeric>
#include <vector>

int main() {
    std::vector<int> v = {1, 2, 3, 4};
    std::vector<int> result(v.size());
    std::partial_sum(v.begin(), v.end(), result.begin());
    for (int i : result) {
        std::cout << i << " "; // Ausgabe: 1 3 6 10
    }
    return 0;
}

4. adjacent_difference

adjacent_differenceDie Funktion berechnet die Differenzen zwischen benachbarten Elementen in einem Container und speichert die Ergebnisse in einem anderen Container.

Syntax:

template <InputIterator InIter, OutputIterator OutIter>
OutIter adjacent_difference(InIter first, InIter last, OutIter result);

Beispiel:

Beispiel

#include <iostream>
#include <numeric>
#include <vector>

int main() {
    std::vector<int> v = {1, 2, 3, 4};
    std::vector<int> result(v.size() - 1);
    std::adjacent_difference(v.begin(), v.end(), result.begin());
    for (int i : result) {
        std::cout << i << " "; // Ausgabe: 1 1 1
    }
    return 0;
}

5. std::gcd

Verwenden Sie std::gcd, um den größten gemeinsamen Teiler zweier ganzer Zahlen zu berechnen:

Beispiel

#include <iostream>
#include <numeric>

int main() {
    int a = 48;
    int b = 18;
    int result = std::gcd(a, b);  // Berechne den größten gemeinsamen Teiler von 48 und 18
    std::cout << "ggT: " << result << std::endl;  // Ausgabe 6
    return 0;
}

6. std::lcm

Verwenden Sie std::lcm, um das kleinste gemeinsame Vielfache zweier ganzer Zahlen zu berechnen:

Beispiel

#include <iostream>
#include <numeric>

int main() {
    int a = 48;
    int b = 18;
    int result = std::lcm(a, b);  // Berechne das kleinste gemeinsame Vielfache von 48 und 18
    std::cout << "kgV: " << result << std::endl;  // Ausgabe 144
    return 0;
}

7. std::iota

Beispiel

#include <iostream>
#include <numeric> // Numerische Header-Datei einbinden
#include <vector>

int main() {
    std::vector<int> v(5); // Einen Vektor mit 5 Elementen erstellen

    // Den Vektor mit std::iota füllen, beginnend bei 1
    std::iota(std::begin(v), std::end(v), 1);

    // Den gefüllten Vektor ausgeben
    for (int i : v) {
        std::cout << i << " ";
    }
    std::cout << std::endl; // Ausgabe: 1 2 3 4 5

    return 0;
}

Verwende std::iota, um einen Bereich mit aufeinanderfolgenden Werten zu füllen.

template<class ForwardIt, class T>
void iota(ForwardIt first, ForwardIt last, T value);

8. Maximale und minimale Werte finden

min_elementundmax_elementDie Funktion wird verwendet, um die maximalen und minimalen Werte in einem Container zu finden.

Beispiel

#include <iostream>
#include <numeric>
#include <vector>
#include <algorithm> // Um std::min_element und std::max_element zu verwenden

int main() {
    // Einen Vektor von Ganzzahlen definieren
    std::vector<int> v = {3, 1, 4, 1, 5, 9};

    // Minimale und maximale Werte berechnen
    int min_val = *std::min_element(v.begin(), v.end());
    int max_val = *std::max_element(v.begin(), v.end());

    // Summe berechnen
    int sum_val = std::accumulate(v.begin(), v.end(), 0);

    // Durchschnitt berechnen
    double avg_val = static_cast<double>(sum_val) / v.size();

    // Gib die Ergebnisse aus
    std::cout << "Min: " << min_val << std::endl;
    std::cout << "Max: " << max_val << std::endl;
    std::cout << "Summe: " << sum_val << std::endl;
    std::cout << "Durchschnitt: " << avg_val << std::endl;

    return 0;
}

Das Ausgabeergebnis ist:

Min: 1
Max: 9
Sum: 23
Average: 3.83333
Weitere Erweiterungen