Fold expression vs compile recursion

Question

In c++17 we have fold expression which can greatly simplify code that could otherwise be implemented using compiler-recursion and SFINAE or overloading. For example, in the following code

#include <iostream>
#include <utility>

template<typename ...Args>
void printer(Args&&... args) {
  (std::cout << ... << args) << '\n';
}

void printer_cpp11() { }

template <typename First, typename ...Args>
void printer_cpp11(First&& first, Args&&... args)
{
  std::cout << first;
  printer_cpp11(std::forward<Args>(args)...);
}

int main()
{
  printer(3, 4, "hello");

  std::cout << std::endl;

  printer_cpp11(3, 4, "hello");

  return 0;
}

the c++17 function printer (taken from cpp reference) does exactly the same job as its c++11 version printer_cpp11.

At compile-time, several overloads of the function printer_cpp11 are generated, whereas a single function printer is needed using fold expression.

Is there an advantage in terms of performance in using fold expressions over the c++11-style? Or can one assume that the compiler inlines all the overloads of printer_cpp11, creating code with equivalent performance?

By `printer(std::forward(args)...);` I think you mean `printer_cpp11(std::forward(args)...);`, right? — L. F., Apr 16 '19 at 09:48
i think `printer_cpp11` should call itself, not the `printer` — bartop, Apr 16 '19 at 09:48
`printer_cpp11` will cause compiler to recursively instantiate `sizeof…(Args)` different template functions - this is a common case of template bloat and slow compilation times — user7860670, Apr 16 '19 at 09:50

score 1 · Accepted Answer · answered Apr 16 '19 at 14:26

Both versions would lead to the same codegen due to inlining, so run-time performance is exactly the same: https://gcc.godbolt.org/z/VIHTvZ (code cleaned of streams clutter).

However, compilation times and memory usage are expected to be way better with fold expressions than with recursive instantiations, and because of that, fold expression are generally preferred. Not to mention they are also provide for cleaner and easier to reason about code.

rmawatson · Answer 2 · 2019-04-16T22:03:08.367

1

Just to add to @SergeyA's answer you can alleviate the need for the recursion and the empty function in the c++11 version by doing something like...

template <typename ...Args>
void printer_cpp11_norecursion( Args&&... args)
{
  using do_ = int[];
  do_{0,
    (std::cout << args,0)...
  };
}

Which should generate the same results as both of the other versions (https://gcc.godbolt.org/z/hyAyiz) with possibly better compile times on c++11.

edited Apr 16 '19 at 22:03

answered Apr 16 '19 at 21:45

rmawatson

1,909
12
20

Thanks, it is the first time I see this syntax. You are initializing an array of ```int``` with 0s, discarding the results of the call to ```cout```, correct? – francesco Apr 17 '19 at 07:29

score 0 · Answer 3 · answered Apr 16 '19 at 10:27

The compiler will create a new instance of printer for each call with different arguments and in the function will unfold the operator<< calls:

https://godbolt.org/z/Zz9Ik9

You can also see what happens here: https://cppinsights.io/

But ultimately - measuring will reveal if it leads to a performance gain.

Fold expression vs compile recursion

3 Answers3