◐ Shell
clean mode source ↗

std::partial_sum - cppreference.com

De cppreference.com

</tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody>

Definido en el archivo de encabezado <numeric>

(1)

template< class InputIt, class OutputIt > OutputIt partial_sum( InputIt first, InputIt last, OutputIt d_first );

 (hasta C++20)

template< class InputIt, class OutputIt > constexpr OutputIt partial_sum( InputIt first, InputIt last, OutputIt d_first );

 (desde C++20)
(2)

template< class InputIt, class OutputIt, class BinaryOperation > OutputIt partial_sum( InputIt first, InputIt last, OutputIt d_first, BinaryOperation op );

 (hasta C++20)

template< class InputIt, class OutputIt, class BinaryOperation > constexpr OutputIt partial_sum( InputIt first, InputIt last, OutputIt d_first, BinaryOperation op );

 (desde C++20)

Calcula las sumas parciales de los elementos en los subrangos del rango [first, last) y las escribe en el rango que comienza en d_first. La primera versión utiliza operator+ para sumar los elementos, la segunda versión utiliza la función binaria dada op, ambas aplican std::move a sus operandos en el lado izquierdo (desde C++20).

Operación equivalente: 

*(d_first)   = *first;
*(d_first+1) = *first + *(first+1);
*(d_first+2) = *first + *(first+1) + *(first+2);
*(d_first+3) = *first + *(first+1) + *(first+2) + *(first+3);
...

op no debe tener efectos secundarios.

(hasta C++11)

op no debe invalidar ningún iterador, incluso los iteradores al final, o modificar ningún elemento del rango involucrado.

(desde C++11)

Parámetros

first, last - El rango de elementos a sumar
d_first - El inicio del rango destino; puede ser igual a first
op - Función objeto de operación binaria que se aplicará.

La signatura de la función deberá ser equivalente a lo siguiente:

Ret fun(const Type1 &a, const Type2 &b);

La signatura no necesita tener const &.
El tipo Type1 debe ser tal que un objeto de tipo iterator_traits<InputIt>::value_type puede convertirse implícitamente a Type1. El tipo Type2 debe ser tal que un objeto de tipo InputIt puede ser desreferenciado y luego convertido implícitamente a Type2. El tipo Ret debe ser tal que un objeto de tipo iterator_traits<InputIt>::value_type puede ser asignado un valor de tipo Ret. ​

Requisitos de tipo
-InputIt debe satisfacer los requisitos de InputIterator.
-OutputIt debe satisfacer los requisitos de OutputIterator.

Valor de retorno

Iterador al elemento después del último elemento escrito.

Complejidad

Exactamente (last - first) - 1 aplicaciones de la operación binaria.

Posible implementación

Primera versión 
template<class InputIt, class OutputIt>
constexpr // desde C++20
OutputIt partial_sum(InputIt first, InputIt last, 
                     OutputIt d_first)
{
    if (first == last) return d_first;

    typename std::iterator_traits<InputIt>::value_type sum = *first;
    *d_first = sum;

    while (++first != last) {
       sum = std::move(sum) + *first; // std::move desde C++20
       *++d_first = sum;
    }
    return ++d_first;

    // o, desde C++14:
    // return std::partial_sum(first, last, d_first, std::plus<>());
}
Segunda versión 
template<class InputIt, class OutputIt, class BinaryOperation>
constexpr // desde C++20
OutputIt partial_sum(InputIt first, InputIt last, 
                     OutputIt d_first, BinaryOperation op)
{
    if (first == last) return d_first;

    typename std::iterator_traits<InputIt>::value_type sum = *first;
    *d_first = sum;

    while (++first != last) {
       sum = op(std::move(sum), *first); // std::move desde C++20
       *++d_first = sum;
    }
    return ++d_first;
}

Ejemplo

#include <numeric>
#include <vector>
#include <iostream>
#include <iterator>
#include <functional>

int main()
{
    std::vector<int> v = {2, 2, 2, 2, 2, 2, 2, 2, 2, 2}; // o std::vector<int>v(10, 2);

    std::cout << "Los primeros 10 numeros pares son: ";
    std::partial_sum(v.begin(), v.end(), 
                     std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';

    std::partial_sum(v.begin(), v.end(), v.begin(), std::multiplies<int>());
    std::cout << "Las primeras 10 potencias de 2 son: ";
    for (auto n : v) {
        std::cout << n << " ";
    }
    std::cout << '\n';
}

Salida: 

Los primeros 10 numeros pares son: 2 4 6 8 10 12 14 16 18 20 
Las primeras 10 potencias de 2 son: 2 4 8 16 32 64 128 256 512 1024

Véase también

Calcula las diferencias entre elementos adyacentes en un rango
(plantilla de función) [editar]
Suma un rango de elementos
(plantilla de función) [editar]
Similar a std::partial_sum, incluye el i-ésimo elemento de entrada de la i-ésima suma
(plantilla de función) [editar]
Similar a std::partial_sum, excluye el i-ésimo elemento de entrada de la i-ésima suma
(plantilla de función) [editar]