Recursion vs Fold Expressions

Fold expressions, introduced in C++17, provide a concise way to apply an operation to each element in a parameter pack without explicit recursion. They can be a good choice over recursive variadic function calls in certain situations:

When the operation is simple and can be expressed as a fold:

• Summing values
• Printing values
• Performing a logical AND or OR on values

When performance is a concern:

• Fold expressions can reduce the amount of generated code compared to recursive function calls
• Recursive variadic functions can lead to deep template instantiations and potentially slower compilation times

However, recursive variadic functions are still useful when:

• The operation is complex and can't be easily expressed as a fold
• You need more fine-grained control over the operation applied to each element
• You need to perform different operations depending on the position or type of the element

For example, consider printing the elements of a parameter pack:

1#include <iostream>
2
3// Recursive variadic function
4template <typename T, typename... Types>
5void PrintRecursive(T First, Types... Rest) {
6  std::cout << First;
7  if constexpr (sizeof...(Rest) > 0) {
8    std::cout << ", ";
9    PrintRecursive(Rest...);
10  }
11}
12
13// Fold expression
14template <typename... Types>
15void PrintFold(Types... Args) {
16  (std::cout << ... << Args);
17}
18
19int main() {
20  PrintRecursive(1, 2.0, "three");
21  std::cout << '\n';
22  PrintFold(1, 2.0, "three");
23}

11, 2, three
212three

The fold expression is more concise but doesn't add separators between elements. The recursive version allows for more control but is more verbose.

In general, prefer fold expressions for simple operations where performance is a concern. Use recursive variadic functions for more complex or fine-grained operations.