Почему для пересылки ссылок необходим std :: forward

Вы действительно не хотите, чтобы ваши параметры автоматически перемещались в вызываемые функции. Рассмотрим эту функцию:

template <typename T>
void foo(T&& x) {
  bar(x);
  baz(x);
  global::y = std::forward<T>(x);
}

Теперь вам действительно не нужен автоматический переход к bar и пустой параметр к baz.

Текущие правила, требующие от вас указывать, следует ли и когда перемещать или продвигать параметр, не случайны.

Разве x не является ссылкой на rvalue внутри foo?

Нет, x - это lvalue внутри foo (у него есть имя и адрес) ссылки типа rvalue. Объедините это с правилами сворачивания ссылок и правилами вывода типа шаблона, и вы увидите, что вам нужно std::forward, чтобы получить правильный тип ссылки.

По сути, если то, что вы передаете как x, является lvalue, скажем, int, тогда T выводится как int&. Тогда int && & становится int& (из-за правил сворачивания ссылок), то есть lvalue ref.

С другой стороны, если вы передадите rvalue, скажем 42, тогда T будет выведено как int, поэтому в конце у вас будет int&& как тип x, то есть rvalue. В основном это то, что делает std::forward: приводит к T&& результат, как

static_cast<T&&>(x)

который становится либо T&&, либо T& из-за правил сворачивания ссылок.

Его полезность становится очевидной в универсальном коде, где вы можете не знать заранее, получите ли вы rvalue или lvalue. Если вы не вызываете std::forward, а только f(x), тогда x будет всегда lvalue, поэтому вы потеряете семантику перемещения, когда это необходимо, и можете получить ненужные копии и т. Д.

Простой пример, в котором вы можете увидеть разницу:

#include <iostream>

struct X
{
    X() = default;
    X(X&&) {std::cout << "Moving...\n";};
    X(const X&) {std::cout << "Copying...\n";}
};

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

template <typename T>
void f2(T&& x)
{
    g(x);
}

template <typename T>
void g(T x)
{ }

int main()
{
    X x;
    std::cout << "with std::forward\n";
    f1(X{}); // moving

    std::cout << "without std::forward\n";
    f2(X{}); // copying
}

Live on Coliru

У меня точно такие же типы с std::forward<T> и без

...нет? Ваш собственный вывод доказывает, что вы ошибались:

__<int>    // T
__<int&&>  // decltype(x)
__<int&&>  // std::forward<T>(x)

Без использования std::forward<T> или decltype(x) вы получите int вместо int&&. Это может случайно не "повысить ценность" x - рассмотрим этот пример:

void foo(int&)  { cout << "int&\n"; }
void foo(int&&) { cout << "int&&\n"; }

template <typename T>
void without_forward(T&& x)
{
    foo(x);
//      ^
//  `x` is an lvalue!
}

template <typename T>
void with_forward(T&& x)
{
//  `std::forward` casts `x` to `int&&`.
//      vvvvvvvvvvvvvvvvvv
    foo(std::forward<T>(x));
//                      ^
//          `x` is an lvalue!
}

template <typename T>
void with_decltype_cast(T&& x)
{
// `decltype(x)` is `int&&`. `x` is casted to `int&&`.
//      vvvvvvvvvvv
    foo(decltype(x)(x));
//                  ^
//          `x` is an lvalue!
}

int main()
{
    without_forward(1);    // prints "int&"
    with_forward(1);       // prints "int&&"
    with_decltype_cast(1); // prints "int&&"
}

Пример палочки

x быть r-значением НЕ то же самое, что x иметь тип ссылки на r-значение.

R-значение - это свойство выражения, тогда как r-value-reference - это свойство его типа.

Если вы на самом деле пытаетесь передать переменную, которая является ссылкой на r-значение, в функцию, она обрабатывается как l-значение. decltype вводит вас в заблуждение. Попробуйте и убедитесь:

#include <iostream>
#include <typeinfo>
using namespace std;

template<class T> struct wrap { };

template<class T>
void bar(T &&value) { std::cout << " vs. " << typeid(wrap<T>).name() << std::endl; }

template<class T>
void foo(T &&value) { std::cout << typeid(wrap<T>).name(); return bar(value); }

int main()
{
    int i = 1;
    foo(static_cast<int &>(i));
    foo(static_cast<int const &>(i));
    foo(static_cast<int &&>(i));
    foo(static_cast<int const &&>(i));
}

Вывод:

4wrapIRiE vs. 4wrapIRiE
4wrapIRKiE vs. 4wrapIRKiE
4wrapIiE vs. 4wrapIRiE (они должны совпадать!)
4wrapIKiE vs. 4wrapIRKiE (они должны совпадать!)