STL std::accumulate()算法：元素的累加和

白日梦想家又困啦

已于 2024-02-26 11:58:24 修改

阅读量2.8k

点赞数 15

分类专栏：深入标准模板库(STL)：探索C++的心脏文章标签： c++ 算法开发语言

于 2024-02-23 09:55:47 首次发布

本文链接：https://blog.csdn.net/weixin_48979633/article/details/136248342

版权

深入标准模板库(STL)：探索C++的心脏专栏收录该内容

6 篇文章

订阅专栏

文章目录

STL std::accumulate()算法元素的累加和

STL std::accumulate()算法元素的累加和

std::accumulate 是 C++ 标准库中定义于 <numeric> 头文件的一个算法，用于计算给定范围 [first, last) 中所有元素的累加和，也可以在累加时应用一个自定义的二元操作。它提供了一种简便的方式来累积容器中的元素值，无论是进行简单的求和还是更复杂的累积操作。

函数原型

std::accumulate 提供了两种重载形式：

不带自定义操作的重载：
```
template< class InputIt, class T >
T accumulate(InputIt first, InputIt last, T init);
```
- InputIt first, InputIt last：定义了一个输入范围的开始和结束迭代器，[first, last) 是要累加的元素范围。
- T init：累加的初始值。
带自定义操作的重载：
```
template< class InputIt, class T, class BinaryOperation >
T accumulate(InputIt first, InputIt last, T init, BinaryOperation op);
```
- InputIt first, InputIt last：定义了一个输入范围的开始和结束迭代器，[first, last) 是要累加的元素范围。
- T init：累加的初始值。
- BinaryOperation op：一个二元操作，用于代替加法操作。这个操作接受两个参数（累加的中间结果和当前元素的值），返回它们的累加或合并结果。

返回值

std::accumulate 返回累加或累积操作的最终结果。

示例代码

不使用自定义操作的示例：

#include <numeric> // std::accumulate
#include <vector>
#include <iostream>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 计算所有元素的和，初始值为0
    int sum = std::accumulate(numbers.begin(), numbers.end(), 0);

    std::cout << "Sum: " << sum << std::endl; // 输出: Sum: 15

    return 0;
}

使用自定义操作的示例：

#include <numeric>
#include <vector>
#include <iostream>
#include <functional> // std::multiplies

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 使用std::multiplies来计算所有元素的乘积，初始值为1
    int product = std::accumulate(numbers.begin(), numbers.end(), 1, std::multiplies<int>());

    std::cout << "Product: " << product << std::endl; // 输出: Product: 120

    return 0;
}

在第二个示例中，我们使用了 std::multiplies<int>() 作为自定义操作，这样 std::accumulate 就计算了所有元素的乘积，而不是它们的和。

注意事项

如果范围 [first, last) 为空（即 first == last），函数直接返回初始值 init。
自定义操作应该不修改其操作对象，尤其是在使用引用传递时。这意味着操作应该是纯函数，不产生副作用。
在使用自定义操作时，初始值 init 的类型和操作的返回类型应该兼容，以避免意外的类型转换问题。

std::accumulate 是 C++ 标准库中定义在 <numeric> 头文件里的一个算法，用于计算给定范围内所有元素的累积结果，例如求和、求积或者更复杂的累积操作。这个函数非常灵活，因为它允许你指定一个自定义的操作来代替默认的加法操作。

最常用的实际场景

1. 求和：

最直接的使用场景是计算一个容器内所有元素的总和。

   std::vector<int> numbers = {1, 2, 3, 4, 5};
   int sum = std::accumulate(numbers.begin(), numbers.end(), 0);

2. 求积：

通过指定一个自定义的二元操作，如乘法，std::accumulate 可以用来计算元素的乘积。

    std::vector<int> numbers = {1, 2, 3, 4, 5};
    int product = std::accumulate(numbers.begin(), numbers.end(), 1, std::multiplies<int>());

3. 字符串拼接：

除了数字运算，std::accumulate 也常用于字符串的拼接操作。

    std::vector<std::string> strings = {"This ", "is ", "a ", "sentence."};
    std::string sentence = std::accumulate(strings.begin(), strings.end(), std::string());

4. 计算容器元素的平均值：

虽然std::accumulate本身不直接提供平均值计算，但可以先用它求和，再除以元素数量。

    std::vector<int> numbers = {1, 2, 3, 4, 5};
    double average = static_cast<double>(std::accumulate(numbers.begin(), numbers.end(), 0)) / numbers.size();

5. 自定义累积操作：

可以定义任意复杂的累积逻辑。例如，累加过程中可能需要对每个元素应用一个转换函数，或者在累加前对元素进行过滤。

   std::vector<int> numbers = {1, 2, 3, 4, 5};
   int customSum = std::accumulate(numbers.begin(), numbers.end(), 0,
                                   [](int a, int b) { return a + b * b; }); //

5. 计算方差：

方差是统计学中衡量数据分散程度的一个重要指标。计算方差通常分为两步：首先计算所有数值与其平均值之差的平方的平均值。假设我们有一个包含数值的 std::vector<double>，我们可以先使用 std::accumulate 计算平均值，然后再次使用它来计算方差：

	#include <numeric>
	#include <vector>
	#include <iostream>
	
	int main() {
	    std::vector<double> v = {1.0, 2.0, 3.0, 4.0, 5.0};
	    
	    // 计算平均值
	    double sum = std::accumulate(v.begin(), v.end(), 0.0);
	    double mean = sum / v.size();
	    
	    // 计算方差
	    double variance = std::accumulate(v.begin(), v.end(), 0.0,
	        [mean](double acc, double x) {
	            return acc + (x - mean) * (x - mean);
	        }) / v.size();
	
	    std::cout << "Variance: " << variance << std::endl;
	
	    return 0;
	}