How to Use accumulate in C++: Syntax and Examples

In C++, accumulate is a function from the <numeric> header that sums or combines elements in a range. You use it by passing the start and end iterators of a container and an initial value, optionally with a custom operation.

Syntax

The accumulate function has two main forms:

• accumulate(begin, end, init): sums elements from begin to end, starting with init.
• accumulate(begin, end, init, binary_op): combines elements using binary_op instead of addition.

Here, begin and end are iterators marking the range, init is the starting value, and binary_op is a function or lambda that takes two arguments.

cpp

#include <numeric>
#include <vector>

// Basic syntax
// auto result = std::accumulate(begin, end, init);
// Using custom operation
// auto result = std::accumulate(begin, end, init, binary_op);

Example

This example shows how to sum integers in a vector using accumulate, and how to multiply them using a custom lambda function.

cpp

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

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

    // Sum all elements starting from 0
    int sum = std::accumulate(numbers.begin(), numbers.end(), 0);

    // Multiply all elements starting from 1
    int product = std::accumulate(numbers.begin(), numbers.end(), 1, [](int a, int b) {
        return a * b;
    });

    std::cout << "Sum: " << sum << "\n";
    std::cout << "Product: " << product << "\n";

    return 0;
}

Output

Sum: 15
Product: 120

Common Pitfalls

Common mistakes when using accumulate include:

• Forgetting to include the <numeric> header.
• Using the wrong initial value, which can change the result (e.g., starting sum with 1 instead of 0).
• Not specifying the correct type for the initial value, causing unexpected type conversions.
• Misusing the custom operation by not matching the expected function signature.

cpp

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

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

    // Wrong initial value for sum (starts at 1 instead of 0)
    int wrong_sum = std::accumulate(nums.begin(), nums.end(), 1);

    // Correct initial value
    int correct_sum = std::accumulate(nums.begin(), nums.end(), 0);

    std::cout << "Wrong sum (starts at 1): " << wrong_sum << "\n";
    std::cout << "Correct sum (starts at 0): " << correct_sum << "\n";

    return 0;
}

Output

Wrong sum (starts at 1): 7
Correct sum (starts at 0): 6

Quick Reference

accumulate is used to combine elements in a range.

• accumulate(begin, end, init): sums elements starting from init.
• accumulate(begin, end, init, binary_op): combines elements using binary_op.
• Include <numeric> header.
• Initial value type affects the result type.

Key Takeaways

Use accumulate from <numeric> to sum or combine container elements easily.

Always provide the correct initial value to get the expected result.

You can customize the operation by passing a binary function or lambda.

Remember to include the <numeric> header to use accumulate.

The type of the initial value determines the result type and can affect calculations.