std:: adjacent_difference

令 T 为 decltype ( first ) 的值类型。

给定 binary_op 作为实际二元操作：

• 若满足以下任一条件，则程序非良构：

• 对于重载 (1,3) ：

• T 无法从 * first 构造。
• acc 不可写入 d_first 。
• binary_op ( val, acc ) (C++20 前) binary_op ( val, std :: move ( acc ) ) (C++20 起) 的结果不可写入 d_first 。

• 对于重载 (2,4) ：

• * first 不可写入 d_first 。
• binary_op ( * first, * first ) 的结果不可写入 d_first 。

• 给定 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 ] 中的任何迭代器或子区间失效。

参数

返回值

指向最后被写入元素之后位置的迭代器，若 [ first , last ) 为空范围则返回 d_first 。

复杂度

给定 \(\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_first 的值（即 operator - 或 op 的返回值）会被赋给它
• 其值会被传递给 operator - 或 op

char i_array[4] = {100, 100, 100, 100};
int  o_array[4];
// 正确：在需要时执行类型转换
// 1. 创建 char 类型的“acc”（值类型）
// 2. 将“acc”赋值给“o_array”的第一个元素
// 3. char 参数用于 long 类型乘法运算（char → long）
// 4. long 类型的乘积被赋值给输出范围（long → int）
// 5. 将“i_array”的下一个值赋值给“acc”
// 6. 返回步骤3处理输入范围内的剩余元素
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()
{
    // 默认实现 - 计算相邻元素的差值
    std::vector v{4, 6, 9, 13, 18, 19, 19, 15, 10};
    println("初始状态, v = ", v);
    std::adjacent_difference(v.begin(), v.end(), v.begin());
    println("修改后 v = ", v);
    // 斐波那契数列生成
    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("斐波那契数列, a = ", a);
}

初始状态, v = 4 6 9 13 18 19 19 15 10 
修改后 v = 4 2 3 4 5 1 0 -4 -5 
斐波那契数列, a = 1 1 2 3 5 8 13 21 34 55

缺陷报告

下列行为变更缺陷报告被追溯应用于先前发布的 C++ 标准。

参见