std:: accumulate

Calcula la suma del valor dado init y los elementos en el rango [ first , last ) .

Si se satisface cualquiera de las siguientes condiciones, el comportamiento es indefinido:

• T no es CopyConstructible .
• T no es CopyAssignable .
• op modifica cualquier elemento de [ first , last ) .
• op invalida cualquier iterador o subrango en [ first , last ] .

Parámetros

Valor de retorno

acc después de todas las modificaciones.

Implementación posible

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;
}

Notas

std::accumulate realiza un plegado hacia la izquierda. Para realizar un plegado hacia la derecha, se debe invertir el orden de los argumentos al operador binario y utilizar iteradores inversos.

Si se deja a la inferencia de tipos, op opera sobre valores del mismo tipo que init lo cual puede resultar en conversiones no deseadas de los elementos del iterador. Por ejemplo, std :: accumulate ( v. begin ( ) , v. end ( ) , 0 ) probablemente no da el resultado que se desea cuando v es de tipo std:: vector < double > .

Ejemplo

#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]), // comenzar con el primer elemento
                                    dash_fold);
    // Plegado hacia la derecha usando iteradores inversos
    std::string rs = std::accumulate(std::next(v.rbegin()), v.rend(),
                                     std::to_string(v.back()), // comenzar con el último elemento
                                     dash_fold);
    std::cout << "suma: " << sum << '\n'
              << "producto: " << product << '\n'
              << "cadena separada por guiones: " << s << '\n'
              << "cadena separada por guiones (plegado derecho): " << rs << '\n';
}

suma: 55
producto: 3628800
cadena separada por guiones: 1-2-3-4-5-6-7-8-9-10
cadena separada por guiones (plegado derecho): 10-9-8-7-6-5-4-3-2-1

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también