std::accumulate - cppreference.com

De cppreference.com

Definido no cabeçalho `<numeric>`

`template< class InputIt, class T > T accumulate( InputIt first, InputIt last, T init );`	(1)

`template< class InputIt, class T, class BinaryOperation > T accumulate( InputIt first, InputIt last, T init, BinaryOperation op );`	(2)

Computes the sum of the given value init and the elements in the range [first, last). The first version uses operator+ to sum up the elements, the second version uses the given binary function op.

Parâmetros

first, last	-	a gama de elementos a soma Original: the range of elements to sum The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
init	-	initial value of the sum
op	-	binary operation function object that will be applied. The signature of the function should be equivalent to the following: `Ret fun(const Type1 &a, const Type2 &b);` The signature does not need to have `const &`. The type `Type1` must be such that an object of type `T` can be implicitly converted to `Type1`. The type `Type2` must be such that an object of type `InputIt` can be dereferenced and then implicitly converted to `Type2`. The type `Ret` must be such that an object of type `T` can be assigned a value of type `Ret`.
Type requirements
-`InputIt` must meet the requirements of `InputIterator`.
-`T` must meet the requirements of `CopyAssignable` and `CopyConstructible`.

Valor de retorno

The sum of the given value and elements in the given range.

Possível implementação

First version
template<class InputIt, class T> T accumulate(InputIt first, InputIt last, T value) { for (; first != last; ++first) { value = value + *first; } return value; }
Second version
template<class InputIt, class T, class BinaryOperation> T accumulate(InputIt first, InputIt last, T value, BinaryOperation op) { for (; first != last; ++first) { value = op(value, *first); } return value; }

First version

template<class InputIt, class T>
T accumulate(InputIt first, InputIt last, T value)
{
    for (; first != last; ++first) {
        value = value + *first;
    }
    return value;
}

Second version

template<class InputIt, class T, class BinaryOperation>
T accumulate(InputIt first, InputIt last, T value, 
             BinaryOperation op)
{
    for (; first != last; ++first) {
        value = op(value, *first);
    }
    return value;
}

Exemplo

#include <iostream>
#include <vector>
#include <numeric>
#include <string>
 
int multiply(int x, int y)
{
    return x*y;
}
 
std::string magic_function(std::string res, int x)
{
    return res += (x > 5) ? "b" : "s";
}
 
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, multiply);
    std::string magic = std::accumulate(v.begin(), v.end(), std::string(), 
                                        magic_function);
 
    std::cout << sum << '\n'
              << product << '\n'
              << magic << '\n';
}

Saída:

Veja também


adjacent_difference	calcula as diferenças entre elementos adjacentes em forma de intervalo Original: computes the differences between adjacent elements in a range The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (modelo de função) [edit]

inner_product	calcula o produto interno de duas gamas de elementos Original: computes the inner product of two ranges of elements The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (modelo de função) [edit]

partial_sum	calcula a soma parcial de um conjunto de elementos Original: computes the partial sum of a range of elements The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (modelo de função) [edit]