CppCon 2026

Move semantics and perfect forwarding, introduced in C++11, are quite impactful features that still remain a source of confusion even for some experienced developers. This talk builds understanding from the ground up: what problem move semantics solves, how rvalue references enable it, and why the rules work the way they do.

We start with the cost of unnecessary copies and how move constructors and move assignment operators let us transfer resources instead of duplicating them. We then look at how std::move doesn't actually move anything — and what it really does. From there we tackle the forwarding problem: why writing a single function that preserves the value category of its arguments is necessary, how forwarding references (also known as "universal reference" in the past) solve it, and what std::forward does under the hood.

Along the way we cover the practical details that trip people up: reference collapsing rules, the interaction between overload resolution and reference binding, when the compiler generates move operations and when it doesn't, and the cases where std::move can actually pessimize your code. We also discuss trade-offs in parameter passing — by value, by const reference, or by forwarding reference — so attendees should have a clearer model for making these decisions in their own code.

At the end we will look into std::forward_like and explore how it is different from std::forward .

No prior knowledge of rvalue references is assumed. Familiarity with copy constructors, destructors, and basic templates is helpful.