C++ accumulate算法累加与自定义操作-C++-PHP中文网

std::accumulate 是 C++ 标准库中的累积算法，通过初始值和二元操作将容器元素归约为单一结果，支持自定义操作如乘积、字符串拼接、最大值查找及复杂对象处理，适用于函数式风格的聚合计算，但不适用于需副作用或提前退出的循环场景。

c++ accumulate算法累加与自定义操作

C++的

accumulate

登录后复制

算法，说白了，就是个能帮你把容器里一堆东西“揉”成一个结果的工具。它最常见的用法是累加求和，但它的本事远不止于此，通过自定义操作，你能让它干很多意想不到的活儿。我个人觉得，它就像一个多功能搅拌机，你放进去什么，再给它一个搅拌的规则，它就能给你变出你想要的东西。

解决方案

std::accumulate

登录后复制

是 C++ 标准库

<numeric>

登录后复制

头文件中的一个算法，它能够对指定范围内的元素进行累积操作。它有两个主要的重载形式：

基本累加形式：

accumulate(first, last, init)

登录后复制

这个版本会将

init

登录后复制

作为初始值，然后依次将范围

[first, last)

登录后复制

中的每个元素加到累积值上。它默认使用加法操作符

登录后复制

。

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

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    // 初始值为0，对vector中的所有元素进行累加
    int sum = std::accumulate(numbers.begin(), numbers.end(), 0);
    std::cout << "Sum: " << sum << std::endl; // 输出：Sum: 15

    // 初始值为10，对vector中的所有元素进行累加
    int sum_from_ten = std::accumulate(numbers.begin(), numbers.end(), 10);
    std::cout << "Sum from ten: " << sum_from_ten << std::endl; // 输出：Sum from ten: 25
    return 0;
}

登录后复制

自定义操作形式：

accumulate(first, last, init, binary_op)

登录后复制

这个版本同样以

init

登录后复制

为初始值，但它允许你提供一个二元操作（

binary_op

登录后复制

），这个操作会接受当前的累积值和当前元素作为参数，并返回新的累积值。这才是

accumulate

登录后复制

真正强大之处。

#include <iostream>
#include <vector>
#include <numeric> // For std::accumulate
#include <string>  // For string concatenation
#include <functional> // For std::multiplies

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

    // 自定义乘法操作，计算乘积，初始值为1
    long long product = std::accumulate(numbers.begin(), numbers.end(), 1LL, std::multiplies<long long>());
    std::cout << "Product: " << product << std::endl; // 输出：Product: 120 (1*2*3*4*5)

    std::vector<std::string> words = {"Hello", ", ", "world", "!"};
    // 自定义字符串拼接操作，初始值为空字符串
    std::string sentence = std::accumulate(words.begin(), words.end(), std::string(""),
                                           [](const std::string& current_sum, const std::string& element) {
                                               return current_sum + element;
                                           });
    std::cout << "Sentence: " << sentence << std::endl; // 输出：Sentence: Hello, world!

    // 也可以使用lambda表达式实现更复杂的逻辑，例如统计偶数个数
    int even_count = std::accumulate(numbers.begin(), numbers.end(), 0,
                                     [](int count, int num) {
                                         return count + (num % 2 == 0 ? 1 : 0);
                                     });
    std::cout << "Even count: " << even_count << std::endl; // 输出：Even count: 2
    return 0;
}

登录后复制

C++

accumulate

登录后复制

算法如何实现自定义操作？

实现

accumulate

登录后复制

的自定义操作，关键在于理解并提供一个符合其要求的二元操作符（binary operation）。这个操作符可以是函数对象（functor）、函数指针，或者在现代 C++ 中最常用的 Lambda 表达式。它的签名通常是

ResultType operation(AccumulatedValueType current_sum, ElementType current_element)

登录后复制

。

当你提供一个自定义的

binary_op

登录后复制

时，

accumulate

登录后复制

的内部逻辑大致是这样的：它会从你给定的

init

登录后复制

值开始，然后遍历容器中的每一个元素。对于每个元素，它会调用

binary_op(当前累积值, 当前元素)

登录后复制

，并将这个调用的结果作为新的累积值。这个过程会一直重复，直到遍历完所有元素，最终返回那个累积值。

立即学习“C++免费学习笔记（深入）”；

举个例子，假设我们想计算一个

std::vector<double>

登录后复制

中所有元素的平均值。虽然直接用

accumulate

登录后复制

求和再除以数量更直观，但我们也可以“硬核”地用

accumulate

登录后复制

来实现一个累积和计数的复合操作。不过，更典型的自定义操作会更直接，比如找出最大值。

#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm> // For std::max

int main() {
    std::vector<double> data = {3.14, 1.618, 2.718, 0.577};

    // 找出vector中的最大值
    // 初始值可以设置为一个足够小的值，或者直接用第一个元素
    // 这里我们用lambda表达式来做比较操作
    double max_val = std::accumulate(data.begin() + 1, data.end(), data[0],
                                     [](double current_max, double element) {
                                         return std::max(current_max, element);
                                     });
    std::cout << "Max value: " << max_val << std::endl; // 输出：Max value: 3.14

    // 也可以计算所有元素的平方和
    double sum_of_squares = std::accumulate(data.begin(), data.end(), 0.0,
                                            [](double current_sum, double element) {
                                                return current_sum + (element * element);
                                            });
    std::cout << "Sum of squares: " << sum_of_squares << std::endl; // 输出：Sum of squares: 21.0664
    return 0;
}

登录后复制

这里，Lambda 表达式

[](double current_max, double element){ return std::max(current_max, element); }

登录后复制

就是我们自定义的二元操作。它接收当前的累积最大值

current_max

登录后复制

和当前元素

element

登录后复制

，然后返回两者中较大的那个。这个例子展示了

accumulate

登录后复制

不仅仅是做简单的加法，它能做任何符合二元操作模式的“聚合”任务。

accumulate

登录后复制

与传统循环或更现代的算法相比，优势与局限性何在？

当我第一次接触

accumulate

登录后复制

的自定义操作时，心里就嘀咕，这不就是个带回调的循环吗？但用着用着，我开始体会到它的一些微妙之处。

优势：

绘蛙

电商场景的AI创作平台，无需高薪聘请商拍和文案团队，使用绘蛙即可低成本、批量创作优质的商拍图、种草文案

179

查看详情

简洁性和表达力： 对于累积操作，尤其是那些可以被归结为“前一个结果与当前元素”的关系的，
```
accumulate
```
登录后复制
写出来代码非常紧凑，而且意图清晰。它直接告诉你，我正在“累积”什么。相比于手动写
```
for
```
登录后复制
循环，它减少了迭代器管理、初始化和最终返回结果的样板代码。比如，一个简单的求和，用
```
accumulate
```
登录后复制
远比
```
for (int x : vec) sum += x;
```
登录后复制
来得更函数式，也更不易出错（比如忘记初始化
```
sum
```
登录后复制
）。
函数式编程风格：
```
accumulate
```
登录后复制
鼓励你以函数式的方式思考问题：输入一个范围，一个初始值，一个操作，然后得到一个结果。这有助于编写更纯粹、副作用更少的代码，特别是在现代 C++ 中，这种风格越来越受到推崇。
可读性： 对于熟悉标准库算法的开发者来说，看到
```
std::accumulate
```
登录后复制
就能立刻明白这段代码是在对一个范围进行归约操作，而不是一个普通的遍历。
潜在的优化： 理论上，标准库的实现者可以对
```
accumulate
```
登录后复制
进行优化，例如在某些情况下（如
```
std::reduce
```
登录后复制
，它是
```
accumulate
```
登录后复制
的并行版本）进行并行化。虽然
```
std::accumulate
```
登录后复制
本身不是并行算法，但其接口设计为后续的并行算法提供了基础。

局限性：

不适用于所有循环场景：
```
accumulate
```
登录后复制
的核心是“归约”成一个单一值。如果你的循环需要执行副作用（例如打印、修改容器、网络请求），或者需要提前退出循环，那么
```
accumulate
```
登录后复制
就不适合了。它不是一个通用的循环替代品。
初始值的选择： 初始值
```
init
```
登录后复制
的类型和值至关重要。如果选择不当，可能会导致结果错误或者类型不匹配。比如计算乘积，初始值必须是
```
1
```
登录后复制
而不是
```
0
```
登录后复制
。对于某些复杂类型，构造一个合适的初始值可能需要一些思考。
可读性下降的风险： 虽然对于简单的累加操作可读性很高，但如果自定义的
```
binary_op
```
登录后复制
逻辑过于复杂，或者 Lambda 表达式内部嵌套了太多逻辑，反而会降低代码的可读性，甚至不如一个结构清晰的
```
for
```
登录后复制
循环。我见过一些代码，为了“炫技”而强行用
```
accumulate
```
登录后复制
实现复杂逻辑，结果维护起来简直是噩梦。
性能考量： 对于极度性能敏感的场景，尤其是在旧编译器或特定平台上，手动优化的
```
for
```
登录后复制
循环有时可能略快于
```
accumulate
```
登录后复制
，因为
```
accumulate
```
登录后复制
可能会引入一些函数调用开销。然而，现代编译器通常能很好地优化标准库算法，这种差异往往微乎其微。更重要的是，对于大规模数据并行归约，应该考虑
```
std::reduce
```
登录后复制
或
```
std::transform_reduce
```
登录后复制
。

总的来说，

accumulate

登录后复制

是一个非常棒的工具，尤其是在你需要将一系列元素“折叠”成一个结果时。但就像任何工具一样，理解它的适用场景和局限性，才能真正发挥它的威力，而不是盲目地滥用它。我个人觉得，当你发现自己写了一个

for

登录后复制

循环，它的主要目的是计算一个总和、一个乘积、一个最大/最小值，或者将一系列元素拼接起来时，就应该考虑

accumulate

登录后复制

了。

accumulate

登录后复制

在处理不同数据类型和复杂对象时的表现如何？

accumulate

登录后复制

在处理不同数据类型和复杂对象时，其核心能力并没有改变，依然是基于你提供的二元操作来“揉”数据。它的灵活性主要体现在

binary_op

登录后复制

的设计上。

基本数据类型： 对于

int

登录后复制

double

登录后复制

float

登录后复制

等基本数值类型，

accumulate

登录后复制

表现得非常自然，无论是累加、累乘，还是其他简单的数值操作，都非常直观。类型推导通常也没什么问题，只要初始值类型设置得当。

#include <iostream>
#include <vector>
#include <numeric>

int main() {
    std::vector<double> prices = {19.99, 29.50, 5.00, 12.75};
    double total_cost = std::accumulate(prices.begin(), prices.end(), 0.0);
    std::cout << "Total cost: " << total_cost << std::endl; // 输出：Total cost: 67.24
    return 0;
}

登录后复制

字符串类型： 字符串拼接是

accumulate

登录后复制

处理复杂对象的一个经典例子。由于

std::string

登录后复制

支持

登录后复制

操作符进行拼接，所以

accumulate

登录后复制

可以很方便地实现字符串的连接。

#include <iostream>
#include <vector>
#include <numeric>
#include <string>

int main() {
    std::vector<std::string> parts = {"The ", "quick ", "brown ", "fox."};
    std::string full_sentence = std::accumulate(parts.begin(), parts.end(), std::string(""));
    std::cout << "Full sentence: " << full_sentence << std::endl; // 输出：Full sentence: The quick brown fox.
    return 0;
}

登录后复制

这里需要注意的是，如果

init

登录后复制

是一个 C 风格字符串字面量（例如

""

登录后复制

），它会被推断为

const char*

登录后复制

，导致后续的

登录后复制

操作符行为不符合预期。所以，明确地用

std::string("")

登录后复制

来初始化非常重要。

自定义类或结构体： 这是

accumulate

登录后复制

真正展现其灵活性的地方。只要你的自定义类支持你想要执行的二元操作，或者你可以提供一个 Lambda 表达式/函数对象来定义这个操作，

accumulate

登录后复制

就能工作。

假设我们有一个

Product

登录后复制

结构体，我们想计算所有产品的总库存价值。

#include <iostream>
#include <vector>
#include <numeric>
#include <string>

struct Product {
    std::string name;
    double price;
    int quantity;

    double get_value() const {
        return price * quantity;
    }
};

int main() {
    std::vector<Product> inventory = {
        {"Laptop", 1200.0, 5},
        {"Mouse", 25.0, 50},
        {"Keyboard", 75.0, 20}
    };

    // 计算总库存价值
    // 初始值是0.0，累加的是每个产品的价值
    double total_inventory_value = std::accumulate(inventory.begin(), inventory.end(), 0.0,
                                                   [](double current_total, const Product& p) {
                                                       return current_total + p.get_value();
                                                   });
    std::cout << "Total inventory value: " << total_inventory_value << std::endl; // 输出：Total inventory value: 7650
    return 0;
}

登录后复制

在这个例子中，

accumulate

登录后复制

遍历

Product

登录后复制

对象，但我们自定义的 Lambda 表达式负责从每个

Product

登录后复制

对象中提取

get_value()

登录后复制

并将其加到累积总和中。这完美展示了

accumulate

登录后复制

能够处理复杂对象的“内部”数据，并将其归约为一个简单的数值。

需要注意的细节：

初始值类型：
```
accumulate
```
登录后复制
的结果类型是由
```
init
```
登录后复制
参数的类型决定的。如果你用
```
0
```
登录后复制
作为初始值来累加
```
double
```
登录后复制
类型的数据，结果可能是
```
int
```
登录后复制
，导致精度丢失。所以，对于
```
double
```
登录后复制
累加，初始值应为
```
0.0
```
登录后复制
。
操作符重载： 如果你的自定义类需要进行默认的加法操作，你可以重载
```
operator+
```
登录后复制
。但通常情况下，使用 Lambda 表达式或函数对象来定义特定的聚合逻辑更为灵活，也避免了对类本身的侵入性修改。
性能： 对于复杂对象的累积，性能瓶颈通常不在
```
accumulate
```
登录后复制
算法本身，而在于你
```
binary_op
```
登录后复制
内部执行的操作。如果
```
binary_op
```
登录后复制
涉及大量计算或资源分配，那么这部分会是主要的性能开销。