Краткий ответ

Forwarding reference сохраняет категорию значения аргумента через особое правило вывода шаблонного типа. Для lvalue типа T параметр шаблона выводится как ссылка T&, а для rvalue — как сам T; затем правило схлопывания ссылок формирует тип параметра.

Для lvalue типа int получается T = int&, а параметр T&& превращается в int&. Для rvalue получается T = int, поэтому параметр остаётся int&&.

Исторический контекст

Механизм появился вместе с rvalue-ссылками и шаблонным выводом в C++11. Он решает задачу идеальной передачи аргументов: обёртка должна передать lvalue как lvalue, а временный объект — как rvalue, не создавая лишних копий и не меняя доступные перегрузки.

До этого универсальные обёртки часто теряли информацию о категории значения или требовали большого набора перегрузок для разных комбинаций ссылок и квалификаторов.

Постановка проблемы

Один шаблонный параметр должен принимать как именованные объекты, так и временные значения. Если объявить параметр просто как ссылку на rvalue, lvalue передать нельзя; если принимать аргумент по значению, теряются ссылочность, const и возможность эффективно передать объект дальше.

Есть и дополнительный риск: внутри функции именованный параметр, даже если его тип — T&&, сам является lvalue-выражением. Поэтому простая передача такого параметра в другую функцию может вызвать lvalue-перегрузку вместо rvalue-перегрузки.

Подробное решение

Forwarding reference возникает, когда параметр имеет вид T&&, а T выводится в контексте шаблонной функции и является cv-неквалифицированным параметром шаблона. Это не то же самое, что любая rvalue-ссылка: например, const T&& forwarding reference не является.

При передаче lvalue типа int специальное правило вывода даёт T = int&. После подстановки получается int& &&, а по правилам схлопывания ссылок это int&. При передаче rvalue T выводится как int, и параметр имеет тип int&&.

Для const действует тот же принцип: const-lvalue приводит к выводу T = const int&, поэтому параметр становится const int&. Это позволяет сохранить не только категорию значения, но и cv-квалификаторы.

Чтобы передать параметр дальше с сохранением исходной категории, применяют std::forward<T>. В отличие от std::move, он превращает аргумент в rvalue только тогда, когда исходный вызов действительно получил rvalue.

#include <utility>

void consume(int&);
void consume(int&&);

template<class T>
void relay(T&& value) {
    consume(std::forward<T>(value));
}

int number = 0;
relay(number); // вызывается consume(int&)
relay(42);     // вызывается consume(int&&)

std::forward обычно реализован через условное приведение к rvalue-ссылке на основе T. Его корректность зависит от сохранения исходного параметра шаблона; ручная замена на std::move может некорректно переместить объект, который изначально был lvalue.

Ситуация из практики

Рассмотрим универсальную функцию-обёртку, которая принимает объект и передаёт его конструктору или другой функции. Передача по значению проста, но может копировать объект и не сохраняет ссылочную категорию. Фиксированная const-ссылка принимает больше вариантов, но запрещает изменение и обычно не позволяет выбрать перемещающую перегрузку.

Вариант с T&& без std::forward принимает оба вида аргументов, однако именованный параметр внутри тела всегда является lvalue. Поэтому временный объект может неожиданно попасть в копирующую или lvalue-перегрузку.

Практически выбирают T&& вместе с std::forward<T>, если функция действительно является транзитной обёрткой и должна сохранять свойства аргумента. Если же функция хранит значение, управляет временем жизни или намеренно не должна перемещать входной объект, обычная передача по значению либо по ссылке может быть понятнее и безопаснее.

Что кандидаты часто упускают

Чем forwarding reference отличается от обычной rvalue-ссылки?

Обычная rvalue-ссылка имеет уже известный тип, например ссылка на Widget&&, и принимает только rvalue. Forwarding reference содержит выводимый параметр шаблона T&&; специальное правило позволяет ему принять lvalue и вывести T как ссылочный тип. Поэтому термин описывает не только синтаксис &&, но и контекст вывода типа.

Почему именованный параметр T&& считается lvalue внутри функции?

Категория значения относится к выражению, а не просто к типу объекта. Имя параметра является выражением с устойчивым идентификатором, поэтому оно lvalue, даже если объявленный тип параметра — rvalue-ссылка. Для восстановления исходной категории используется std::forward<T>(value).

Что произойдёт с forwarding reference при передаче const-lvalue?

Для const-lvalue типа const Widget параметр шаблона обычно выводится как T = const Widget&. После схлопывания T&& становится const Widget&, поэтому функция не сможет изменить объект и не должна передавать его как изменяемый rvalue. Применение std::forward<T> сохранит именно const-квалификацию и категорию исходного аргумента.