std::adjacent_difference

template< class InputIt, class OutputIt >
OutputIt adjacent_difference( InputIt first, InputIt last,
                              OutputIt d_first );

template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2 >
ForwardIt2 adjacent_difference( ExecutionPolicy&& policy,
                                ForwardIt1 first, ForwardIt1 last,
                                ForwardIt2 d_first );

template< class InputIt, class OutputIt, class BinaryOp >
OutputIt adjacent_difference( InputIt first, InputIt last, 
                              OutputIt d_first, BinaryOp op );

template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2, class BinaryOp >
ForwardIt2 adjacent_difference( ExecutionPolicy&& policy,
                                ForwardIt1 first, ForwardIt1 last, 
                                ForwardIt2 d_first, BinaryOp op );

T を decltype(first) の値型とする。

実際の二項演算を binary_op としたとき:

• 以下の条件のいずれかが満たされる場合、プログラムは ill-formed である:

• オーバーロード (1,3) について:

• T*first から構築可能ではない。
• accwritable が d_first に対して false である。
• binary_op(val, acc)(C++20 まで)binary_op(val, std::move(acc))(C++20 から) の結果が d_first に対して writable ではない。

• オーバーロード (2,4) について:

• *firstd_first に対して writable ではない。
• binary_op(*first, *first) の結果が d_first に対して writable ではない。

• d_last を 返されるイテレータとしたとき、以下の条件のいずれかが満たされる場合、動作は未定義である:

• オーバーロード (2,4) について、 [first, last) と [d_first, d_last) は重なる。
• binary_op[first, last) または [d_first, d_last) の任意の要素を変更する。
• binary_op[first, last] または [d_first, d_last] 内の任意のイテレータまたは部分レンジを無効にする。

引数

戻り値

書き込まれた最後の要素の次の要素を指すイテレータ。 d_first が空の場合は [first, last)。

計算量

\(\scriptsize N\)N を std::distance(first, last) として:

例外

テンプレートパラメータ ExecutionPolicy を持つオーバーロードは、以下のようにエラーを報告する:

• アルゴリズムの一部として呼び出された関数が例外を投げ、 ExecutionPolicy が 標準ポリシー のいずれかである場合、 std::terminate が呼ばれる。それ以外の ExecutionPolicy については、動作は処理系定義である。
• アルゴリズムがメモリの確保に失敗した場合、 std::bad_alloc が投げられる。

実装例

template<class InputIt, class OutputIt>
constexpr // since C++20
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;
}

template<class InputIt, class OutputIt, class BinaryOp>
constexpr // since C++20
OutputIt adjacent_difference(InputIt first, InputIt last, 
                             OutputIt d_first, BinaryOp 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;
}

注意

acc は LWG issue 539 の解決により導入された。直接差分を計算する代わりに acc を使用する理由は、以下の型が一致しない場合に後者の意味が混乱を招くからである:

• InputIt
• の値型OutputIt
• operator- または op
• のパラメータの型operator-op

acc は、反復される要素の値をキャッシュするための中間オブジェクトとして機能する:

• その型は InputIt
• の値型であるd_firstoperator- または op の戻り値である
• に書き込まれる値が代入されるoperator-その値が op

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 range
std::adjacent_difference(i_array, i_array + 4, o_array, std::multiplies<long>{});

または

#include <array>
#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>

void println(auto comment, const auto& sequence)
{
    std::cout << comment;
    for (const auto& n : sequence)
        std::cout << n << ' ';
    std::cout << '\n';
};

int main()
{
    // Default implementation - the difference between two adjacent items
    std::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);
    
    // Fibonacci
    std::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

出力:

欠陥報告

関連項目