# std::forward

> C++ Atlas: `cppatlas.com/w/cpp/utility/forward` | Source: https://en.cppreference.com/w/cpp/utility/forward | Domain: Utility | Standards: C++11, C++14

When t is a forwarding reference (a function argument that is declared as an rvalue reference to a cv-unqualified function template parameter), this overload forwards the argument to another function with the value category it had when…

## Executive Mental Model (Study Companion)

**Core Intuition:** T&& is a forwarding reference ONLY when T is a deduced template parameter of that exact function—not std::vector<T>&&.

- **Standard Era:** C++11 → C++20 → C++23
- **Primary ISO Clauses:** [dcl.ref], [temp.deduct.call], [class.copy.ctor], [utility.syn]
- **CppCon Talk Angle:** Show the exact 24-byte stack footprint of std::vector: copying duplicates the heap allocation, moving copies 3 pointers and nulls the source.
- **Common Audience Trap:** Forgetting noexcept on a custom move constructor, forcing std::vector::push_back to fall back to O(N) deep copies for exception safety.
- **Stage Takeaway:** Universal reference collapsing has one simple rule: '&' is infectious (& + anything = &). Only && + && yields &&.

## Memory Map Walkthrough: Stack/Heap Move Layout & Reference Collapsing Lab

Moving an owning container like std::vector does not move heap elements; it copies the 24-byte stack control block (begin, end, capacity pointers) into the destination and resets the source pointers to null in O(1) time. However, to preserve the strong exception guarantee during std::vector reallocation, std::vector calls std::move_if_noexcept—meaning if your user-defined move constructor is missing noexcept, vector silently copies every element instead of moving! Meanwhile, forwarding references (T&& or auto&&) leverage reference collapsing ([dcl.ref]): when an lvalue Widget passes to template<class T> void f(T&&), T deduces to Widget&, and Widget& && collapses to Widget&, letting std::forward<T> preserve the caller's exact value category.

### The noexcept move constructor cliff ([utility.move.if.noexcept] & [vector.capacity])

std::vector::push_back promises the strong exception guarantee: if reallocation fails halfway through migrating elements from the old buffer to the new buffer, the vector remains unchanged.

If moving element #50 out of 100 throws an exception, the old buffer already has 49 moved-from husks that cannot be rolled back. Therefore std::vector uses std::move_if_noexcept—it moves ONLY when the move constructor is noexcept (or when no copy constructor exists).

*noexcept unlocks fast vector growth:*
```cpp
struct Buffer {
    int* data = nullptr;
    Buffer(Buffer&& other) noexcept   // <-- omit noexcept and vector COPIES!
        : data(std::exchange(other.data, nullptr)) {}
    Buffer(const Buffer& other);
};
```

**Key takeaway:** Always mark user-defined move constructors and move assignment operators noexcept whenever they cannot throw.

### Forwarding reference vs. rvalue reference & collapsing ([temp.deduct.call] & [dcl.ref])

The syntax T&& means 'rvalue reference' everywhere EXCEPT when T is a deduced type parameter of that function template (or auto&&). Any cv-qualifier (const T&&) or wrapper (std::vector<T>&&) disables the forwarding-reference rule and becomes a plain rvalue reference.

When T&& IS a forwarding reference and receives an lvalue of type X, template deduction makes an intentional exception: T deduces to X&. Then reference collapsing fires: X& + && collapses to X&. Passing an rvalue deduces T = X, leaving X&&.

*Reference collapsing matrix:*
```cpp
template <class T>
void relay(T&& arg) {
    sink(std::forward<T>(arg));
}

Widget w;
relay(w);            // T = Widget&,  arg = Widget&  (lvalue)
relay(Widget{});     // T = Widget,   arg = Widget&& (xvalue after forward)
relay(std::move(w)); // T = Widget,   arg = Widget&&
```

**Key takeaway:** Any single & in a reference collapse (& &, & &&, && &) yields &; only && + && stays &&.

## Official Specification Summary (cppreference)

```cpp
// Defined in header <utility>

template< class T >
T&& forward( typename std::remove_reference<T>::type& t ) noexcept; // (1) (since C++11) (until C++14)

template< class T >
constexpr T&& forward( std::remove_reference_t<T>& t ) noexcept; // (1) (since C++14)

template< class T >
T&& forward( typename std::remove_reference<T>::type&& t ) noexcept; // (2) (since C++11) (until C++14)

template< class T >
constexpr T&& forward( std::remove_reference_t<T>&& t ) noexcept; // (2) (since C++14)
```

1) Forwards lvalues as either lvalues or as rvalues, depending on T.

When `t` is a forwarding reference (a function argument that is declared as an rvalue reference to a cv-unqualified function template parameter), this overload forwards the argument to another function with the value category it had when passed to the calling function.

For example, if used in a wrapper such as the following, the template behaves as described below:

```cpp
template<class T>
void wrapper(T&& arg)
{
    // arg is always lvalue
    foo(std::forward<T>(arg)); // Forward as lvalue or as rvalue, depending on T
}
```

- If a call to `wrapper()` passes an rvalue `std::string`, then `T` is deduced to `std::string` (not `std::string&`, `const std::string&`, or `std::string&&`), and `std::forward` ensures that an rvalue reference is passed to `foo`.
- If a call to `wrapper()` passes a const lvalue `std::string`, then `T` is deduced to `const std::string&`, and `std::forward` ensures that a const lvalue reference is passed to `foo`.
- If a call to `wrapper()` passes a non-const lvalue `std::string`, then `T` is deduced to `std::string&`, and `std::forward` ensures that a non-const lvalue reference is passed to `foo`.

2) Forwards rvalues as rvalues and prohibits forwarding of rvalues as lvalues.

This overload makes it possible to forward a result of an expression (such as function call), which may be rvalue or lvalue, as the original value category of a forwarding reference argument.

For example, if a wrapper does not just forward its argument, but calls a member function on the argument, and forwards its result:

```cpp
// transforming wrapper
template<class T>
void wrapper(T&& arg)
{
    foo(forward<decltype(forward<T>(arg).get())>(forward<T>(arg).get()));
}
```

where the type of arg may be

```cpp
struct Arg
{
    int i = 1;
    int  get() && { return i; } // call to this overload is rvalue
    int& get() &  { return i; } // call to this overload is lvalue
};
```

Attempting to forward an rvalue as an lvalue, such as by instantiating the form (2) with lvalue reference type T, is a compile-time error.

### Notes

See template argument deduction for the special rules behind forwarding references (`T&&` used as a function parameter) and forwarding references for other detail.

### Parameters

- `t` - the object to be forwarded

### Return value

`static_cast<T&&>(t)`

### Complexity

Constant.

### Example

This example demonstrates perfect forwarding of the parameter(s) to the argument of the constructor of class `T`. Also, perfect forwarding of parameter packs is demonstrated.

```cpp
#include <iostream>
#include <memory>
#include <utility>

struct A
{
    A(int&& n) { std::cout << "rvalue overload, n=" << n << '\n'; }
    A(int& n)  { std::cout << "lvalue overload, n=" << n << '\n'; }
};

class B
{
public:
    template<class T1, class T2, class T3>
    B(T1&& t1, T2&& t2, T3&& t3) :
        a1_{std::forward<T1>(t1)},
        a2_{std::forward<T2>(t2)},
        a3_{std::forward<T3>(t3)}
    {}

private:
    A a1_, a2_, a3_;
};

template<class T, class U>
std::unique_ptr<T> make_unique1(U&& u)
{
    return std::unique_ptr<T>(new T(std::forward<U>(u)));
}

template<class T, class... U>
std::unique_ptr<T> make_unique2(U&&... u)
{
    return std::unique_ptr<T>(new T(std::forward<U>(u)...));
}

auto make_B(auto&&... args) // since C++20
{
    return B(std::forward<decltype(args)>(args)...);
}

int main()
{
    auto p1 = make_unique1<A>(2); // rvalue
    int i = 1;
    auto p2 = make_unique1<A>(i); // lvalue

    std::cout << "B\n";
    auto t = make_unique2<B>(2, i, 3);

    std::cout << "make_B\n";
    [[maybe_unused]] B b = make_B(4, i, 5);
}
```

Output:

```text
rvalue overload, n=2
lvalue overload, n=1
B
rvalue overload, n=2
lvalue overload, n=1
rvalue overload, n=3
make_B
rvalue overload, n=4
lvalue overload, n=1
rvalue overload, n=5
```

### See also

- [`move`](https://en.cppreference.com/w/cpp/utility/move) (C++11): converts the argument to an xvalue (function template)
- [`move_if_noexcept`](https://en.cppreference.com/w/cpp/utility/move_if_noexcept) (C++11): converts the argument to an xvalue if the move constructor does not throw (function template)

## Podcast Host Debate & Socratic Standard Traps

Use the prompts and tricky ISO standard questions below to guide a Socratic audio discussion:

- Break down what std::vector actually puts on the stack versus the heap, and why moving a million-element vector costs three pointer assignments.
- Tell the story of the missing noexcept move constructor and how std::move_if_noexcept quietly saves exception safety at the cost of speed.
- Clarify why Box<T>::push(T&&) is NOT a forwarding reference even though T&& looks identical.

### Trap 1: [vector.modifiers] & [utility.move.if.noexcept] (cppcon-stage)

Widget defines BOTH a copy constructor and a non-noexcept move constructor. What does std::vector<Widget>::push_back invoke on existing elements during buffer growth?

```cpp
struct Widget {
    Widget(const Widget&);
    Widget(Widget&&); // Note: NOT marked noexcept
};
```

A. The move constructor, because std::vector always moves existing items
B. The copy constructor, via std::move_if_noexcept, to preserve the strong exception guarantee
C. Compile error: move constructors must be noexcept to live in std::vector
D. memcpy bitwise relocation

**Standard Answer (B):** The copy constructor, via std::move_if_noexcept, to preserve the strong exception guarantee

**Why:** Because Widget has a copy constructor and its move constructor might throw, std::move_if_noexcept yields const Widget& so std::vector copies elements safely into the new buffer before freeing the old buffer.

### Trap 2: [temp.deduct.call] §13.10.3.2 (standard-lawyer)

Which function parameter is actually a forwarding (universal) reference?

A. template<class T> void f(std::vector<T>&& v);
B. template<class T> void f(const T&& v);
C. template<class T> struct Box { void push(T&& v); };
D. auto&& x = expr;

**Standard Answer (D):** auto&& x = expr;

**Why:** std::vector<T>&& and const T&& are plain rvalue references. Box<T>::push(T&&) is NOT deduced at the push() call site because T was already fixed by Box<T>! Only auto&& (or a template function's own deduced T&&) is a forwarding reference.

*CppCon speaker note:* Box<T>::push(T&&) is a notorious class-template surprise (think std::vector<T>::push_back(T&&)).

### Trap 3: [dcl.ref] §9.3.4.3 (subtle)

Given using LRef = int&; and using RRef = int&&;, what type does LRef&& collapse to?

A. int&&
B. int&
C. int
D. Ill-formed: references to references are always illegal

**Standard Answer (B):** int&

**Why:** While writing int& && directly in source is illegal, forming a reference to a reference through type aliases, decltype, or template substitution collapses via [dcl.ref]: if either reference is an lvalue reference (&), the result is an lvalue reference (int&).

### Trap 4: [lib.types.movedfrom] (subtle)

After std::string b = std::move(a);, what operations are guaranteed valid on the moved-from string a?

A. a is guaranteed to be empty (a.empty() == true)
B. Only destruction and reassignment are valid; calling a.clear() is UB
C. a is in a valid but unspecified state: all operations with no preconditions (like a.empty(), a.clear(), a = "new", ~string) are valid
D. Using a in any way after std::move is Undefined Behavior

**Standard Answer (C):** a is in a valid but unspecified state: all operations with no preconditions (like a.empty(), a.clear(), a = "new", ~string) are valid

**Why:** Standard library types leave moved-from objects in a valid but unspecified state ([lib.types.movedfrom]). While small-string optimization means a might NOT even be empty, you may safely inspect size(), call clear(), reassign, or destroy a.

---
Attribution: content from https://en.cppreference.com/w/cpp/utility/forward (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.