Jonathan Müller

An (In-)Complete Guide to C++ Object Lifetimes

In C++, an object's life doesn't always start when memory is allocated. This guide explores the subtle rules that prevent dangling pointers and undefined behavior.

An (In-)Complete Guide to C++ Object Lifetimes
#1about 3 minutes

Defining objects and lifetimes in C++

An object is a region of storage with a type and value, and its lifetime is a property on the abstract machine that dictates when it can be safely manipulated.

#2about 5 minutes

Creating objects with variable declarations and storage duration

Objects created by variable definitions have their lifetime influenced by their storage duration (automatic, static, or thread), which is distinct from the object's actual lifetime that begins after initialization.

#3about 5 minutes

Understanding temporary objects and lifetime extension rules

Temporary objects are created for prvalues and are usually destroyed at the end of an expression, but their lifetime can be extended when bound directly to a reference or used in a range-based for loop.

#4about 5 minutes

Manually creating objects in existing memory with placement new

Placement `new` allows constructing an object in pre-allocated storage, and if the new object is "transparently replaceable," existing pointers and references to the old object remain valid.

#5about 2 minutes

Using std::launder for non-transparent object replacement

When an object replacement is not transparent (e.g., for `const` objects), `std::launder` must be used on old pointers to prevent undefined behavior by forcing the compiler to acknowledge the new object in that storage.

#6about 5 minutes

Implicit object creation and std::start_lifetime_as

Certain operations like `malloc` can implicitly create objects to make C-style code valid, and `std::start_lifetime_as` should be used to correctly begin the lifetime of an object in a raw byte buffer.

#7about 2 minutes

Implicit destruction and best practices for object lifetime

Reusing storage with placement `new` implicitly destroys the previous object, and best practices include explicit object creation and using the newly returned pointer to avoid aliasing issues.

Related jobs
Jobs that call for the skills explored in this talk.

Featured Partners

Related Videos

See all videos
The C++ rvalue lifetime disaster24:17

The C++ rvalue lifetime disaster

Arno Schoedl

C++ Features You Might Not Know24:13

C++ Features You Might Not Know

Jonathan Müller

101 brilliant things of C++45:27

101 brilliant things of C++

Andreas Fertig

The Design and Evolution of C++1:01:15

The Design and Evolution of C++

Bjarne Stroustrup

C++ in constrained environments1:00:16

C++ in constrained environments

Bjarne Stroustrup

Why Iterators Got It All Wrong — and what we should use instead26:12

Why Iterators Got It All Wrong — and what we should use instead

Arno Schödl

Guided Memory Management: Rust's Ownership Model00:18

Guided Memory Management: Rust's Ownership Model

Stefan Baumgartner

Python: Behind the Scenes25:29

Python: Behind the Scenes

Diana Gastrin

From learning to earning

Jobs that call for the skills explored in this talk.

Rust and GoLang

Rust and GoLang

NHe4a GmbH
Karlsruhe, Germany

Remote
€55-65K
Intermediate
Senior
Go
Rust

Techlead C++

REDLAB
Paris, France

QT
C++
Software Architecture