Defined in header <numeric>  

template< class InputIt, class OutputIt > OutputIt adjacent_difference( InputIt first, InputIt last, OutputIt d_first );  (1)  
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > ForwardIt2 adjacent_difference( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first );  (2)  (since C++17) 
template< class InputIt, class OutputIt, class BinaryOperation > OutputIt adjacent_difference( InputIt first, InputIt last, OutputIt d_first, BinaryOperation op );  (3)  
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryOperation > ForwardIt2 adjacent_difference( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, BinaryOperation op );  (4)  (since C++17) 
Computes the differences between the second and the first of each adjacent pair of elements of the range [first, last)
and writes them to the range beginning at d_first + 1
. Unmodified copy of first
is written to d_first
.
acc
whose type is InputIt
's value type, initializes it with *first
, and assigns the result to *d_first
. Then, for every iterator i
in [first + 1, last)
in order, creates an object val
whose type is InputIt
's value type, initializes it with *i
, computes val  acc
(overload (1)) or op(val, acc)
(overload (3)), assigns the result to *(d_first + (i  first))
, and move assigns from val
to acc
.first==d_first
*first
, and assigns the result to *d_first
. Then for every d
in [1, last  first  1]
, creates an object val
whose type is ForwardIt1's value type, initializes it with *(first + d)  *(first + d  1)
(overload (2)) or op(*(first + d), *(first + d  1))
(overload (4)), and assigns the result to *(d_first + d)
. This is executed according to policy
. This overload only participates in overload resolution if std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>
is true.
Equivalent operation:
*(d_first) = *first; *(d_first+1) = *(first+1)  *(first); *(d_first+2) = *(first+2)  *(first+1); *(d_first+3) = *(first+3)  *(first+2); ...
 (until C++11) 
 (since C++11) 
first, last    the range of elements 
d_first    the beginning of the destination range 
policy    the execution policy to use. See execution policy for details. 
op    binary operation function object that will be applied. The signature of the function should be equivalent to the following:
The signature does not need to have 
Type requirements  
InputIt must meet the requirements of InputIterator . InputIt's value type must be MoveAssignable and constructible from the type of *first 

OutputIt must meet the requirements of OutputIterator . both acc (the accumulated value) and the result of valacc or op(val, acc) must be writable to OutputIt 

ForwardIt1, ForwardIt2 must meet the requirements of ForwardIterator . ForwardIt1's value_type must be CopyConstructible , constructible from the expression *first  *first or op(*first, *first) , and assignable to ForwardIt2's value_type 
It to the element past the last element written.
If first == last
, this function has no effect and will merely return d_first
.
Exactly (last  first)  1
applications of the binary operation.
The overloads with a template parameter named ExecutionPolicy
report errors as follows:
ExecutionPolicy
is one of the three standard policies, std::terminate
is called. For any other ExecutionPolicy
, the behavior is implementationdefined. std::bad_alloc
is thrown. First version 

template<class InputIt, class OutputIt> OutputIt adjacent_difference(InputIt first, InputIt last, OutputIt d_first) { if (first == last) return d_first; typedef typename std::iterator_traits<InputIt>::value_type value_t; value_t acc = *first; *d_first = acc; while (++first != last) { value_t val = *first; *++d_first = val  acc; acc = std::move(val); } return ++d_first; } 
Second version 
template<class InputIt, class OutputIt, class BinaryOperation> OutputIt adjacent_difference(InputIt first, InputIt last, OutputIt d_first, BinaryOperation op) { if (first == last) return d_first; typedef typename std::iterator_traits<InputIt>::value_type value_t; value_t acc = *first; *d_first = acc; while (++first != last) { value_t val = *first; *++d_first = op(val, acc); acc = std::move(val); } return ++d_first; } 
The following code converts a sequence of even numbers to repetitions of the number 2 and converts a sequence of ones to a sequence of Fibonacci numbers.
#include <numeric> #include <vector> #include <iostream> #include <functional> int main() { std::vector<int> v{2, 4, 6, 8, 10, 12, 14, 16, 18, 20}; std::adjacent_difference(v.begin(), v.end(), v.begin()); for (auto n : v) { std::cout << n << ' '; } std::cout << '\n'; v = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; std::adjacent_difference(v.begin(), v.end()  1, v.begin() + 1, std::plus<int>()); for (auto n : v) { std::cout << n << ' '; } std::cout << '\n'; }
Output:
2 2 2 2 2 2 2 2 2 2 1 1 2 3 5 8 13 21 34 55
computes the partial sum of a range of elements (function template) 

sums up a range of elements (function template) 
© cppreference.com
Licensed under the Creative Commons AttributionShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/algorithm/adjacent_difference