Enforce parameter evaluation order while retaining lifetime of of expressions

Question

Given a macro FOO used like this:

std::string f1();
std::string f2();
FOO(f1().c_str(), f2().c_str());

Note: The type, std::string is only an example. FOO is generic and may not assume anything about types.

that is supposed to guarantee the order of evaluation of f1() and f2() by doing something like:

#define FOO(e1, e2) \
do {                \
    auto v1 = e1;   \
    auto v2 = e2;   \
    foo(e1, e2);    \
} while(0)

Edit: unfortunately foo can also be a template.

Unfortunately, that way the temporary returned by f1 is deleted and the c_str becomes invalid for the call to foo.

Is there a way to guarantee the order of expression evaluation for macro parameters while retaining all temporary lifetimes?

Surely there are overall better ways to approach that, but I'm specifically curious if there is a way to do this without reasoning about each of the usages of that macro in a large code base. Further I want to avoid handling specific types (i.e. not preserving const char* with strdup).

Answer 1

This is trivial in C++17, using std::apply:

#define FOO(...) std::apply(foo, decltype(std::forward_as_tuple(__VA_ARGS__)){__VA_ARGS__})

Example.

If you're using a pre-C++17 standard library, you can use the recipe for implementing std::apply at the above link.

If foo is a function template or an overload set, it can't be passed directly to std::apply so it has to be wrapped in a polymorphic lambda:

#define FOO(...) std::apply( \
    [](auto&&... args) -> decltype(auto) { return foo(std::forward<decltype(args)>(args)...); }, \
    decltype(std::forward_as_tuple(__VA_ARGS__)){__VA_ARGS__})

This works because the order of evaluation within {} braces is strict left-to-right. We use std::forward_as_tuple to determine the type of the tuple we want to pass to apply, but we construct it using list-initialization syntax.

If you're using a C++17 compiler with class template argument deduction, and don't need to worry about lvalue references, you could simplify this even further:

#define FOO(...) std::apply(foo, std::tuple{__VA_ARGS__})

Unfortunately, because the solution (without class template argument deduction) uses decltype, it won't work if the arguments involve lambda expressions. The only way I can see to make it work in this case is to use the sequencing between function arguments and function body, expanding FOO(e1, e2) to:

[&](auto&& p1) {
    return [&](auto&& p2) {
        return foo(std::forward<decltype(p1)>(p1), std::forward<decltype(p2)>(p2));
    }(e2);
}(e1)

This is actually possible using the incredible Boost.Preprocessor library:

#define FOO_IMPL_START(z,n,_) [&](auto&& p ## n) { return
#define FOO_IMPL_PARAM(z,n,_) std::forward<decltype(p ## n)>(p ## n)
#define FOO_IMPL_END(z,n,t) ; }(BOOST_PP_TUPLE_ELEM(n,t))
#define FOO_IMPL(n,t) \
    BOOST_PP_REPEAT(n, FOO_IMPL_START, _) \
    foo(BOOST_PP_ENUM(n, FOO_IMPL_PARAM, _)) \
    BOOST_PP_REPEAT(n, FOO_IMPL_END, BOOST_PP_TUPLE_REVERSE(t))
#define FOO(...) (FOO_IMPL(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__), BOOST_PP_VARIADIC_TO_TUPLE(__VA_ARGS__)))

Example.

Answer 2

Generalized solution:

struct Execute
{
    template <typename Func, typename ... Args>
    Execute(Func&& function, Args&& ... args)
    {
        std::forward<Func>(function)(std::forward<Args>(args) ...);
    }
};

#define FOO(...)                            \
    do {                                    \
            Execute{foo, __VA_ARGS__};      \
    } while(0)

 FOO(f1().c_str(), f2().c_str()); // this will be evaluated in order from left to right

The reason why it has to work: evaluation order of braced-init-list is guaranteed.

C++11 Standard, 8.5.4/4:

Within the initializer-list of a braced-init-list, the initializer-clauses, including any that result from pack expansions (14.5.3), are evaluated in the order in which they appear...

Unlike the accepted solution it works with C++11 without any shenanigans and do not need Boost.