template <class InputIterator, class OutputIterator>
OutputIterator
adjacent_difference(InputIterator first, InputIterator last,
OutputIterator result);
template <class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2
adjacent_difference(ExecutionPolicy&& exec,
ForwardIterator1 first, ForwardIterator1 last,
ForwardIterator2 result);
template <class InputIterator, class OutputIterator, class BinaryOperation>
OutputIterator
adjacent_difference(InputIterator first, InputIterator last,
OutputIterator result,
BinaryOperation binary_op);
template <class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
class BinaryOperation>
ForwardIterator2
adjacent_difference(ExecutionPolicy&& exec,
ForwardIterator1 first, ForwardIterator1 last,
ForwardIterator2 result,
BinaryOperation binary_op);
Requires:
For the overloads with no
ExecutionPolicy,
InputIterator's value
type shall be
MoveAssignable (Table
25) and shall
be constructible from the type of
*first.The result of the expression
val - acc or
binary_op(val, acc) shall be writable to the
result output iterator
.For the overloads with an
ExecutionPolicy, the value type of
ForwardIterator1
shall be
CopyConstructible (Table
24),
constructible from the expression
*first - *first or
binary_op(*first, *first), and assignable to the value type of
ForwardIterator2.For all overloads, in the ranges
[first, last]
and
[result, result + (last - first)],
binary_op
shall neither modify elements nor invalidate iterators or
subranges
.
Effects: For the overloads with no
ExecutionPolicy and a non-empty range,
the function creates an accumulator
acc whose type is
InputIterator's
value type, initializes it with
*first,
and assigns the result to
*result. For every iterator
i in
[first + 1, last)
in order, creates an object
val whose type is
InputIterator's value type, initializes it
with
*i, computes
val - acc or
binary_op(val, acc), assigns the result
to
*(result + (i - first)), and move assigns from
val to
acc.For the overloads with an
ExecutionPolicy and a non-empty range, first the
function creates an object whose type is
ForwardIterator1's value type,
initializes it with
*first, and assigns the result to
*result.Then for every
d
in
[1, last - first - 1], creates an object
val whose type is
ForwardIterator1's value type, initializes it with
*(first + d) - *(first + d - 1) or
binary_op(*(first + d), *(first + d - 1)), and assigns the result to
*(result + d).Returns:
result + (last - first). Complexity:
Exactly
(last - first) - 1
applications of
the binary operation
. Remarks:
For the overloads with no
ExecutionPolicy,
result may be equal
to
first. For the overloads with an
ExecutionPolicy, the ranges
[first, last) and
[result, result + (last - first)) shall not overlap
.