How does std::forward receive the correct argument?

by

It does bind to the overload of std::forward taking an lvalue:

template <class T>
constexpr T&& forward(remove_reference_t<T>& t) noexcept;

It binds with T == int. This function is specified to return:

static_cast<T&&>(t)

Because the T in f deduced to int. So this overload casts the lvalue int to xvalue with:

static_cast<int&&>(t)

Thus calling the g(int&&) overload.

In summary, the lvalue overload of std::forward may cast its argument to either lvalue or rvalue, depending upon the type of T that it is called with.

The rvalue overload of std::forward can only cast to rvalue. If you try to call that overload and cast to lvalue, the program is ill-formed (a compile-time error is required).

So overload 1:

template <class T>
constexpr T&& forward(remove_reference_t<T>& t) noexcept;

catches lvalues.

Overload 2:

template <class T> constexpr T&& forward(remove_reference_t<T>&& t) noexcept;

catches rvalues (which is xvalues and prvalues).

Overload 1 can cast its lvalue argument to lvalue or xvalue (the latter which will be interpreted as an rvalue for overload resolution purposes).

Overload 2 can can cast its rvalue argument only to an xvalue (which will be interpreted as an rvalue for overload resolution purposes).

Overload 2 is for the case labeled “B. Should forward an rvalue as an rvalue” in N2951. In a nutshell this case enables:

std::forward<T>(u.get());

where you are unsure if u.get() returns an lvalue or rvalue, but either way if T is not an lvalue reference type, you want to move the returned value. But you don’t use std::move because if T is an lvalue reference type, you don’t want to move from the return.

I know this sounds a bit contrived. However N2951 went to significant trouble to set up motivating use cases for how std::forward should behave with all combinations of the explicitly supplied template parameter, and the implicitly supplied expression category of the ordinary parameter.

It isn’t an easy read, but the rationale for each combination of template and ordinary parameters to std::forward is in N2951. At the time this was controversial on the committee, and not an easy sell.

The final form of std::forward is not exactly what N2951 proposed. However it does pass all six tests presented in N2951.

More Related Contents:

  1. What are the main purposes of using std::forward and which problems it solves?
  2. What does T&& (double ampersand) mean in C++11?
  3. C++11 make_pair with specified template parameters doesn’t compile
  4. Can I typically/always use std::forward instead of std::move?
  5. What are the main purposes of std::forward and which problems does it solve?
  6. How to combine std::bind(), variadic templates, and perfect forwarding?
  7. Optimization code for a debug function (c++11 with templates) [closed]
  8. Check if a class has a member function of a given signature
  9. std::enable_if to conditionally compile a member function
  10. C++11 does not deduce type when std::function or lambda functions are involved
  11. Do rvalue references to const have any use?
  12. What is the partial ordering procedure in template deduction
  13. Syntax for universal references
  14. When to use std::forward to forward arguments?
  15. C++11: I can go from multiple args to tuple, but can I go from tuple to multiple args? [duplicate]
  16. non-class rvalues always have cv-unqualified types
  17. Capturing perfectly-forwarded variable in lambda
  18. What does this variadic template code do?
  19. SFINAE works differently in cases of type and non-type template parameters
  20. On how to recognize Rvalue or Lvalue reference and if-it-has-a-name rule
  21. Is there a compiler bug exposed by my implementation of an is_complete type trait?
  22. Returning a void?
  23. How to typedef a template class? [duplicate]
  24. Should all/most setter functions in C++11 be written as function templates accepting universal references?
  25. using SFINAE for template class specialisation
  26. Why does the template-id in “A=0” not compile without space because of the greater-or-equal-than operator “>=”?
  27. Specializing a template on a lambda in C++0x
  28. Overloading on R-value references and code duplication
  29. Concatenate compile-time strings in a template at compile time?
  30. using extern template (C++11) to avoid instantiation

Leave a Comment