LetT be the value type ofdecltype(first).

Givenbinary_op as the actual binary operation:

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

• For overloads(1,3):

• T is not constructible from*first.
• acc is notwritable tod_first.
• The result ofbinary_op(val, acc)(until C++20)binary_op(val, std::move(acc))(since C++20) is not writable tod_first.

• For overloads(2,4):

• *first is not writable tod_first.
• The result ofbinary_op(*first,*first) is not writable tod_first.

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

• For overloads(2,4),[first, last) and[d_first, d_last) overlaps.
• 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].

[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]Exceptions

The overloads with a template parameter namedExecutionPolicy report errors as follows:

• If execution of a function invoked as part of the algorithm throws an exception andExecutionPolicy is one of thestandard policies,std::terminate is called. For any otherExecutionPolicy, the behavior is implementation-defined.
• If the algorithm fails to allocate memory,std::bad_alloc is thrown.

[edit]Possible implementation

template<class InputIt,class OutputIt>constexpr// since C++20OutputIt adjacent_difference(InputIt first, InputIt last, OutputIt d_first){if(first== last)return d_first; typedeftypenamestd::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;}

template<class InputIt,class OutputIt,class BinaryOp>constexpr// since C++20OutputIt adjacent_difference(InputIt first, InputIt last,                              OutputIt d_first, BinaryOp op){if(first== last)return d_first; typedeftypenamestd::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;}

[edit]Notes

acc was introduced because of the resolution ofLWG issue 539. The reason of usingacc rather than directly calculating the differences 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 cache values of the iterated elements:

• its type is the value type ofInputIt
• the value written tod_first (which is the return value ofoperator- orop) is assigned to it
• its value is passed tooperator- orop

char i_array[4]={100,100,100,100};int  o_array[4]; // OK: performs conversions when needed// 1. creates “acc” of type char (the value type)// 2. “acc” is assigned to the first element of “o_array”// 3. the char arguments are used for long multiplication (char -> long)// 4. the long product is assigned to the output range (long -> int)// 5. the next value of “i_array” is assigned to “acc”// 6. go back to step 3 to process the remaining elements in the input rangestd::adjacent_difference(i_array, i_array+4, o_array,std::multiplies<long>{});

[edit]Example

#include <array>#include <functional>#include <iostream>#include <iterator>#include <numeric>#include <vector> void println(auto comment,constauto& sequence){std::cout<< comment;for(constauto& n: sequence)std::cout<< n<<' ';std::cout<<'\n';}; int main(){// Default implementation - the difference between two adjacent itemsstd::vector v{4,6,9,13,18,19,19,15,10};    println("Initially, v = ", v);    std::adjacent_difference(v.begin(), v.end(), v.begin());    println("Modified v = ", v); // Fibonaccistd::array<int,10> a{1};    std::adjacent_difference(std::begin(a),std::prev(std::end(a)),std::next(std::begin(a)),std::plus<>{});    println("Fibonacci, a = ", a);}

Initially, v = 4 6 9 13 18 19 19 15 10 Modified v = 4 2 3 4 5 1 0 -4 -5 Fibonacci, a = 1 1 2 3 5 8 13 21 34 55

[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
• Русский
• 中文