Para ver el artículo en inglés, active la casilla Inglés. También puede ver el texto en inglés en una ventana emergente si pasa el puntero del mouse por el texto.
Traducción
Inglés

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

_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.

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.

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;
}
          El vector original v1 es:
 ( 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ).
La suma de los enteros del 1 al 20 es: 210.
El vector de sumas parciales es:
 ( 1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190 210 ).

El vector original v3 es:
 ( 1 2 3 4 5 6 7 8 9 10 ).
El producto de los enteros del 1 al 10 es: 3628800.
El vector de productos parciales es:
 ( 1 2 6 24 120 720 5040 40320 362880 3628800 ).

Requisitos

Encabezado: <numérico>

Espacio de nombres: std

Mostrar: