Return forwarding reference parameters - Best practice

Question

In the following scenario

template <class T>
? f(T&& a, T&& b)
{
    return a > b ? a : b; 
}

what would the optimum return type be ? My thoughts so far are :

1. Return by r value refs, perfectly forwarding the function arguments :

   template <class T>
   decltype(auto) f(T&& a, T&& b)
   {
       return a > b ? forward<T>(a) : forward<T>(b); 
   }
   

2. Move construct the return value :

   template <class T>
   auto f(T&& a, T&& b)
   {
       return a > b ? forward<T>(a) : forward<T>(b); 
   }
   

3. Try fo find a way to enable (N)RVOs (even though I think since I want to use the function arguments that's impossible)

Is there a problem with these solutions ? Is there a better one ? What's the best practice ?

Answer 1

For option 1, you need to use two template parameters to enable forwarding to happen when the two arguments have different value categories. It should be

template <typename T, typename U>
decltype(auto) f(T&& a, U&& b)
{
    return a > b ? std::forward<T>(a) : std::forward<U>(b);
}

What actually gets returned here is pretty tricky to work out. First you need to know the value categories of a and b, and what T and U get deduced as. Then whatever pairing you choose goes through the very complicated rules for the ternary operator. Finally, the output of that goes through the decltype rules to give you the actual return type of the function.

I did actually sit down and work it all out once, with a little help from SO. To the best of my recollection, it goes like this: the result will be a mutable lvalue reference if and only if a and b are lvalue references of compatible types; the result will be a const lvalue reference if one of a and b is a const lvalue reference and the other is any sort of reference; otherwise f will return a new value.

In other words, it does the right thing for any given pair of arguments -- probably because somebody sat down and wrote the rules exactly so that it would do the right thing in all cases.

Option 2 is doing to do exactly the same as option 1, except that the decltype rules don't come in to play, and the function will always return a new value -- plain auto never deduces to a reference.

I can't think of an option 3 that would work RVO-wise, since as you say you're using the arguments.

All in all, I think (1) is the answer you're looking for.

Answer 2

It depends on your intentions and the move awareness of your T. Each case is valid but there are differences in the behavior; this :

template <class T>
decltype(auto) f(T&& a, T&& b)
{
    return a > b ? forward<T>(a) : forward<T>(b); 
}

will perfectly forward an lvalue or rvalue reference resulting in no temporaries at all. If you put an inline there (or the compiler puts it for you) is like having the parameter in place. Against "first sight intuition" it won't produce any runtime error due to 'referencing' a dead stack object (for the rvalue case), since any temporaries we forward come from a caller above us (or below us, depends on how you think of stacks during function calls). On the other hand, this (in the rvalue case):

template <class T>
auto f(T&& a, T&& b)
{
    return a > b ? forward<T>(a) : forward<T>(b); 
}

will move-construct a value (auto will never deduce a & or &&) and if T is not move constructible, then you'll invoke a copy constructor (a copy will always be made if T is an lvalue reference). If you use f in an expression you'll produce an xvalue after all (and that makes me wonder if the compiler can use the initial rvalue, but I wouldn't bet on it).

Long story short, if the code that uses f is build in a way that handles both rvalue and lvalue references, I'd go with the first choice, after all that's the logic std::forward is built around plus you won't produce any copies when you have lvalue references.