Lesson 3

Welcome back! In our previous lesson, we explored the fundamentals of STL algorithms in C++ and how they can enhance your code's efficiency and readability. Today, we will continue this journey by diving into more advanced STL algorithms, with a focus on `std::accumulate`

.

By the end of this lesson, you should understand:

- How to use
`std::accumulate`

to find the sum of numbers in a vector. - Advanced uses of
`std::accumulate`

with custom functionalities using lambda expressions.

`std::accumulate`

in the `<numeric>`

header performs a fold or reduction operation over a range of elements. It combines the elements using a binary operation, starting with an initial value.

The basic syntax of `std::accumulate`

:

C++`1std::accumulate(first, last, init);`

**First**: Iterator to the beginning of the range.**Last**: Iterator to the end of the range.**Init**: Initial value to start the accumulation.

Here is an example using `std::accumulate`

to sum the elements of a vector:

C++`1#include <iostream> 2#include <vector> 3#include <numeric> // For std::accumulate 4 5int main() { 6 std::vector<int> data = {1, 2, 3, 4, 5}; 7 8 // Using std::accumulate 9 int sum = std::accumulate(data.begin(), data.end(), 0); 10 std::cout << "Sum: " << sum << '\n'; // Sum: 15 11 12 return 0; 13}`

**Explanation:**

**Initialize a vector**: We initialize a vector`data`

with`{1, 2, 3, 4, 5}`

.**Use**: We pass the range defined by`std::accumulate`

`data.begin()`

and`data.end()`

, and the initial value`0`

.**Result**: The function sums the elements starting from`0`

. The final sum,`15`

, is outputted.

Consider computing the product of elements:

C++`1#include <iostream> 2#include <vector> 3#include <numeric> // For std::accumulate 4#include <functional> // For std::multiplies 5 6int main() { 7 std::vector<int> data = {1, 2, 3, 4, 5}; 8 9 // Using std::accumulate with std::multiplies 10 int product = std::accumulate(data.begin(), data.end(), 1, std::multiplies<int>()); 11 std::cout << "Product: " << product << '\n'; // Product: 120 12 13 return 0; 14}`

**Explanation:**

**Initial Value**: Use`1`

as the initial value.**Custom Operation**: Use`std::multiplies<int>()`

for multiplication.

Let's look at custom logic with lambda expressions.

Finding the Sum of Squares:

C++`1#include <iostream> 2#include <vector> 3#include <numeric> // For std::accumulate 4 5int main() { 6 std::vector<int> data = {1, 2, 3, 4, 5}; 7 8 // Using std::accumulate with a lambda expression 9 int sum_of_squares = std::accumulate(data.begin(), data.end(), 0, [](int sum, int val) { 10 return sum + val * val; 11 }); 12 std::cout << "Sum of Squares: " << sum_of_squares << '\n'; // Sum of Squares: 55 13 14 return 0; 15}`

**Custom Lambda**: We pass a lambda that computes the square of each element and adds it to the sum. In the lambda expression:

**sum**: Accumulator that holds the ongoing sum of squares.**val**: Current element from the vector being processed.

Combining two vectors into a single accumulated sum:

C++`1#include <iostream> 2#include <vector> 3#include <numeric> // For std::accumulate 4 5int main() { 6 std::vector<int> data1 = {1, 2, 3, 4, 5}; 7 std::vector<int> data2 = {6, 7, 8, 9, 10}; 8 9 // Combining two vectors element-wise and accumulating the result 10 int combined_sum = std::accumulate(data1.begin(), data1.end(), 0, [&data2, i = 0](int sum, int val) mutable { 11 return sum + val + data2[i++]; 12 }); 13 std::cout << "Combined Sum: " << combined_sum << '\n'; // Combined Sum: 55 14 15 return 0; 16}`

**Lambda with Capture**: We capture `data2`

by reference and use a mutable lambda to add elements of both vectors. In the lambda expression:

**sum**: Accumulator that holds the ongoing sum of combined elements from both vectors.**val**: Current element from`data1`

being processed.**data2[i++]**: Corresponding element from`data2`

being added, with**mutable**allowing us to modify the captured`i`

to iterate through`data2`

.

In this lesson, we explored:

- The importance and utility of STL algorithms in C++.
- How to use
`std::accumulate`

for simple and complex operations. - Examples with built-in and custom operations via lambda expressions.

Now that you've learned to use `std::accumulate`

, it's time to practice. Move on to the hands-on exercises to reinforce your understanding and enhance your skills. Good luck, and happy coding!