When to use std::forward to forward arguments?

by

Use it like your first example:

template <typename T> void f(T && x)
{
  g(std::forward<T>(x));
}

template <typename ...Args> void f(Args && ...args)
{
  g(std::forward<Args>(args)...);
}

That’s because of the reference collapsing rules: If T = U&, then T&& = U&, but if T = U&&, then T&& = U&&, so you always end up with the correct type inside the function body. Finally, you need forward to turn the lvalue-turned x (because it has a name now!) back into an rvalue reference if it was one initially.

You should not forward something more than once however, because that usually does not make sense: Forwarding means that you’re potentially moving the argument all the way through to the final caller, and once it’s moved it’s gone, so you cannot then use it again (in the way you probably meant to).

More Related Contents:

  1. How to emulate C array initialization “int arr[] = { e1, e2, e3, … }” behaviour with std::array?
  2. C++11 make_pair with specified template parameters doesn’t compile
  3. What is “Expression SFINAE”?
  4. How to initialize std::array elegantly if T is not default constructible?
  5. Why should I avoid std::enable_if in function signatures
  6. Detecting constexpr with SFINAE
  7. Alias template specialisation
  8. declare template friend function of template class
  9. What do compilers do with compile-time branching?
  10. Is it possible to “store” a template parameter pack without expanding it?
  11. Parameter pack must be at the end of the parameter list… When and why?
  12. Can lambda functions be templated?
  13. C++11: Compile Time Calculation of Array
  14. How to reverse the order of arguments of a variadic template function?
  15. Doing a static_assert that a template type is another template
  16. Template specialization and enable_if problems [duplicate]
  17. Populate An Array Using Constexpr at Compile-time
  18. Disambiguate overloaded member function pointer being passed as template parameter
  19. Why do auto and template type deduction differ for braced initializers?
  20. C++ parameter pack, constrained to have instances of a single type?
  21. Forwarding all constructors in C++0x
  22. How can I expand call to variadic template base classes?
  23. Lambda expressions as class template parameters
  24. Using export keyword with templates
  25. How to make a variadic is_same?
  26. std::remove_const with const references
  27. Dependent name resolution & namespace std / Standard Library
  28. Specialized template function with deleted “general” case fails to compile with g++
  29. How does std::forward receive the correct argument?
  30. Why can’t I use alias from a base class in a derived class with templates?

Leave a Comment