std:: accumulate

Berechnet die Summe des gegebenen Wertes init und der Elemente im Bereich [ first , last ) .

Wenn eine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert:

• T ist nicht CopyConstructible .
• T ist nicht CopyAssignable .
• op modifiziert irgendein Element in [ first , last ) .
• op invalidiert irgendeinen Iterator oder Teilbereich in [ first , last ] .

Parameter

Rückgabewert

acc nach allen Änderungen.

Mögliche Implementierung

template<class InputIt, class T>
constexpr // since C++20
T accumulate(InputIt first, InputIt last, T init)
{
    for (; first != last; ++first)
        init = std::move(init) + *first; // std::move since C++20
    return init;
}

template<class InputIt, class T, class BinaryOperation>
constexpr // since C++20
T accumulate(InputIt first, InputIt last, T init, BinaryOperation op)
{
    for (; first != last; ++first)
        init = op(std::move(init), *first); // std::move since C++20
    return init;
}

`-Tags (C++-Code) wurde gemäß den Anforderungen nicht übersetzt. Die Funktionsnamen und C++-spezifischen Begriffe wie "template", "constexpr", "InputIt" etc. bleiben unverändert.*

Hinweise

std::accumulate führt eine Linksfaltung durch. Um eine Rechtsfaltung durchzuführen, muss die Reihenfolge der Argumente für den binären Operator umgekehrt werden und reverse Iteratoren verwendet werden.

Wenn der Typinferenz überlassen, op operiert auf Werten desselben Typs wie init , was zu unerwünschten Typumwandlungen der Iteratorelemente führen kann. Zum Beispiel, std :: accumulate ( v. begin ( ) , v. end ( ) , 0 ) liefert wahrscheinlich nicht das gewünschte Ergebnis, wenn v vom Typ std:: vector < double > ist.

Beispiel

#include <functional>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
int main()
{
    std::vector<int> v{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int sum = std::accumulate(v.begin(), v.end(), 0);
    int product = std::accumulate(v.begin(), v.end(), 1, std::multiplies<int>());
    auto dash_fold = [](std::string a, int b)
    {
        return std::move(a) + '-' + std::to_string(b);
    };
    std::string s = std::accumulate(std::next(v.begin()), v.end(),
                                    std::to_string(v[0]), // beginne mit erstem Element
                                    dash_fold);
    // Rechtsfaltung mit Reverse-Iteratoren
    std::string rs = std::accumulate(std::next(v.rbegin()), v.rend(),
                                     std::to_string(v.back()), // beginne mit letztem Element
                                     dash_fold);
    std::cout << "sum: " << sum << '\n'
              << "product: " << product << '\n'
              << "dash-separated string: " << s << '\n'
              << "dash-separated string (right-folded): " << rs << '\n';
}

sum: 55
product: 3628800
dash-separated string: 1-2-3-4-5-6-7-8-9-10
dash-separated string (right-folded): 10-9-8-7-6-5-4-3-2-1

Fehlerberichte

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

Siehe auch