Why does std::forward have two overloads?

by

A good place to start would be Howard Hinnant’s answer and paper on std::forward().

Your implementation handles all the normal use-cases correctly (T& --> T&, T const& --> T const&, and T&& --> T&&). What it fails to handle are common and easy-to-make errors, errors which would be very difficult to debug in your implementation but fail to compile with std::forward().

Given these definitions:

struct Object { };

template <typename T, typename = std::enable_if_t<!std::is_const<T>::value>>
T&& my_forward(const typename std::remove_reference<T>::type& val) {
    return static_cast<T&&>(const_cast<T&&>(val));
}

template <class T>
void foo(T&& ) { }

I can pass non-const references to const objects, both of the lvalue variety:

const Object o{};
foo(my_forward<Object&>(o));    // ok?? calls foo<Object&>
foo(std::forward<Object&>(o));  // error

and the rvalue variety:

const Object o{};
foo(my_forward<Object>(o));    // ok?? calls foo<Object>
foo(std::forward<Object>(o));  // error

I can pass lvalue references to rvalues:

foo(my_forward<Object&>(Object{}));   // ok?? calls foo<Object&>
foo(std::forward<Object&>(Object{})); // error

The first two cases lead to potentially modifying objects that were intended to be const (which could be UB if they were constructed const), the last case is passing a dangling lvalue reference.

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. Rvalue Reference is Treated as an Lvalue?
  4. make_unique and perfect forwarding
  5. What’s the difference between std::move and std::forward
  6. Difference between pointer and reference as thread parameter
  7. One VS2010 bug ? Allowing binding non-const reference to rvalue WITHOUT EVEN a warning?
  8. C++11 auto: what if it gets a constant reference?
  9. how to initialize a constexpr reference
  10. non-class rvalues always have cv-unqualified types
  11. In C++, what categories (lvalue, rvalue, xvalue, etc.) can expressions that produce temporaries of class type fall into?
  12. Capturing perfectly-forwarded variable in lambda
  13. Do rvalue references allow dangling references?
  14. Can I typically/always use std::forward instead of std::move?
  15. What is the difference between std::reference_wrapper and a simple pointer?
  16. On how to recognize Rvalue or Lvalue reference and if-it-has-a-name rule
  17. What are the main purposes of std::forward and which problems does it solve?
  18. Passing rvalues through std::bind
  19. What is the value category of the operands of C++ operators when unspecified?
  20. Isn’t the const modifier here unnecessary? [duplicate]
  21. Is it valid to bind non-const lvalue-references to rvalues in C++ 11?(modified)
  22. Why can’t I initialize a reference in an initializer list with uniform initialization?
  23. Should all/most setter functions in C++11 be written as function templates accepting universal references?
  24. How to determine programmatically if an expression is rvalue or lvalue in C++?
  25. prolonging the lifetime of temporaries
  26. Rvalues, lvalues and formal definitions
  27. How to combine std::bind(), variadic templates, and perfect forwarding?
  28. How does std::forward receive the correct argument?
  29. Is it safe to link C++17, C++14, and C++11 objects
  30. Can I safely use OpenMP with C++11?

Leave a Comment