Difference Between Reduce and Fold Algorithms

The main difference between std::reduce() and the new fold algorithms introduced in C++23 lies in the additional flexibility and control provided by the latter.

The std::reduce() Algorithm

• This function is part of the C++17 standard and is used to reduce a range of elements to a single value using a binary operation.
• It processes elements in a range sequentially, combining them using the provided operation.
• The initial value can be specified, but it does not offer variations for different folding strategies.

New Fold Algorithms in C++23

C++23 introduced six new fold algorithms to provide more control and options when reducing collections of elements. These algorithms are:

1. std::ranges::fold_left()
2. std::ranges::fold_left_first()
3. std::ranges::fold_left_with_iter()
4. std::ranges::fold_left_first_with_iter()
5. std::ranges::fold_right()
6. std::ranges::fold_right_last()

The key differences are:

Direction of Folding:

• fold_left() processes elements from left to right, starting with the first element.
• fold_right() processes elements from right to left, starting with the last element.

Initial Value:

• fold_left_first() and fold_right_last() allow folding without explicitly providing an initial value by using the first or last element of the range, respectively.

Iterator and Sentinel:

• fold_left_with_iter() and fold_left_first_with_iter() return additional information about the iterator where the folding process stopped. This is useful when you need to know where the range ended.

Handling Empty Ranges:

• The fold algorithms return a std::optional when using fold_left_first() or fold_right_last(), which helps in handling cases where the input range might be empty.

Here's a simple example comparing std::reduce() and std::ranges::fold_left():

1#include <algorithm>
2#include <iostream>
3#include <numeric>
4#include <vector>
5
6int main() {
7  std::vector<int> numbers{1, 2, 3, 4, 5};
8
9  // Using std::reduce()
10  int reduce_result = std::reduce(
11    numbers.begin(), numbers.end(), 0, std::plus<>());
12  std::cout << "Reduce result: "
13    << reduce_result << "\n";
14
15  // Using std::ranges::fold_left()
16  int fold_left_result = std::ranges::fold_left(
17    numbers, 0, std::plus<>());
18  std::cout << "Fold left result: "
19    << fold_left_result << "\n";
20}

1Reduce result: 15
2Fold left result: 15

In summary, the new fold algorithms in C++23 offer more flexibility and control over the folding process, with variations that handle different scenarios, such as folding direction and range termination, more gracefully than std::reduce().