Givenbinary_op as the actual binary operation:

• If any of the following conditions is satisfied, the program is ill-formed:

• The value type ofInputIt is not constructible from*first.
• acc is notwritable tod_first.
• The result ofbinary_op(acc,*iter)(until C++20)binary_op(std::move(acc),*iter)(since C++20) is not implicitly convertible to the value type ofInputIt.

• Givend_last as the iterator to bereturned, if any of the following conditions is satisfied, the behavior is undefined:

• binary_op modifies any element of[first, last) or[d_first, d_last).
• binary_op invalidates any iterator or subrange in[first, last] or[d_first, d_last].

1. ↑The actual value to be assigned is the result of the assignment in the previous step. We assume the assignment result isacc here.

[edit]Parameters

[edit]Return value

Iterator to the element past the last element written, ord_first if[first, last) is empty.

[edit]Complexity

Given\(\scriptsize N\)N asstd::distance(first, last):

[edit]Possible implementation

template<class InputIt,class OutputIt>constexpr// since C++20OutputIt partial_sum(InputIt first, InputIt last, OutputIt d_first){if(first== last)return d_first; typenamestd::iterator_traits<InputIt>::value_type sum=*first;*d_first= sum; while(++first!= last){        sum= std::move(sum)+*first;// std::move since C++20*++d_first= sum;} return++d_first; // or, since C++14:// return std::partial_sum(first, last, d_first, std::plus<>());}

template<class InputIt,class OutputIt,class BinaryOp>constexpr// since C++20OutputIt partial_sum(InputIt first, InputIt last,                      OutputIt d_first, BinaryOp op){if(first== last)return d_first; typenamestd::iterator_traits<InputIt>::value_type acc=*first;*d_first= acc; while(++first!= last){        acc= op(std::move(acc),*first);// std::move since C++20*++d_first= acc;} return++d_first;}

[edit]Notes

acc was introduced because of the resolution ofLWG issue 539. The reason of usingacc rather than directly summing up the results (i.e.*(d_first+2)=(*first+*(first+1))+*(first+2);) is because the semantic of the latter is confusing if the following types mismatch:

• the value type ofInputIt
• the writable type(s) ofOutputIt
• the types of the parameters ofoperator+ orop
• the return type ofoperator+ orop

acc serves as the intermediate object to store and provide the values for each step of the computation:

• its type is the value type ofInputIt
• it is written tod_first
• its value is passed tooperator+ orop
• it stores the return value ofoperator+ orop

enum not_int{ x=1, y=2}; char i_array[4]={100,100,100,100};not_int e_array[4]={x, x, y, y};int  o_array[4]; // OK: uses operator+(char, char) and assigns char values to int arraystd::partial_sum(i_array, i_array+4, o_array); // Error: cannot assign not_int values to int arraystd::partial_sum(e_array, e_array+4, o_array); // OK: performs conversions when needed// 1. creates “acc” of type char (the value type)// 2. the char arguments are used for long multiplication (char -> long)// 3. the long product is assigned to “acc” (long -> char)// 4. “acc” is assigned to an element of “o_array” (char -> int)// 5. go back to step 2 to process the remaining elements in the input rangestd::partial_sum(i_array, i_array+4, o_array,std::multiplies<long>{});

[edit]Example

#include <functional>#include <iostream>#include <iterator>#include <numeric>#include <vector> int main(){std::vector<int> v(10,2);// v = {2, 2, 2, 2, 2, 2, 2, 2, 2, 2} std::cout<<"The first "<< v.size()<<" even numbers are: ";// write the result to the cout stream    std::partial_sum(v.cbegin(), v.cend(),std::ostream_iterator<int>(std::cout," "));std::cout<<'\n'; // write the result back to the vector v    std::partial_sum(v.cbegin(), v.cend(),                     v.begin(),std::multiplies<int>()); std::cout<<"The first "<< v.size()<<" powers of 2 are: ";for(int n: v)std::cout<< n<<' ';std::cout<<'\n';}

The first 10 even numbers are: 2 4 6 8 10 12 14 16 18 20 The first 10 powers of 2 are: 2 4 8 16 32 64 128 256 512 1024

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit]See also

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文