两个重载的 std::forward 是如何工作的？

Question

我在 std 库中找到了 std::forward 的以下实现：

// TEMPLATE FUNCTION forward
template<class _Ty> inline
constexpr _Ty&& forward(
    typename remove_reference<_Ty>::type& _Arg) _NOEXCEPT
{   // forward an lvalue as either an lvalue or an rvalue
return (static_cast<_Ty&&>(_Arg));
}

template<class _Ty> inline
constexpr _Ty&& forward(
    typename remove_reference<_Ty>::type&& _Arg) _NOEXCEPT
{   // forward an rvalue as an rvalue
static_assert(!is_lvalue_reference<_Ty>::value, "bad forward call");
return (static_cast<_Ty&&>(_Arg));
}

第一个功能显然有效，但第二个功能我找不到有用的示例。如果我尝试做这样的事情：

template<class _Ty> inline
constexpr _Ty&& my_forward(
   typename std::remove_reference<_Ty>::type&& _Arg) _NOEXCEPT
{   // forward an rvalue as an rvalue
   static_assert(!std::is_lvalue_reference<_Ty>::value, "bad forward call");
   return (static_cast<_Ty&&>(_Arg));
}

template<typename T>
T getRValue()
{
    return std::remove_reference<T>::type{};
}

template<typename T>
void setValue(T && i)
{
   my_forward<T>(getRValue<T>());
}

int main()
{
    int i = 1;
    setValue(i);
}

检查第二个函数何时被调用，我收到错误：

Error   C2664   '_Ty my_forward<T>(int &&) noexcept': cannot convert argument 1 from 'int' to 'int &&'

有人知道在什么情况下会调用第二个重载函数（按我的说法my_forward）吗？或者可能是一些很好的例子？顺便说一句，我的编译器是 MSVC 2015

谢谢大家的帮助！！

Answer 1

int bad_forward_call() {
  return std::forward<int&>(7);
}

这将调用该版本。

请注意，我将右值作为左值转发。不允许。

如果 T 是引用类型，您的 getRValue 无法获得右值。

Answer 2

我发现调用此函数的案例：

my_forward<int&>(8); // This calls forward(typename remove_reference<_Ty>::type&& _Arg)
But it won't compile 'cause we try convert rvalue to lvalue

my_forward<int&&>(8); // This calls forward(typename remove_reference<_Ty>::type&& _Arg)
But it compiles successfully

如果对某人有用，std::forward 的目的是将操作转发给另一个 class 或函数。

考虑以下示例：

template<typename T>
void precompute(T & t)
{
   std::cout << "lvalue reference";
}

template<typename T, 
         std::enable_if_t<!std::is_reference<T>::value, bool> = true>
void precompute(T && t)
{
   std::cout << "rvalue reference";
}

template<typename T>
void calculate(T && t)
{
   precompute(t); // Every time called precompute(T & t)
}

或者像这样：

template<typename T>
void precompute(T & t)
{
   std::cout << "lvalue reference";
}

template<typename T, 
         std::enable_if_t<!std::is_reference<T>::value, bool> = true>
void precompute(T && t)
{
   std::cout << "rvalue reference";
}

template<typename T>
void calculate(T && t)
{
   precompute(std::move(t)); // Every time called precompute(T && t)
}

如您所见，我们遇到了问题！！两个例子都不让我们满意。

在第一个例子中，每次都会调用lvalue函数，并且无法用rvalue.[=14=先调用]

在第二个例子中，每次都会调用rvalue函数，并且无法做任何事情来调用lvalue.

解决方案是将决策转发给被调用的函数：

template<typename T>
void precompute(T & t)
{
   std::cout << "lvalue reference";
}

template<typename T, 
         std::enable_if_t<!std::is_reference<T>::value, bool> = true>
void precompute(T && t)
{
   std::cout << "rvalue reference";
}

template<typename T>
void calculate(T && t)
{
   precompute(std::forward<T>(t)); // Will be called either precompute(T & t) or precompute(T && t) depends on type of t
}

在这种情况下，我们必须确保调用合适的版本。这就是我们转发的原因（意思是：“请检查 t 的类型，如果它是 rvalue -> 调用 rvalue 版本函数的，如果它是 lvalue -> 调用 lvalue 版本的函数 ") 此操作调用函数。

两个重载的 std::forward 是如何工作的？

How do two overloaded std::forward work?

c++

forward-declaration

c++11