accumulate

Artikel
07/13/2016

Veröffentlicht: Juli 2016

Berechnet die Summe aller Elemente in einem angegebenen Gültigkeitsbereich einschließlich einige Anfangswert, indem das Ableiten von aufeinander folgenden partiellen Summen oder berechnet das Ergebnis aufeinander folgender partiellen Ergebnisse, die ähnlich mit einer angegebenen binäre Operation als die Summe erreicht werden.

Syntax

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

Parameter

_First
Ein Eingabeiterator, der das erste Element im entsprechend einer angegebenen binäre Operation zählt werden oder kombiniert wurde Bereich, behandelt.
_Last
Ein Eingabeiterator, der das letzte Element im entsprechend einer angegebenen binäre Operation zählt werden oder kombiniert wurde Bereich, behandelt, die eine Position über dem letzten Element hinaus ist, abgeschlossenen tatsächlich in der durchgelaufenen Ansammlung ein.
_Val
Ein Anfangswert, in dem jedes Element wiederum mit entsprechend einer angegebenen binäre Operation hinzugefügt oder kombiniert wird.
_Binary_op
Die binäre Operation, die auf jedes Element im angegebenen Bereich und im Ergebnis der vorherigen Anforderungen angewendet werden soll.

Rückgabewert

Die Summe aus _Val und aus alle Elemente im angegebenen Bereich für die erste Vorlagenfunktion, oder für die zweite Vorlagenfunktion, das Ergebnis der Anwendung der angegebenen binäre Operation, anstelle des Summenvorgangs, zu (PartialResult, *Iter), wo PartialResult das Ergebnis der vorherigen Anforderungen des Vorgangs und des Iter ist, ist ein Iterator, der auf ein Element im Bereich zeigt.

Hinweise

Der Anfangswert sichergestellt ist, dass ein klar definiertes Ergebnis gibt, wenn der Bereich leer ist, in diesem Fall _Val zurückgegeben wird. Die binäre Operation muss nicht, um assoziativ oder auswechselbar zu sein. Das Ergebnis wird mit dem Anfangswert _Val initialisiert und dann wird Ergebnis = _Binary_op (Ergebnis, *****Iter) iterativ im Bereich berechnet, wobei Iter ein Iterator ist, der auf aufeinander dem folgenden Element im Bereich zeigt. Der Bereich muss gültig sein und Komplexität ist mit der Größe des Bereichs linear. Der Rückgabetyp des binären Operators muss Typ konvertierbar sein, Finalisierung während der Iteration sicherzustellen.

Beispiel

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

          Der erste Vektor v1 ist:
 ( 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ).
Die Summe der ganzen Zahlen von 1 bis 20 ist: 210.
Der Vektor von partiellen Summen ist:
 ( 1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190 210 ).

Der erste Vektor v3 ist:
 ( 1 2 3 4 5 6 7 8 9 10 ).
Das Produkt der ganzen Zahlen von 1 bis 10 ist: 3628800.
Der Vektor von partiellen Produkten ist:
 ( 1 2 6 24 120 720 5040 40320 362880 3628800 ).

Anforderungen

Header: <numerisch>

Namespace: std

Siehe auch

accumulate, copy und vector::push_back
Standard Template Library

Freigeben über