Perfect Forwarding with std::forward and Universal References

Advanced14 min read•Updated: 2026-10-22

🚀 Perfect Forwarding and Universal References

Introduction

When authoring generic factory functions or wrapper templates (such as std::make_unique or thread dispatchers), you must accept arguments and forward them to an underlying function preserving their exact value category (lvalue stays lvalue; rvalue stays rvalue). This is achieved through Universal References and std::forward.

🔀 The Reference Collapsing Rules

In a template where T is deduced, T&& is not an rvalue reference; it is a Forwarding Reference (or Universal Reference). The compiler applies reference collapsing:

& + & ──► &
& + && ──► &
&& + & ──► &
&& + && ──► &&

💻 Perfect Forwarding in Action

1#include <iostream>
2#include <string>
3#include <utility>
4 
5struct Student {
6    std::string name;
7    int age;
8 
9    // Overload 1: Lvalue copy
10    Student(const std::string& n, int a) : name(n), age(a) {
11        std::cout << "[COPIED name into Student]\n";
12    }
13 
14    // Overload 2: Rvalue move
15    Student(std::string&& n, int a) : name(std::move(n)), age(a) {
16        std::cout << "[MOVED name into Student with ZERO copies]\n";
17    }
18};
19 
20// Generic Factory Function with Perfect Forwarding
21template <typename T, typename... Args>
22T createInstance(Args&&... args) {
23    // std::forward restores original lvalue/rvalue category:
24    return T(std::forward<Args>(args)...);
25}
26 
27int main() {
28    std::string persistentName = "Aarav Sharma";
29 
30    // 1. Passing lvalue: forwards as const std::string&
31    Student s1 = createInstance<Student>(persistentName, 21);
32 
33    // 2. Passing rvalue: forwards as std::string&& (Move executed!)
34    Student s2 = createInstance<Student>(std::string("Rohan Verma"), 22);
35 
36    return 0;
37}

⚠️ `std::move` vs `std::forward`

std::move(x): Unconditionally casts to an rvalue reference (xvalue).
std::forward<T>(x): Conditionally casts to an rvalue only if the argument was passed as an rvalue.

Next Lesson

Resource Acquisition Is Initialization (RAII) Principle

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
The Rule of Five and Rule of Zero in Modern C++	Resource Acquisition Is Initialization (RAII) Principle

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

Introduction

💻 Perfect Forwarding in Action

1#include <iostream>
2#include <string>
3#include <utility>
4 
5struct Student {
6    std::string name;
7    int age;
8 
9    // Overload 1: Lvalue copy
10    Student(const std::string& n, int a) : name(n), age(a) {
11        std::cout << "[COPIED name into Student]\n";
12    }
13 
14    // Overload 2: Rvalue move
15    Student(std::string&& n, int a) : name(std::move(n)), age(a) {
16        std::cout << "[MOVED name into Student with ZERO copies]\n";
17    }
18};
19 
20// Generic Factory Function with Perfect Forwarding
21template <typename T, typename... Args>
22T createInstance(Args&&... args) {
23    // std::forward restores original lvalue/rvalue category:
24    return T(std::forward<Args>(args)...);
25}
26 
27int main() {
28    std::string persistentName = "Aarav Sharma";
29 
30    // 1. Passing lvalue: forwards as const std::string&
31    Student s1 = createInstance<Student>(persistentName, 21);
32 
33    // 2. Passing rvalue: forwards as std::string&& (Move executed!)
34    Student s2 = createInstance<Student>(std::string("Rohan Verma"), 22);
35 
36    return 0;
37}

Previous Lesson

Next Lesson

The Rule of Five and Rule of Zero in Modern C++

Resource Acquisition Is Initialization (RAII) Principle

🚀 Perfect Forwarding and Universal References

Introduction

🔀 The Reference Collapsing Rules

💻 Perfect Forwarding in Action

⚠️ std::move vs std::forward

Resource Acquisition Is Initialization (RAII) Principle

Related Lessons

Practice Quiz

Loading Page Content...

🚀 Perfect Forwarding and Universal References

Introduction

🔀 The Reference Collapsing Rules

💻 Perfect Forwarding in Action

⚠️ std::move vs std::forward

Resource Acquisition Is Initialization (RAII) Principle

Related Lessons

Practice Quiz

⚠️ `std::move` vs `std::forward`

⚠️ `std::move` vs `std::forward`