accumulate

Articolo
03/26/2013

Calcola la somma di tutti gli elementi in un intervallo specificato con il valore iniziale calcolando di somme parziali successive o calcola il risultato dei risultati parziali successivi analogamente ottenuti da tramite un'operazione binaria specificato dalla somma.

template<class InputIterator, class Type>
   Type accumulate(
      InputIterator _First, 
      InputIterator _Last, 
      Type _Val
   );
template<class InputIterator, class Type, class BinaryOperation>
   Type accumulate(
      InputIterator _First, 
      InputIterator _Last, 
      Type _Val, 
      BinaryOperation _Binary_op
   );

Parametri

_First
Un iteratore di input destinato al primo elemento nell'intervallo da sommare o combinare come un'operazione binaria specificata.
_Last
Un iteratore di input destinato all'ultimo elemento nell'intervallo da sommare o combinare come un'operazione binaria specificata è una posizione oltre l'elemento finale realtà incluso nella compilazione ripetuta.
_Val
Un valore iniziale a cui ogni elemento a sua volta che si aggiunge o si combina con come un'operazione binaria specificata.
_Binary_op
Un'operazione binaria che deve essere applicato a ogni elemento dell'intervallo specificato e nei risultati delle applicazioni precedenti.

Valore restituito

La somma _Val e tutti gli elementi dell'intervallo specificato per la prima funzione di modello, o, per la seconda funzione di modello, il risultato dell'applicazione di un'operazione binaria specificata, anziché operazione di somma, a (PartialResult, *Iter), dove PartialResult è il risultato delle applicazioni precedenti dell'operazione e Iter è un iteratore che punta a un elemento nell'intervallo.

Note

Il valore iniziale garantisce che sia presente un risultato ben definito se l'intervallo è vuoto, nel qual caso _Val viene restituito.Un'operazione binaria non deve essere associativa o commutativa.Il risultato viene inizializzato sul valore iniziale _Val quindi il risultato = _Binary_op (risultato, *****Iter) viene calcolato in modo iterativo nell', in cui Iter è un iteratore che punta all'elemento successivo nell'intervallo.L'intervallo deve essere valido e complessità è lineare con la dimensione dell'intervallo.Il tipo restituito dell'operatore binario deve essere convertibile in Tipo garantire la chiusura durante un'iterazione.

Esempio

// numeric_accum.cpp
// compile with: /EHsc
#include <vector>
#include <numeric>
#include <functional>
#include <iostream>

int main( )
{
   using namespace std;

   vector <int> v1, v2(20);
   vector <int>::iterator iter1, iter2;

   int i;
   for (i = 1; i < 21; i++)
   {
      v1.push_back(i);
   }

   cout << "The original vector v1 is:\n ( " ;
   for (iter1 = v1.begin(); iter1 != v1.end(); iter1++)
      cout << *iter1 << " ";
   cout << ")." << endl;

   // The first member function for the accumulated sum
   int total;
   total = accumulate(v1.begin(), v1.end(), 0);

   cout << "The sum of the integers from 1 to 20 is: "
        << total << "." << endl;

   // Constructing a vector of partial sums
   int j = 0, partotal;
   for (iter1 = v1.begin(); iter1 != v1.end(); iter1++)
   {
      partotal = accumulate(v1.begin(), iter1 + 1, 0);
      v2[j] = partotal;
      j++;
   }

   cout << "The vector of partial sums is:\n ( " ;
   for (iter2 = v2.begin(); iter2 != v2.end(); iter2++)
      cout << *iter2 << " ";
   cout << ")." << endl << endl;

   // The second member function for the accumulated product
   vector <int> v3, v4(10);
   vector <int>::iterator iter3, iter4;

   int s;
   for (s = 1; s < 11; s++)
   {
      v3.push_back(s);
   }

   cout << "The original vector v3 is:\n ( " ;
   for (iter3 = v3.begin(); iter3 != v3.end(); iter3++)
      cout << *iter3 << " ";
   cout << ")." << endl;

   int ptotal;
   ptotal = accumulate(v3.begin(), v3.end(), 1, multiplies<int>());

   cout << "The product of the integers from 1 to 10 is: "
        << ptotal << "." << endl;

   // Constructing a vector of partial products
   int k = 0, ppartotal;
   for (iter3 = v3.begin(); iter3 != v3.end(); iter3++) {
      ppartotal = accumulate(v3.begin(), iter3 + 1, 1, multiplies<int>());
      v4[k] = ppartotal;
      k++;
   }

   cout << "The vector of partial products is:\n ( " ;
   for (iter4 = v4.begin(); iter4 != v4.end(); iter4++)
      cout << *iter4 << " ";
   cout << ")." << endl;
}

Requisiti

intestazione: <numeric>

Spazio dei nomi: deviazione standard

Vedere anche

Riferimenti

accumulate, copy, e vector::push_back

Libreria di modelli standard

Condividi tramite