Для чего нужна функция std::forward?

std::forward в C++: Идеальная передача параметров

Определение

std::forward — это функция, которая сохраняет категорию значения (value category) параметра при передаче его дальше. Она позволяет реализовать идеальную передачу параметров (perfect forwarding).

Это нужно для того, чтобы lvalue оставались lvalue, а rvalue оставались rvalue при передаче в другие функции.

Проблема, которую она решает

Представим функцию-обёртку (wrapper), которая должна передать параметр дальше:

void process(int& x) {
    std::cout << "lvalue: " << x << "\n";
}

void process(int&& x) {
    std::cout << "rvalue: " << x << "\n";
}

// Обёртка БЕЗ std::forward
template <typename T>
void wrapper(T param) {
    process(param);  // Что передастся: lvalue или rvalue?
}

int main() {
    int a = 10;
    wrapper(a);           // Хотим process(int&)
    wrapper(20);          // Хотим process(int&&)
}

Проблема: param внутри wrapper — это всегда lvalue (у него есть имя), даже если передали rvalue.

wrapper(20);  // Передали rvalue
// Но внутри wrapper:
int&& param = 20;  // Параметр с типом rvalue reference
process(param);    // Но param — это ИМЁННОЕ значение, hence lvalue!
// Вызовется process(int&), не process(int&&)

Решение: std::forward

template <typename T>
void wrapper(T&& param) {  // T&& — universal reference
    process(std::forward<T>(param));  // Идеальная передача
}

int main() {
    int a = 10;
    wrapper(a);   // T = int&, std::forward<int&>(param) -> lvalue -> process(int&)
    wrapper(20);  // T = int, std::forward<int>(param) -> rvalue -> process(int&&)
}

Теперь:

• Если передали lvalue → передалась как lvalue
• Если передали rvalue → передалась как rvalue

Как работает std::forward?

Это template магия на основе type deduction rules:

template <typename T>
T&& forward(typename std::remove_reference<T>::type& arg) noexcept {
    return static_cast<T&&>(arg);
}

Хитрость в том, как выбирается T:

Случай 1: передали lvalue

int a = 10;
wrapper(a);           // a — lvalue
// T выводится как: int&
// forward<int&>(param) -> int& && -> int& (reference collapsing)
// Возвращает int&

Случай 2: передали rvalue

wrapper(20);          // 20 — rvalue
// T выводится как: int
// forward<int>(param) -> int&& 
// Возвращает int&&

Reference collapsing правила

Это важно понять:

T&  && -> T&   (lvalue reference побеждает)
T&& &  -> T&   (lvalue reference побеждает)
T&& && -> T&&  (оба rvalue)
T&  &  -> T&   (оба lvalue)

Практический пример: функция создания объекта

class Widget {
public:
    Widget(const std::string& name) : name(name) {
        std::cout << "Скопировали строку\n";
    }
    Widget(std::string&& name) : name(std::move(name)) {
        std::cout << "Переместили строку\n";
    }
private:
    std::string name;
};

// Функция создания (factory)
template <typename T, typename... Args>
std::unique_ptr<T> make(Args&&... args) {
    return std::make_unique<T>(std::forward<Args>(args)...);
}

int main() {
    std::string name = "Widget1";
    
    // Передали lvalue -> вызовет копирующий конструктор
    auto w1 = make<Widget>(name);
    
    // Передали rvalue -> вызовет перемещающий конструктор
    auto w2 = make<Widget>("Widget2");
}

// Вывод:
// Скопировали строку
// Переместили строку

Реальный пример: std::make_unique реализация

template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(
        new T(std::forward<Args>(args)...)
    );
}

// Это позволяет:
auto p1 = std::make_unique<Widget>("name");  // Передача по значению
auto p2 = std::make_unique<std::vector<int>>(10, 5);  // Несколько параметров

// Все параметры идеально пересылаются конструктору

Отличие std::move vs std::forward

std::move — безусловно преобразует в rvalue:

template <typename T>
std::remove_reference_t<T>&& move(T&& arg) noexcept {
    return static_cast<std::remove_reference_t<T>&&>(arg);
}

int a = 10;
auto x = std::move(a);  // Всегда int&& (даже если a — lvalue)

std::forward — сохраняет категорию:

int a = 10;
auto x = std::forward<int&>(a);   // int& (если T = int&)
auto y = std::forward<int>(20);    // int&& (если T = int)

Сложный пример: цепочка вызовов

void log(const char* msg) {
    std::cout << "Message: " << msg << "\n";
}

// Обёртка 1
template <typename T>
void wrapper1(T&& arg) {
    log("wrapper1 called");
    wrapper2(std::forward<T>(arg));  // Идеальная передача
}

// Обёртка 2
template <typename T>
void wrapper2(T&& arg) {
    log("wrapper2 called");
    process(std::forward<T>(arg));   // Идеальная передача
}

void process(const std::string& s) {
    std::cout << "process(const string&): " << s << "\n";
}

void process(std::string&& s) {
    std::cout << "process(string&&): " << s << "\n";
}

int main() {
    std::string str = "hello";
    wrapper1(str);      // Пройдёт как lvalue через все слои
    wrapper1("world");  // Пройдёт как rvalue через все слои
}

Когда использовать?

Используй std::forward:

• В template функциях, которые передают параметры дальше
• В factory функциях (make, create, emplace)
• В обёртках (decorators, adapters)
• В callable объектах, которые вызывают другие функции

// ✅ Правильно
template <typename F, typename... Args>
auto call_with_log(F&& func, Args&&... args) {
    std::cout << "Calling...\n";
    return func(std::forward<Args>(args)...);
}

// ❌ Неправильно (теряется категория значения)
template <typename F, typename... Args>
auto call_with_log(F&& func, Args... args) {
    return func(args...);  // args всегда lvalue
}

Типичная ошибка

// ❌ БАГИ
template <typename T>
void bad_forward(const T& param) {  // const T& — всегда lvalue!
    process(std::forward<T>(param));
    // forward не поможет, param уже const lvalue
}

// ✅ Правильно
template <typename T>
void good_forward(T&& param) {  // universal reference
    process(std::forward<T>(param));
}

Производительность

std::forward — это zero-cost abstraction:

// Это просто static_cast в compile-time
// Нет runtime overhead
// Компилятор может полностью оптимизировать

Заключение

• std::forward решает проблему сохранения категории значения при передаче
• Используется с universal references (T&&) в templates
• Позволяет реализовать идеальную передачу параметров
• Критично для factory функций, обёрток, callback систем
• Zero-cost abstraction — нет runtime overhead
• Без std::forward теряется информация об lvalue/rvalue, что убивает производительность