Video & On-Demand : Standard C++

Home » Blog » Categories » Video & On-Demand

CppCon 2025 Cache-Friendly C++ -- Jonathan Müller

By Blog Staff | Jun 10, 2026 03:00 PM | Tags: None

Registration is now open for CppCon 2026! The conference starts on September 12 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from last year's conference. Here’s another CppCon talk video we hope you will enjoy – and why not register today for CppCon 2026!

Cache-Friendly C++

by Jonathan Müller

Summary of the talk:

When you need a container, pick std::vector＜T＞ by default. This is because std::vector＜T＞ is cache-friendly.

What does that mean, though?

This talk will answer that from the ground-up. We will cover the need for CPU caches and their consequences, how the CPU tricks to make them as seamless as possible, and when and why those tricks sometimes fail. This means that you need to be careful when structuring your program to avoid slowdowns. We will thus explore cache-friendly data structures, data-oriented design, and how to avoid common pitfalls.

CppCon 2025 Cutting Down on Unnecessary Objects -- Prithvi Okade & Kathleen Baker

By Blog Staff | Jun 8, 2026 02:57 PM | Tags: None

C++ Performance Tips: Cutting Down on Unnecessary Objects

by Prithvi Okade & Kathleen Baker

Summary of the talk:

In C++, unnecessary temporary object creation can lead to costly runtime operations, increased code execution, and higher memory usage. Luckily this can be improved! This talk investigates common scenarios that result in the creation of temporary objects and how to detect these scenarios, demonstrated through code examples. We will then explore strategies to reduce the creation of such objects with techniques like explicitly moving objects, passing objects by reference, leveraging lightweight classes like std::string_view and std::span , using functions like reserve and emplace , and more. Join us to learn how to optimize your code’s performance and adopt better practices.

CppCon 2025 Building Vector Math Libraries with Concepts & Customization Points -- Greg von Winckel

By Blog Staff | Jun 4, 2026 02:54 PM | Tags: None

Zero-Overhead Abstractions: Building Vector Math Libraries with Concepts and Customization Points

by Greg von Winckel

Summary of the talk:

This talk demonstrates how C++20's Concepts and Customization Point Objects (CPOs) provide a flexible, opt-in approach to vector algorithms—a compelling alternative to inheritance-based interfaces. Starting with foundational concepts and CPOs, we'll design mathematical abstractions that enable precise compile-time requirements with helpful diagnostics and clear error messages.

Through a practical vector framework implementation, we'll explore patterns essential for high-performance scientific computing applications, including interpolation and iterative methods for linear and nonlinear systems. Attendees will learn how CPOs with intelligent fallbacks parallel the familiar base-class/override structure of OOP, providing similar code reuse and customization opportunities without inheritance entanglements, while enabling seamless interoperability between diverse container types in the spirit of the STL.

As a C++ developer and architect at Sandia National Laboratories for the past decade, I've witnessed the burden of OOP overuse: complicated class hierarchies, parallelism compatibility issues, and testing challenges. The Real Vector Framework I've developed demonstrates how static polymorphism and free functions provide cleaner, more flexible alternatives to inheritance—bringing modern C++ practices to scientific computing while preserving the performance critical to our applications.

C++: The Documentary

By Blog Staff | Jun 2, 2026 05:09 PM | Tags: None

Sponsored by HRT and produced by CultRepo, C++: The Documentary is about to be released worldwide on YouTube on Thursday at 20:00 UTC. Click Notify me on the YouTube Premiere page to get a reminder when it goes live.

Last week, the film's world premiere event in New York was followed by a live panel discussion with Matt Godbolt (moderator), Bjarne Stroustrup, Gabriel Dos Reis, Nina Ranns, Eric Lubin, and Herb Sutter. That panel was recorded and will be also released in the next few days on the CppCon YouTube channel.

CppCon 2025 Best Practices for AI Tool Use in C++ -- Jason Turner

By Blog Staff | Jun 2, 2026 02:51 PM | Tags: None

Best Practices for AI Tool Use in C++

by Jason Turner

Summary of the talk:

AI (LLMs) are becoming prolific in C++ tooling. Virtually everything has an AI bot built in or available to it. Common wisdom says that these tools simply regurgitate what they find on the internet. As we all know, the internet is full of terrible examples of outdated memory leaks, undefined behavior, and worse!

How do we effectively and safely use these tools while ensuring good code quality?!

CppCon 2025 Back to Basics: Master C++ Friendship -- Mateusz Pusz

By Blog Staff | May 27, 2026 02:48 PM | Tags: None

Back to Basics: Master C++ Friendship

by Mateusz Pusz

Summary of the talk:

C++ offers a rich set of access specifiers to control the visibility of class members. However, the friend keyword introduces a unique and often misunderstood concept. This talk explores the nuances of friendship, examining its role in code design, testing, and compilation performance optimization.

We'll delve into the intricacies of friendship, exploring its benefits and potential pitfalls. We'll examine how to leverage friendship effectively, discuss best practices, and uncover hidden gems and common misconceptions. We will see how friendship affects name lookup and compile-time error messages. We will discuss best practices for using it effectively and learn how to avoid or resolve compilation problems that may occur when C++ templates are involved.

By the end of this session, you'll have a solid grasp of friendship and be able to use it to write more elegant, efficient, and maintainable C++ code.

CppCon 2025 Could C++ Developers Handle an ABI Break Today? -- Luis Caro Campos

By Blog Staff | May 25, 2026 02:46 PM | Tags: None

Could C++ Developers Handle an ABI Break Today?

by Luis Caro Campos

Summary of the talk:

The C++ Evolution Working Group recently reaffirmed its commitment to ABI stability, prioritizing link compatibility with C and older C++. The C++11 libstdc++ ABI updates introduced in gcc 5.1, although not strictly “breaking”, are still in the collective memory of C++ developers and this experience shows us how sensitive the ecosystem is to ABI updates.

This talk challenges the assumption that a future ABI break would be equally problematic, as the landscape has evolved significantly in the last decade.

On the one hand, the C++ standard has evolved in such a way that even if the standards committee and compiler vendors go through great lengths to avoid breaking the ABI of standard library implementations, library authors are not as cautious - so in practice, the ability to link objects built with different C++ standard levels does not hold true for a lot of cases.

On the other hand, tooling has evolved significantly in this time period. For example, both Conan and vcpkg are able to “tag” binaries on some arbitrary ABI version. We can see similar examples in other tools or ecosystems that need to work around ABI complexities.

This talk is not intended to argue about the merits or risks of future ABI changes - but to ask ourselves the question: are we overestimating the pain of a future ABI break?

CppCon 2025 How To Build Robust C++ Inter-Process Queues -- Jody Hagins

By Blog Staff | May 21, 2026 02:42 PM | Tags: None

How To Build Robust C++ Inter-Process Queues

by Jody Hagins

Summary of the talk:

This talk will offer design and implementation details of a queue intended to be used between multiple processes.

The C++ standard was written with a single-process worldview, mentioning processes only once—in a note stating that lock-free atomic operations work across process boundaries. This has led to widespread but incorrect advice about using std::atomic in shared memory. When moving queue implementations from threads to processes, seemingly rock-solid code can induce undefined behavior.

In addition, traditional queue interfaces are fundamentally insufficient for cross-process communication. A properly designed inter-process queue API must enforce role separation, ensuring that a process can only perform operations appropriate to its designated role. For example, a producer process should not be able to consume messages or manage the queue itself, and the API should prevent multiple processes from accidentally assuming the same role in a single-producer design.

By the end of this talk, you will understand the fundamental differences between thread process synchronization, how to design proper interfaces for interprocess queues that enforce correct usage across process boundaries, and practical techniques to ensure your cross-process code works reliably in production environments.

Oh yeah, and you will have a full implementation that you can use and improve upon.

The road to 'import boost': a library developer's journey into C++20 modules -- Rubén Pérez Hidalgo

By Blog Staff | May 20, 2026 03:50 PM | Tags: None

C++20 modules have been in the standard for more than 5 years already. They promise to deliver a big change to how we write C++, but their adoption hasn't been as widespread as one would have expected. This talk is a deep dive into the practical aspects of C++20 modules, exploring the reality of the ecosystem as it is today.

The road to 'import boost': a library developer's journey into C++20 modules

Rubén Pérez Hidalgo

Watch now:

CppCon 2025 Concept-based Generic Programming -- Bjarne Stroustrup

By Blog Staff | May 19, 2026 02:38 PM | Tags: None

Concept-based Generic Programming

by Bjarne Stroustrup

Summary of the talk:

This talk presents programming techniques to illustrate the facilities and principles of C++ generic programming using concepts. Concepts are C++’s way to express constraints on generic code. As an initial example, it provides a simple type system that eliminate narrowing conversions and provides range checking.

Concepts are used throughout to provide user-defined extensions to the type system. The aim is to show their utility and the fundamental ideas behind them, rather than to provide a detailed or complete explanation of C++’s language support for generic programming or the extensive support provided by the standard library.

The final sections briefly present design rationales and origins for key parts of the concept design, including use patterns, the relationship to Object-Oriented Programming, value arguments, syntax, concept type-matching, and definition checking. They also mention static reflection, a C++26 improvements in the support of general programming.