Order of Evaluation for Fold Expressions

Question

Fold expressions seem to be a nice way to apply a function to each element of a tuple. However, if the applied function has side effects, the order of function invocations might be an important concern.

Consider:

#include <iostream>

template<typename... Ts>
void printStuff(Ts... args)
{
    ( ([](auto&& v) { std::cout << v << " "; })(args), ... );
    std::cout << '\n';
}

int main()
{
    printStuff("hello", 42, 1.5f);
    // expected output: hello 42 1.5
}

This seems to work.

But is the order of evaluation for the lambdas guaranteed here or could I end up with the values being flipped around in the output? Does the answer change if I used a different operator for chaining the commands together?

FYI, that fold expression can be re-written as: `([&]{ std::cout << args << " "; }(), ...);` — Elliott, Jun 14 '23 at 14:56

score 17 · Accepted Answer · edited Sep 05 '17 at 18:27

17

A right-fold over an operator expands like this: ... (arg0 op (arg1 op arg2)). So while the parens help, they don't guarantee anything about the order of the individual elements.

Therefore, it's all left up to op. And the comma operator (which is distinct from commas separating function arguments), even pre-C++17, is a hard sequence point. It ensures left-to-right evaluation with no cross-talk.

If you had instead used +, there would be no sequencing guarantees. So it depends on the operator you use. C++17 added a few more operators that have strict sequencing guarantees (<<, for example).

edited Sep 05 '17 at 18:27

T.C.

133,968
17
288
421

answered Sep 05 '17 at 13:38

Nicol Bolas

449,505
63
781
982

3

For reference: The proposal that gave us the stricter sequencing guarantees in C++17 is [P0145r3](https://wg21.link/P0145r3). This one also guarantees that overloading the comma operator will not remove the sequencing guarantees. – ComicSansMS Sep 05 '17 at 13:55

Order of Evaluation for Fold Expressions

1 Answers1