std::accumulate - cppreference.com

Da cppreference.com.

Questa pagina è stata tradotta in modo automatico dalla versione in ineglese della wiki usando Google Translate.

La traduzione potrebbe contenere errori e termini strani. Muovi il puntatore sopra al testo per vedere la versione originale. Puoi aiutarci a correggere gli gli errori. Per ulteriori istruzioni clicca qui.

Click here for the English version of this page

Elemento definito nell'header `<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.

Parametri

first, last	-	l'intervallo di elementi di somma 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`.

Valore di ritorno

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

Possibile implementazione

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

Esempio

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

Output:

Vedi anche


adjacent_difference	calcola le differenze tra elementi adiacenti in un intervallo 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. (funzione di modello) [modifica]

inner_product	calcola il prodotto interno di due gamme di elementi 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. (funzione di modello) [modifica]

partial_sum	calcola la somma parziale di una serie di elementi 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. (funzione di modello) [modifica]