C++11标准模板（STL）- 算法库 - 类似 std::accumulate，但不依序执行 -（std::reduce）

于 2024-08-15 23:55:02 发布
阅读量980 收藏 20
点赞数 25
分类专栏： # 数值运算 文章标签： c++ 开发语言 STL reduce 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40788199/article/details/141234316
版权

算法库

算法库提供大量用途的函数（例如查找、排序、计数、操作），它们在元素范围上操作。注意范围定义为 [first, last) ，其中 last 指代要查询或修改的最后元素的后一个元素。

类似 std::accumulate，但不依序执行

std::reduce
template<class InputIt>

typename std::iterator_traits<InputIt>::value_type reduce(

    InputIt first, InputIt last);		(1)(C++17 起)
template<class ExecutionPolicy, class ForwardIt>

typename std::iterator_traits<ForwardIt>::value_type reduce(
    ExecutionPolicy&& policy,

    ForwardIt first, ForwardIt last);		(2)(C++17 起)

template<class InputIt, class T>
T reduce(InputIt first, InputIt last, T init);

(3)(C++17 起)
template<class ExecutionPolicy, class ForwardIt, class T>

T reduce(ExecutionPolicy&& policy,

         ForwardIt first, ForwardIt last, T init);		(4)(C++17 起)

template<class InputIt, class T, class BinaryOp>
T reduce(InputIt first, InputIt last, T init, BinaryOp binary_op);

(5)(C++17 起)
template<class ExecutionPolicy, class ForwardIt, class T, class BinaryOp>

T reduce(ExecutionPolicy&& policy,

         ForwardIt first, ForwardIt last, T init, BinaryOp binary_op);		(6)(C++17 起)

1) 同 reduce(first, last, typename std::iterator_traits<InputIt>::value_type{})

3) 同 reduce(first, last, init, std::plus<>())

5) 在 binary_op 上以初值 init 规约范围 [first; last) ，可能以未指定方式排序聚合。

2,4,6) 同 (1,3,5) ，但按照 policy 执行。此重载仅若std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> 为 true才参与重载决议

若 binary_op 非结合或非交换，则行为非确定。

若 binary_op 修改 [first; last] 中任何元素或非法化范围中任何迭代器，含尾迭代器，则行为未定义。

参数

first, last-要应用算法的元素范围
init-广义和的初值
policy-使用的执行策略。细节见执行策略。
binary_op-将以未指定顺序应用于解引用输入迭代器结果、其他 binary_op 结果及 init 上的二元函数对象 (FunctionObject) 。
类型要求
- InputIt 必须满足遗留输入迭代器 (LegacyInputIterator) 的要求。
- ForwardIt 必须满足遗留向前迭代器 (LegacyForwardIterator) 的要求。
- T 必须满足可移动构造 (MoveConstructible) 的要求。而且 binary_op(init, *first) 、 binary_op(*first, init) 、 binary_op(init, init) 及 binary_op(*first, *first) 必须可转换到 T 。

返回值

init 及 *first 、 *(first+1) 、…… *(last-1) 在 binary_op 上的广义和，

其中广义和 GSUM(op, a
1, ..., a
N) 定义如下：

  • 若 N=1 ，则为 a
    1
  • 若 N > 1 ，则为 op(GSUM(op, b
    1, ..., b
    K), GSUM(op, b
    M, ..., b
    N)) ，其中
  • b
    1, ..., b
    N 可以是任何 a1, ..., aN 的排列，且
  • 1 < K+1 = M ≤ N

换言之， reduce 表现类似 std::accumulate ，除了范围中的元素可能以任意顺序分组并重排。

复杂度

O(last - first) 次应用 binary_op.

异常

拥有名为 ExecutionPolicy 的模板形参的重载按下列方式报告错误：

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

注意

若为空，则返回不修改的 init

调用示例

#include <iostream>
#include <string>
#include <iterator>
#include <algorithm>
#include <functional>
#include <time.h>
#include <random>
#include <vector>
#include <cassert>

struct Cell
{
    int x;
    int y;

    Cell() = default;
    Cell(int a, int b): x(a), y(b) {}

    Cell &operator +=(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator +(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator *(const Cell &cell)
    {
        x *= cell.x;
        y *= cell.y;
        return *this;
    }

    Cell &operator ++()
    {
        x += 1;
        y += 1;
        return *this;
    }


    bool operator <(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y < cell.y;
        }
        else
        {
            return x < cell.x;
        }
    }

    bool operator >(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y > cell.y;
        }
        else
        {
            return x > cell.x;
        }
    }

    bool operator ==(const Cell &cell) const
    {
        return x == cell.x && y == cell.y;
    }

    friend Cell operator+(const Cell &lcell, const Cell &rcell)
    {
        Cell cell = lcell;
        cell.x += rcell.x;
        cell.y += rcell.y;
        return cell;
    }

    friend Cell operator-(const Cell &lcell, const Cell &rcell)
    {
        Cell cell = lcell;
        cell.x -= rcell.x;
        cell.y -= rcell.y;
        return cell;
    }

    friend Cell operator*(const Cell &lcell, const Cell &rcell)
    {
        Cell cell = lcell;
        cell.x *= rcell.x;
        cell.y *= rcell.y;
        return cell;
    }

    friend Cell operator/(const Cell &lcell, const Cell &rcell)
    {
        Cell cell = lcell;
        cell.x /= rcell.x;
        cell.y /= rcell.y;
        return cell;
    }

    friend Cell operator%(const Cell &lcell, const Cell &rcell)
    {
        Cell cell = lcell;
        cell.x %= rcell.x;
        cell.y %= rcell.y;
        return cell;
    }
};

std::ostream &operator<<(std::ostream &os, const Cell &cell)
{
    os << "{" << cell.x << "," << cell.y << "}";
    return os;
}

namespace std
{
template <typename InputIt, typename T, typename BinaryOperation>
T reduce(InputIt first, InputIt last, T init, BinaryOperation op)
{
    for (; first != last; ++first)
    {
        init = op(std::move(init), *first);
    }
    return init;
}
}

int main()
{
    std::cout << std::boolalpha;

    std::mt19937 g{std::random_device{}()};
    srand((unsigned)time(NULL));

    auto generate = []()
    {
        int n = std::rand() % 10 + 110;
        Cell cell{n, n};
        return cell;
    };

    //3) 构造拥有 count 个有值 value 的元素的容器。
    std::vector<Cell> vector1(8, generate());
    std::generate(vector1.begin(), vector1.end(), generate);
    std::sort(vector1.begin(), vector1.end());
    std::cout << "vector1:  ";
    std::copy(vector1.begin(), vector1.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::vector<Cell> vector2(vector1.size(), generate());
    std::generate(vector2.begin(), vector2.end(), generate);
    std::sort(vector2.begin(), vector2.end());
    std::cout << "vector2:  ";
    std::copy(vector2.begin(), vector2.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    for (size_t index = 0; index < vector1.size(); ++index)
    {
        std::cout << "std::reduce(vector1.begin(), " << index << ", Cell{0, 0} std::plus<Cell>() ):    ";
        std::cout << std::reduce(vector1.begin(), vector1.begin() + index, Cell{0, 0}, std::plus<Cell>());
        std::cout << std::endl;
    }
    std::cout << std::endl;

    for (size_t index = 0; index < vector1.size(); ++index)
    {
        std::cout << "std::reduce(vector1.begin(), " << index << ", Cell{0, 0} std::minus<Cell>() ):    ";
        std::cout << std::reduce(vector1.begin(), vector1.begin() + index, Cell{0, 0}, std::minus<Cell>());
        std::cout << std::endl;
    }
    std::cout << std::endl;

    for (size_t index = 0; index < vector2.size(); ++index)
    {
        std::cout << "std::reduce(vector2.begin(), " << index << ", Cell{1, 1} std::multiplies<Cell>() ):    ";
        std::cout << std::reduce(vector2.begin(), vector2.begin() + index, Cell{1, 1}, std::multiplies<Cell>());
        std::cout << std::endl;
    }
    std::cout << std::endl;

    for (size_t index = 0; index < vector2.size(); ++index)
    {
        std::cout << "std::reduce(vector2.begin(), " << index << ", Cell{1024, 1024} std::divides<Cell>() ):    ";
        std::cout << std::reduce(vector2.begin(), vector2.begin() + index, Cell{1024, 1024}, std::divides<Cell>());
        std::cout << std::endl;
    }
    std::cout << std::endl;

    for (size_t index = 0; index < vector2.size(); ++index)
    {
        std::cout << "std::reduce(vector2.begin(), " << index << ", Cell{1024, 1024} std::modulus<Cell>() ):    ";
        std::cout << std::reduce(vector2.begin(), vector2.begin() + index, Cell{1024, 1024}, std::modulus<Cell>());
        std::cout << std::endl;
    }
    std::cout << std::endl;

    return 0;
}

输出

vector1:  {111,111} {112,112} {113,113} {115,115} {116,116} {116,116} {117,117} {119,119}
vector2:  {110,110} {112,112} {112,112} {114,114} {117,117} {117,117} {119,119} {119,119}
std::reduce(vector1.begin(), 0, Cell{0, 0} std::plus<Cell>() ):    {0,0}
std::reduce(vector1.begin(), 1, Cell{0, 0} std::plus<Cell>() ):    {111,111}
std::reduce(vector1.begin(), 2, Cell{0, 0} std::plus<Cell>() ):    {223,223}
std::reduce(vector1.begin(), 3, Cell{0, 0} std::plus<Cell>() ):    {336,336}
std::reduce(vector1.begin(), 4, Cell{0, 0} std::plus<Cell>() ):    {451,451}
std::reduce(vector1.begin(), 5, Cell{0, 0} std::plus<Cell>() ):    {567,567}
std::reduce(vector1.begin(), 6, Cell{0, 0} std::plus<Cell>() ):    {683,683}
std::reduce(vector1.begin(), 7, Cell{0, 0} std::plus<Cell>() ):    {800,800}

std::reduce(vector1.begin(), 0, Cell{0, 0} std::minus<Cell>() ):    {0,0}
std::reduce(vector1.begin(), 1, Cell{0, 0} std::minus<Cell>() ):    {-111,-111}
std::reduce(vector1.begin(), 2, Cell{0, 0} std::minus<Cell>() ):    {-223,-223}
std::reduce(vector1.begin(), 3, Cell{0, 0} std::minus<Cell>() ):    {-336,-336}
std::reduce(vector1.begin(), 4, Cell{0, 0} std::minus<Cell>() ):    {-451,-451}
std::reduce(vector1.begin(), 5, Cell{0, 0} std::minus<Cell>() ):    {-567,-567}
std::reduce(vector1.begin(), 6, Cell{0, 0} std::minus<Cell>() ):    {-683,-683}
std::reduce(vector1.begin(), 7, Cell{0, 0} std::minus<Cell>() ):    {-800,-800}

std::reduce(vector2.begin(), 0, Cell{1, 1} std::multiplies<Cell>() ):    {1,1}
std::reduce(vector2.begin(), 1, Cell{1, 1} std::multiplies<Cell>() ):    {110,110}
std::reduce(vector2.begin(), 2, Cell{1, 1} std::multiplies<Cell>() ):    {12320,12320}
std::reduce(vector2.begin(), 3, Cell{1, 1} std::multiplies<Cell>() ):    {1379840,1379840}
std::reduce(vector2.begin(), 4, Cell{1, 1} std::multiplies<Cell>() ):    {157301760,157301760}
std::reduce(vector2.begin(), 5, Cell{1, 1} std::multiplies<Cell>() ):    {1224436736,1224436736}
std::reduce(vector2.begin(), 6, Cell{1, 1} std::multiplies<Cell>() ):    {1525177344,1525177344}
std::reduce(vector2.begin(), 7, Cell{1, 1} std::multiplies<Cell>() ):    {1107477504,1107477504}

std::reduce(vector2.begin(), 0, Cell{1024, 1024} std::divides<Cell>() ):    {1024,1024}
std::reduce(vector2.begin(), 1, Cell{1024, 1024} std::divides<Cell>() ):    {9,9}
std::reduce(vector2.begin(), 2, Cell{1024, 1024} std::divides<Cell>() ):    {0,0}
std::reduce(vector2.begin(), 3, Cell{1024, 1024} std::divides<Cell>() ):    {0,0}
std::reduce(vector2.begin(), 4, Cell{1024, 1024} std::divides<Cell>() ):    {0,0}
std::reduce(vector2.begin(), 5, Cell{1024, 1024} std::divides<Cell>() ):    {0,0}
std::reduce(vector2.begin(), 6, Cell{1024, 1024} std::divides<Cell>() ):    {0,0}
std::reduce(vector2.begin(), 7, Cell{1024, 1024} std::divides<Cell>() ):    {0,0}

std::reduce(vector2.begin(), 0, Cell{1024, 1024} std::modulus<Cell>() ):    {1024,1024}
std::reduce(vector2.begin(), 1, Cell{1024, 1024} std::modulus<Cell>() ):    {34,34}
std::reduce(vector2.begin(), 2, Cell{1024, 1024} std::modulus<Cell>() ):    {34,34}
std::reduce(vector2.begin(), 3, Cell{1024, 1024} std::modulus<Cell>() ):    {34,34}
std::reduce(vector2.begin(), 4, Cell{1024, 1024} std::modulus<Cell>() ):    {34,34}
std::reduce(vector2.begin(), 5, Cell{1024, 1024} std::modulus<Cell>() ):    {34,34}
std::reduce(vector2.begin(), 6, Cell{1024, 1024} std::modulus<Cell>() ):    {34,34}
std::reduce(vector2.begin(), 7, Cell{1024, 1024} std::modulus<Cell>() ):    {34,34}

繁星璀璨G
关注
专栏目录
C++的并行算法：并行reduce
夏天的狂风的专栏
06-11 1293
reduce是一种常见的并行操作，它将一个序列的元素组合成一个单一的值。在C++中，我们可以使用std::accumulate算法进行reduce。然而，std::accumulate是一个顺序算法，它在一个时间点只执行一个操作。为了提高reduce的性能，我们可以使用并行reduce算法，它在多个处理器上同时执行多个操作。C++17标准库中的std::accumulate并没有并行版本，但我们可以使用std::reduce并行算法进行reduce。
C++11 新特性 ④ | 模板类 std::function 和标准库函数 std::bind
热门推荐
dvlinker的技术专栏
09-09 1万+
详细讲解模板类std::function和标准库函数std::bind。
C++ STL 中提供的算法
Michael__Wu的博客
12-23 464
1 算法 1.1 for_each() 参数有三个: 首迭代器 尾迭代器 执行的函数 例如如下代码: #include <algorithm> //必须包含 #include <vector> using namespace std; int main() { vector<int> tmp; tmp.push_back(10); tmp.push_back(20); tmp.push_back(30); tmp.
std::accumulate 和 std::reduce 累加求和
qq_38349382的博客
11-23 216
中文标准库std::accumulate 中文标准库std::reduce std::accumulate accumulate定义在头文件numeric中，作用有两个: 累加求和(不仅可以求int，float等类型还可以求和string类型) 自定义类型数据的处理 函数原型： template <class InputIt, class T > T accumulate...
c++记录std::reduce使用上的问题-意料之外的并行计算
qq_34179431的博客
03-04 1002
std::reduce的并行执行特性可能导致在不同编译器或不同的运行环境下出现不同的结果，特别是当归约操作（如乘法）不是关联的时，或者编译器对并行算法的支持和优化水平不同时。非确定性的并行执行: std::reduce允许并行执行，这意味着操作的顺序可能因执行而异，特别是在涉及有状态的lambda表达式（如在你的代码中使用&[&](int init, int value)）时。std::accumulate保证了操作的顺序，虽然它可能不会像std::reduce那样利用并行执行的优势。
reduce的用法及实例
weixin_34064653的博客
04-20 170
reduce的定义：reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。说白了就是累加器。 我们看一下之前的累加： 看例子： //假设我们有一个数组 var arr=[,1,2,3,4,5,6,7,8] //我们求这个数组里面值的综总和 //按照平常写法： var num=0 for(var i=0;i&l...
reduce、transform_reduce、decltype、函数式编程、SIMD、TBB并发
yao-xin
09-27 316
如果不是4的倍数，例如1023，那么会将1020个元素用SIMD填入，剩余的3个元素使用传统标量方式填入，为了实现这样的功能，编译器会生成很复杂的边界特判代码。对于没有声明为__restrict的两个指针，编译器担心它们重叠，会同时生成两份代码，一份是SIMD的，一份是传统标量的，运行时判断指针的差值是否超过1024来判断重叠。计算数组内浮点数的和时，由于temp越加越大，如果是串行着累加，就会导致 大加小 丢失精度，而如果使用并行的累加，每次相加的就都是一个数量级的，会更精确。
reduce详解
qq_38788128的博客
05-17 245
# -- coding: utf-8 -- #求1累加到100的和 list=xrange(1,101); def add(x,y): return x+y; print reduce(add,list) ''' reduce(function, iterable[, initializer]) 第一个参数是作用在序列上的方法，第二个参数是被作用的序列，这与 map 一致。另外有一...
《C++语言 - 标准模板库STL》_标准模板库_C++_C++STL_
09-29
在C++编程中，标准模板库（Standard Template Library，简称STL）是一个极其重要的组成部分，它为程序员提供了高效且易用的数据结构和算法。STL是C++标准库的一个核心部分，极大地提升了代码的可读性和复用性，使得...
C++ STL教程（10）std::set使用
二进制君
08-10 1851
set也是STL中比较常见的容器。set集合容器实现了红黑树的平衡二叉检索树的数据结构，它会自动调整二叉树的排列，把元素放到适当的位置。set容器所包含的元素的值是唯一的，集合中的元素按一定的顺序排列。 我们构造set集合的目的是为了快速的检索，不可直接去修改键值。 set的一些常见操作： begin() 返回指向第一个元素的迭代器 clear() 清除所有元素 count() 返回某个值元素的个数 empty() 如果集合为空，返回true(真） end() 返回指向最后一个元素之后的迭代器，不是最后一个
std::string format格式化函数源代码及两种格式化方法
01-20
而`format`函数通常指的是用于格式化输出的工具，类似于C语言中的`printf`或C++的`std::stringstream`。本项目提供的`std::string format`函数是作者自定义的一个实现，它提供了一种方便的方式来格式化`std::string`...
C++ STL教程（9）std::map全网最权威、最完整介绍
二进制君
08-10 1万+
定义 map是STL的一个关联容器，它是一个单映射容器。它提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可以称为该关键字的值，合称key-value）的数据处理能力。这里说下map内部数据的组织，map内部自建一颗红黑树(一种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能，所以在map内部所有的数据都是有序的，后边我们会见识到有序的好处。下面举例说明什么是一对一的数据映射比如一个班级中，每个学生的学号跟他的姓名就存在着一一映射的关系，这个模型用map可能轻易描述。
c++当中关于reduce accumulate函数的一些延申思考
最新发布
qq_48088330的博客
08-02 520
类本身不能作为可调用对象传递，必须传递一个实例化的对象。accumulate用于对迭代器指示范围[first, last)中元素进行累加操作，对于序列当中的每个元素，一次应用某个二元操作（默认加法），并且将结果累加到一个初始值上。可以简单理解为reduce accumulate需要一个能够直接调用的对象，要么是类的实例要么是函数。reduce 同样是对迭代器指示范围内元素进行归约操作，但支持并行执行，操作元素必须是无关联的。运算符，使得实例对象可以像函数一样调用。函数对象是可以像函数一样调用的对象。
C++ STL reduce 用法
GPU全栈博主-程序哥
08-01 460
累加求和，它是 std::accumulate 的泛化版本，它元素的累加顺序没有要求，因此可以用于并行累加。另外也可以通过重载运算符进行累乘等运算。
reduce方法的用法详解
anglra的博客
10-27 241
reduce方法作为JavaScript中数组的一个高阶函数， 对数组中的每个元素执行一个由您提供的reduce函数(升序执行)，将其结果汇总为单个返回值。reduce方法可做的事情特别多，就是循环遍历能做的，reduce都可以做，比如数组求和、数组求积、数组中元素出现的次数、等等。
C++并发编程（十）并行算法函数
CSSS_2021的博客
03-14 3131
《C++并发编程实战》笔记
C++标准库算法整理
友善啊，朋友的博客
10-17 1983
此代码首先对{1, 2, 3, 4, 5}的每个元素执行square即平方操作，得到{1, 4, 9, 16, 25}，再对此序列中的元素执行plus即相加的操作。移除指定范围内的元素，返回一个新的范围，其中被移除的元素被放置在范围的末尾。用于将元素的值从一个范围内的位置移动到另一个范围内的位置，并保持原始顺序的逆序。结果是计算出一个新的序列，新序列中的每个元素都是原序列中当前位置以及之前位置的元素的累积和。c++17以上才支持。将指定范围内的元素插入到容器中，并调整剩余元素的顺序，使其符合堆的规则。
Modern C++ 学习笔记——C++函数式编程
小小笑笑川的博客
07-13 3429
C++函数式编程看这一篇就够了，建议收藏~~~！！！ ModernC++学习笔记是一系列介绍现代C++新特性的文章，结合《effective modern C++》说明了如何更好的使用这些新特性。相互讨论，共同学习，不断成长
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值