Как std:: forward получает правильный аргумент?

почему вызов не привязывается к перегрузке std::forward что занимает lvalue?

он делает именно это, но std::forward не вывести его аргумент шаблона, вы говорите ему, какой это тип, и вот где происходит магия. Вы передаете prvalue f() так f() выводит [T = int]. Затем он вызывает перегрузку lvalue forward, и из-за ссылка рушатся оба типа возврата и static_cast<T&&> это произойдет внутри forward будет типа int&&, таким образом вызывая void g(int&&) перегрузка.

если вы должны были передать lvalue в f()

int x = 0;
f(x);

f() выводит [T = int&], снова та же перегрузка lvalue forward вызывается, но на этот раз тип возврата и static_cast<T&&> как int&, опять же из-за ссылки рушатся правила. Затем это вызовет void g(int&) перегрузка вместо этого.

Live демо

у Говарда уже есть хороший ответ на ваш вопрос о том, почему перегрузка rvalue , но я добавлю пример, который показывает две версии в действии.

основная идея двух перегрузок заключается в том, что перегрузка rvalue будет вызываться в случаях, когда результат выражения, которое вы передаете forward дает значение rvalue (prvalue или xvalue).

скажем, у вас есть типа foo что есть ref-квалифицированная пара get() перегрузка функции-члена. С && классификатор возвращает int в то время как другой возвращает int&.

struct foo
{
    int i = 42;
    int  get() && { return i; }
    int& get() &  { return i; }
};

и сказал f() вызывает get() функция-член на все, что было передано ему, и вперед, что на g()

template<class T>
auto f(T&& t)
{
    std::cout << __PRETTY_FUNCTION__ << '\n';
    g(forward<decltype(forward<T>(t).get())>(forward<T>(t).get()));
}

foo foo1;
f(foo1);   // calls lvalue overload of forward for both calls to forward

f(std::move(foo1)); // calls lvalue overload of forward for forward<T>(t)
                    // but calls rvalue overload for outer call to forward

Live demo

как std:: forward получает правильный аргумент?

для идеальной пересылки, как ваш код:

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

обратите внимание: std:: forward требует как аргумента функции, так и аргумента типа шаблона. параметр шаблона T будет кодировать, был ли аргумент, переданный param, lvalue или rvalue а затем вперед использовать его. В этом случае не имеет значения x см., Что ,x сам по себе является lvalue, перегрузка выбора 1 и x форвардные(универсальные) опорные параметры.Правила следующие:

1. если f expr аргумента является lvalue ，оба x и T будет ссылка lvalue тип
2. если f expr аргумента является rvalue ，T будет не ссылочным типом.

например, используйте исходный код gcc:

  template<typename _Tp>
    constexpr _Tp&&
    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
    { return static_cast<_Tp&&>(__t); } //overload 1


  template<typename _Tp>
    constexpr _Tp&&
    forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
    {
      static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
            " substituting _Tp is an lvalue reference type");
      return static_cast<_Tp&&>(__t);
    }// overload 2

• если функция пропуска f lvalue типа string или string&,для передовая функция _Tp будет string&,__t будет string & & равно string&,_Tp&& будет string& && равна string&.(ссылка рушится)
• если функция пропуска f rvalue типа string или string&&,для вперед функция _Tp будет string,__t будет string&,_Tp&& будет string&&.

что делает функция?

• если rvalue для rvalue (перегрузка 2) или lvalue для lvalue(перегрузка 1), ничего не делать, просто возвращаться.
• если вы не осторожны или что-то еще, привести rvalue к lvalue, дает вам ошибку компиляции по static_assert.(Перегрузка 2)
• если вы делаете lvalue для rvalue (перегрузка 1),это то же самое с std::move,но не удобство.

так же, как Скотт Мейерс сказать:

учитывая, что оба std:: move и std:: forward сводятся к броскам, единственная разница в том, что std:: move всегда бросает, в то время как std:: вперед только иногда ли, вы могли бы спросить, можем ли мы обойдитесь без std::move и просто используйте std:: forward везде. от a чисто техническая перспектива, ответ да: std:: вперед может сделать все это. std:: перемещение не требуется. Конечно, ни функция действительно необходимо, потому что мы могли бы писать слепки везде, но я надеюсь, мы согласимся, что это было бы, ну, отвратительно.

для чего перегрузка rvalue?

я не уверен, его следует использовать где тебе это действительно нужно.Такие, как Говард Хиннант говорит:

перегрузка 2 для случая с надписью " B. должен переслать rvalue как rvalue " в N2951. В двух словах этот случай позволяет:

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

где вы не уверены, если u.get () возвращает значение lvalue или rvalue, но в любом случае, если T не является ссылочным типом lvalue, вы хотите переместить возвращаемое значение. Но вы не используете std:: move, потому что если T-lvalue ссылочный тип, вы не хотите перейти от возврата.

одним словом, это позволяет нам использовать тип T, чтобы решить, двигаться или нет.