Defined in header <numeric>  

(1)  
template< class InputIt, class OutputIt > OutputIt adjacent_difference( InputIt first, InputIt last, OutputIt d_first );  (until C++20)  
template< class InputIt, class OutputIt > constexpr OutputIt adjacent_difference( InputIt first, InputIt last, OutputIt d_first );  (since C++20)  
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > ForwardIt2 adjacent_difference( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first );  (2)  (since C++17) 
(3)  
template< class InputIt, class OutputIt, class BinaryOperation > OutputIt adjacent_difference( InputIt first, InputIt last, OutputIt d_first, BinaryOperation op );  (until C++20)  
template< class InputIt, class OutputIt, class BinaryOperation > constexpr OutputIt adjacent_difference( InputIt first, InputIt last, OutputIt d_first, BinaryOperation op );  (since C++20)  
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
. An 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
(until C++20)val  std::move(acc)
(since C++20) (overload (1)) or op(val, acc)
(until C++20)op(val, std::move(acc))
(since C++20) (overload (3)), assigns the result to *(d_first + (i  first))
, and move assigns from val
to acc
.first
may be equal to d_first
.*d_first = *first;
. For every d
in [1, last  first  1]
, assigns *(first + d)  *(first + d  1)
(overload (2)) or op(*(first + d), *(first + d  1))
(overload (4)) 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 LegacyInputIterator. InputIt's value type must be MoveAssignable and constructible from the type of *first 

OutputIt must meet the requirements of LegacyOutputIterator. both acc (the accumulated value) and the result of val  acc or op(val, acc) (until C++20)val  std::move(acc) or op(val, std::move(acc)) (since C++20) must be writable to OutputIt 

ForwardIt1, ForwardIt2 must meet the requirements of LegacyForwardIterator. The results of *first , *first  *first (for (2)) and op(*first, *first) (for (4)) must be writable to ForwardIt2 . 
Iterator 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 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  std::move(acc); // std::move since C++20 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, std::move(acc)); // std::move since C++20 acc = std::move(val); } return ++d_first; } 
#include <numeric> #include <vector> #include <array> #include <iostream> #include <functional> #include <iterator> int main() { // Default implementation  the difference b/w two adjacent items std::vector 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'; // Fibonacci std::array<int, 10> a {1}; adjacent_difference(begin(a), std::prev(end(a)), std::next(begin(a)), std::plus<> {}); copy(begin(a), end(a), std::ostream_iterator<int> {std::cout, " "}); }
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