Perfect Forwarding & std::forward

The Problem: Named Rvalue References Are Lvalues

Here's the fundamental problem perfect forwarding solves: when you accept an argument as T&& and pass it to another function, the name makes it an lvalue:

```cpp
void inner(int& x) { std::cout << "lvalue\n"; }
void inner(int&& x) { std::cout << "rvalue\n"; }

void outer(int&& x) {
inner(x); // calls inner(int&) — x is an lvalue!
}
```

The value category is lost at every function boundary. If you are writing a wrapper function (logging, timing, factory), you need to forward the argument with its original value category preserved. Simply passing x always passes an lvalue. Using std::move(x) always passes an rvalue. Neither is correct for a generic wrapper.

std::forward: The Conditional Cast

std::forward(x) is a conditional cast:

- If T is an lvalue reference (deduced because an lvalue was passed), std::forward(x) returns an lvalue reference — no cast.
- If T is a non-reference (deduced because an rvalue was passed), std::forward(x) returns an rvalue reference — casts to T&&.

The key difference from std::move:
- std::move always casts to rvalue (unconditional).
- std::forward casts to rvalue only if the original argument was an rvalue (conditional).

std::forward should ONLY be used with forwarding references (T&& where T is deduced). Using it elsewhere is a bug.

The Canonical Forwarding Pattern

The pattern: accept a forwarding reference T&&, then use std::forward(arg) to preserve the value category when passing to another function.

#include <iostream>
#include <string>
#include <utility>
#include <chrono>

// The function we want to wrap
void process(const std::string& s) {
    std::cout << "process(lvalue): " << s << '\n';
}
void process(std::string&& s) {
    std::cout << "process(rvalue): " << s << '\n';
    // Can steal s's resources since it's an rvalue
}

// Generic wrapper that perfectly forwards
template <typename T>
void timed_process(T&& arg) {
    auto start = std::chrono::steady_clock::now();

    // std::forward<T>(arg) preserves the original value category
    process(std::forward<T>(arg));

    auto elapsed = std::chrono::steady_clock::now() - start;
    std::cout << "Took: " << elapsed.count() << " ns\n";
}

int main() {
    std::string name = "Alice";
    timed_process(name);              // T = string&,  forwards as lvalue
    timed_process(std::string("Bob")); // T = string, forwards as rvalue
    timed_process("Charlie");          // T = const char(&)[8], forwards as lvalue
}

Variadic Forwarding & emplace_back

Perfect forwarding truly shines with variadic templates. emplace_back forwards constructor arguments directly into the container, constructing the object in-place without any copies or moves.

#include <iostream>
#include <vector>
#include <string>
#include <utility>

struct Employee {
    std::string name;
    int age;
    Employee(std::string n, int a) : name(std::move(n)), age(a) {
        std::cout << "Constructed: " << name << '\n';
    }
    Employee(const Employee&) { std::cout << "Copied\n"; }
    Employee(Employee&&) noexcept { std::cout << "Moved\n"; }
};

// Custom factory using variadic forwarding
template <typename T, typename... Args>
std::vector<T> make_vector_of(Args&&... args) {
    std::vector<T> v;
    // Fold expression (C++17) + emplace_back
    (v.emplace_back(std::forward<Args>(args)), ...);
    return v;
}

int main() {
    std::vector<Employee> team;

    // push_back: creates temporary, then MOVES it into vector
    team.push_back(Employee("Alice", 30));
    // Output: Constructed: Alice, Moved

    // emplace_back: constructs IN-PLACE — no copy, no move
    team.emplace_back("Bob", 25);
    // Output: Constructed: Bob

    std::cout << "---\n";
    // Variadic forwarding
    auto v = make_vector_of<std::string>("hello", std::string("world"), "!");
    for (const auto& s : v) std::cout << s << ' ';
    std::cout << '\n';
}

move vs forward: Know the Difference

| | std::move | std::forward |
|---|---|---|
| Cast type | Unconditional cast to T&& | Conditional — lvalue if T is T&, rvalue if T is T |
| Use case | "I'm done with this, steal it" | "Pass this along with its original value category" |
| Context | Concrete types, last use of a variable | Template forwarding references only |
| Danger | Accidentally moving a value you still need | Using without a forwarding reference (meaningless) |

Rule of thumb: use std::move when you own the value and want to give it away. Use std::forward when you are forwarding someone else's value.