std:: transform_exclusive_scan

序列元素关于二元运算 binary_op 的 广义非交换和 定义如下：

• 如果序列只有一个元素，则总和为该元素的值。
• 否则，按顺序执行以下操作：

1. 从序列中选择任意两个相邻元素 elem1 和 elem2 。
2. 计算 binary_op ( elem1, elem2 ) 并将序列中的这两个元素替换为计算结果。
3. 重复步骤1和2，直到序列中仅剩一个元素。

如果 binary_op 不具有结合性（例如浮点数加法），则结果将是非确定性的。

如果以下任意值无法转换为 T ，则程序非良构：

• binary_op ( init, init )
• binary_op ( init, unary_op ( * first ) )
• binary_op ( unary_op ( * first ) , unary_op ( * first ) )

若满足以下任一条件，则行为未定义：

• T 不满足 MoveConstructible 要求。
• unary_op 或 binary_op 修改了 [ first , last ) 范围内的任何元素。
• unary_op 或 binary_op 使 [ first , last ] 范围内的任何迭代器或子区间失效。

参数

返回值

指向已写入的最后一个元素之后位置的迭代器。

复杂度

给定 \(\scriptsize N\) N 为 std:: distance ( first, last ) ：

异常

带有名为 ExecutionPolicy 模板参数的重载按以下方式报告错误：

• 如果作为算法一部分调用的函数执行抛出异常，且 ExecutionPolicy 是某个 标准策略 ，则调用 std::terminate 。对于任何其他 ExecutionPolicy ，其行为由实现定义。
• 如果算法无法分配内存，则抛出 std::bad_alloc 。

注释

unary_op 永远不会应用于 init 。

示例

#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
int main()
{
    std::vector data{3, 1, 4, 1, 5, 9, 2, 6};
    auto times_10 = [](int x) { return x * 10; };
    std::cout << "10倍排他和: ";
    std::transform_exclusive_scan(data.begin(), data.end(),
                                  std::ostream_iterator<int>(std::cout, " "),
                                  0, std::plus<int>{}, times_10);
    std::cout << "\n10倍包含和: ";
    std::transform_inclusive_scan(data.begin(), data.end(),
                                  std::ostream_iterator<int>(std::cout, " "),
                                  std::plus<int>{}, times_10);
    std::cout << '\n';
}

10倍排他和: 0 30 40 80 90 140 230 250 
10倍包含和: 30 40 80 90 140 230 250 310

参见