accumulate

Calcula la suma de todos los elementos en un intervalo especificado como un valor inicial calcular sumas parciales sucesivas o calcula el resultado de los resultados parciales sucesivos obtenidos de igual forma de utilizar una operación binaria especificada distinto de la suma.

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

Parámetros

• _First
  Un iterador de entrada que dirige el primer elemento del intervalo que se va a sumar o combinado de una operación binaria especificada.

• _Last
  Un iterador de entrada que las el último elemento del intervalo que se va a sumar o combinado de una operación binaria especificada es una posición más allá del último elemento incluido realmente en la acumulación itera.

• _Val
  Un valor inicial a que cada elemento a su vez se agrega o se combina con como una operación binaria especificada.

• _Binary_op
  La operación binaria que debe aplicar a cada elemento del intervalo especificado y el resultado de las aplicaciones anteriores.

Valor devuelto

La suma de _Val y todos los elementos en el intervalo especificado para la primera función de plantilla, o, para la segunda función de plantilla, el resultado de aplicar la operación binaria especificada, en lugar de la operación de suma, a (PartialResult, *Iter), donde el resultado PartialResult de aplicaciones anteriores de la operación y de Iter es un iterador que señala a un elemento del intervalo.

Comentarios

El valor inicial garantiza que habrá un resultado bien definido cuando el intervalo está vacío, en cuyo caso se devuelve _Val . La operación binaria no necesita ser asociativa o conmutativa. El resultado se inicializa en el valor inicial _Val y el resultado = _Binary_op (resultado, ###*Iter) se calcula iterativo a través del intervalo, donde es un iterador Iter que señala al elemento sucesivo del intervalo. El intervalo debe ser válido y complejidad es lineal al tamaño del intervalo. El tipo de valor devuelto del operador binario debe poder convertirse a Tipo garantizar el cierre durante la iteración.

Ejemplo

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

Requisitos

Encabezado: <numérico>

Espacio de nombres: std

Vea también

Referencia

accumulate, copy y vector::push_back

Biblioteca de plantillas estándar