accumulate

Article
03/26/2013

Calcule la somme de tous les éléments dans une plage spécifiée y compris une valeur initiale lors de le calcul des totaux partielles successives ou calcule le résultat des résultats partiels successifs de obtenus d'utiliser une opération binaire spécifiée autre que la somme.

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

Paramètres

_First
Un itérateur d'entrée adressant le premier élément de la plage à additionner ou être combinés en fonction d'une opération binaire spécifiée.
_Last
Un itérateur d'entrée adressant le dernier élément dans la plage à additionner ou être combinés en fonction d'une opération binaire spécifiée qui est une position au delà de le dernier élément a réellement inclus dans l'accumulation itérée.
_Val
Une valeur initiale à laquelle chaque élément est ensuite ajouté ou combiné avec selon une opération binaire spécifiée.
_Binary_op
L'opération binaire qui doit être appliquée à chaque élément de la plage spécifiée et le résultat de ses applications précédentes.

Valeur de retour

La somme d' _Val et tous les éléments dans la plage spécifiée pour la première fonction de modèle, ou, pour la deuxième fonction de modèle, le résultat d'appliquer l'opération binaire spécifiée, au lieu de l'exécution de somme, la valeur (PartialResult, *Iter), où PartialResult est le résultat des applications précédentes de l'exécution et d' Iter est un itérateur qui désigne un élément dans la plage.

Notes

La valeur initiale assurer qu'il y aura un résultat bien défini lorsque la plage est vide, dans ce cas _Val est retourné.L'opération binaire n'a pas besoin d'être associative ou commutative.Le résultat est initialisé avec la valeur initiale _Val puis le résultat = l' _Binary_op (résultat, *****Iter) est calculé de manière itérative via la plage, où Iter est un itérateur qui pointe vers l'élément consécutif dans l'intervalle.L'intervalle doit être valide et la complexité est linéaire à la taille de la plage.Le type de retour de l'opérateur binaire doit être convertible à Type pour garantir la fermeture pendant l'itération.

Exemple

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

Configuration requise

en-tête : <numeric>

l'espace de noms : DST

Voir aussi

Référence

accumulate, copy, et vector::push_back

Modèles Standard

Partager via