Using Fold with Custom Data Types

Yes, fold_left() and fold_right() can be used with custom data types, provided that the custom data type supports the required binary operation.

Requirements for Custom Data Types

• The custom data type must support the operation used in the fold function. This means that if you are using std::plus<>, your custom type must have an operator+.
• The initial value and the elements in the range must be compatible with the binary operation.

Example

Let’s create a custom data type Accumulator that supports the addition operation. We’ll use this type with fold_left() to demonstrate how folding works with custom data types.

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5struct Accumulator {
6  int sum;
7  int count;
8
9  Accumulator operator+(int n) const {
10    return Accumulator{sum + n, count + 1}; }
11
12  void log() const {
13    std::cout << "Count: " << count
14      << "\nSum: " << sum << "\n";
15  }
16};
17
18int main() {
19  std::vector<int> numbers{1, 2, 3, 4, 5};
20
21  Accumulator result = std::ranges::fold_left(
22    numbers, Accumulator{}, std::plus<>());
23
24  result.log();
25}

1Count: 5
2Sum: 15

Explanation

• The Accumulator struct has two members: sum and count.
• We define the operator+ to allow adding an integer to an Accumulator object, which updates the sum and count.
• The log() function is used to print the current state of the Accumulator.

In the main() function, we use std::ranges::fold_left() to combine elements of the numbers vector using an Accumulator as the initial value. The custom operator+ ensures that each element of the vector is added to the Accumulator, updating the sum and count accordingly.

Using Different Operations

You can also define other operations for your custom data types. For example, if you have a custom type that represents a complex number, you can define an operator* for multiplication and use it with fold_left().

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5struct Complex {
6  double real;
7  double imag;
8
9  Complex operator*(const Complex& other) const {
10    return Complex{
11      real * other.real - imag * other.imag,
12      real * other.imag + imag * other.real
13    };
14  }
15};
16
17int main() {
18  std::vector<Complex> numbers{
19    {1, 2}, {3, 4}, {5, 6}};
20
21  Complex initial{1, 0};
22  Complex result = std::ranges::fold_left(
23    numbers, initial, std::multiplies<>());
24
25  std::cout << "Result: (" << result.real
26    << ", " << result.imag << ")";
27}

1Result: (-85, 20)

In summary, fold_left() and fold_right() can be used with custom data types as long as the required operations are defined. This allows for flexible and powerful ways to process collections of custom objects.