Why is template argument deduction disabled with std::forward?

by

If you pass an rvalue reference to an object of type X to a template function that takes type T&& as its parameter, template argument deduction deduces T to be X. Therefore, the parameter has type X&&. If the function argument is an lvalue or const lvalue, the compiler deduces its type to be an lvalue reference or const lvalue reference of that type.

If std::forward used template argument deduction:

Since objects with names are lvalues the only time std::forward would correctly cast to T&& would be when the input argument was an unnamed rvalue (like 7 or func()). In the case of perfect forwarding the arg you pass to std::forward is an lvalue because it has a name. std::forward‘s type would be deduced as an lvalue reference or const lvalue reference. Reference collapsing rules would cause the T&& in static_cast<T&&>(arg) in std::forward to always resolve as an lvalue reference or const lvalue reference.

Example:

template<typename T>
T&& forward_with_deduction(T&& obj)
{
    return static_cast<T&&>(obj);
}

void test(int&){}
void test(const int&){}
void test(int&&){}

template<typename T>
void perfect_forwarder(T&& obj)
{
    test(forward_with_deduction(obj));
}

int main()
{
    int x;
    const int& y(x);
    int&& z = std::move(x);

    test(forward_with_deduction(7));    //  7 is an int&&, correctly calls test(int&&)
    test(forward_with_deduction(z));    //  z is treated as an int&, calls test(int&)

    //  All the below call test(int&) or test(const int&) because in perfect_forwarder 'obj' is treated as
    //  an int& or const int& (because it is named) so T in forward_with_deduction is deduced as int& 
    //  or const int&. The T&& in static_cast<T&&>(obj) then collapses to int& or const int& - which is not what 
    //  we want in the bottom two cases.
    perfect_forwarder(x);           
    perfect_forwarder(y);           
    perfect_forwarder(std::move(x));
    perfect_forwarder(std::move(y));
}

More Related Contents:

  1. push_back vs emplace_back
  2. Is std::unique_ptr required to know the full definition of T?
  3. Why can’t simple initialize (with braces) 2D std::array? [duplicate]
  4. Nice way to append a vector to itself
  5. Is the size of std::array defined by standard
  6. Why is the C++ initializer_list behavior for std::vector and std::array different?
  7. What does the standard library guarantee about self move assignment?
  8. Why use non-member begin and end functions in C++11?
  9. std::map emplace without copying value
  10. How to declare a vector of atomic in C++
  11. std::optional specialization for reference types
  12. What is the default hash function used in C++ std::unordered_map?
  13. C++11 STL containers and thread safety
  14. How do I erase elements from STL containers?
  15. What happens when you call data() on a std::vector?
  16. Comparing 3 modern c++ ways to convert integral values to strings
  17. The implementation of random_device in VS2010?
  18. Why can’t I replace std::map with std::unordered_map
  19. Are lambdas inlined like functions in C++?
  20. Why vector access operators are not specified as noexcept?
  21. Why isn’t std::array::size static?
  22. error for hash function of pair of ints
  23. Can we get the type of a lambda argument?
  24. Should std::unique_ptr be permitted
  25. stl container with std::unique_ptr’s vs boost::ptr_container
  26. STL algorithms: Why no additional interface for containers (additional to iterator pairs)?
  27. const auto std::initializer_list difference between Clang and GCC
  28. Using data member in lambda capture list inside a member function
  29. C++ priority_queue with lambda comparator error
  30. Can the ‘type’ of a lambda expression be expressed?

Leave a Comment