CppNorth, The Canadian C++ Conference 2025

Type erasure is a powerful concept in C++ that allows us to work with heterogeneous types while hiding their concrete details behind a generic interface. In this talk, we will explore how the C++ Standard Library employs type erasure in constructs like std::function, std::shared_ptr, and std::any to provide flexible and efficient solutions for managing types at runtime. Further, we will unveil the hidden cost of using these constructs.
We will start by building our own version of std::function, which will help demystify how it can store and call any callable object, regardless of its type. Then, we'll look at how std::shared_ptr uses type erasure to maintain type safety via dynamic dispatch of the deleter. Finally, we will delve into std::any, some times claimed the modern void*, and explore a different technique of type erasure.

Two years ago a junior developer, doing her very first "introductory" task, asked the seemingly simple question "should I check for null here?".

This, of course, resulted in a multi page response from me, starting with:

"It depends"

and ending with:

"And that's the short version. For the long version, see my hour/day presentation on whether to check for null (which is actually not about null at all, but Contracts...)"

Aha! Two years later...

This is a talk about Error Handling - but in particular those errors you didn't expect - bugs.

And yes, this is really a talk about Contracts, in particular C++26 (and beyond) Contracts. What are they, What AREN'T they, how to use them and WHY.

Get ready for a crazy fun & informative talk! Boost your C++ code's performance by utilizing the full power of your computer’s built-in cache. In this talk, we'll delve into the basics of caches, spatial and temporal cache locality, and practical techniques for optimizing cache access. We'll also explore cache prefetching, branch prediction, and false sharing, providing examples modelled on real-world production code and performance benchmarks to drive home each point. By the end of this talk, you'll be equipped with the knowledge and tools to better optimize your code for cross-platform performance gains.

This talk explores five widely taught C++ coding guidelines and the subtle but profound way that the special member functions interact with class invariants, all with the ultimate goal of learning how to write better code.

A pipeline is a chain of processing elements such as functions, threads etc., arranged so that the output of each element is the input of the next. We often encounter this pattern in practice. C++ also allows us to write in this way, e.g. using the `std::ranges` library with its characteristic overloaded pipe `operator |`. But modern C++ enables much more and this will be discussed in this talk. First, we'll show how to implement a custom pipeline framework that employs `std::expected`, available since C++23. Secondly, we will show pipelines in the serial version, where the functions communicate the results of their calculations, as well as in the parallel version, in which at least one thread operates on each link. In the last case we will need synchronized queues – and here we will also show how `std::expected` can be used again to create a flexible interface. Everyone is welcome!

Dynamic memory allocations are ever-present in most programs. A simple look at the RAM usage of the browser you are currently using to read this abstract will likely tell you something.
But what of the runtime performance cost? How much (or little) should you be concerned about it and keep it in mind while implementing new features or designing software?

In this talk, we will present a set of about 10 guidelines to keep in mind when dealing with dynamic memory allocation and mitigate its potential performance impact on execution speed. From quite simple to somewhat advanced, everyone should be able to walk away from this talk having learnt something.

C++ is a powerful language, but with great power comes… plenty of pitfalls. Memory management quirks (even when using smart pointers), subtle undefined behaviors, and bug-prone code can silently introduce dangerous behaviors—only to surface at the worst possible moment in production. While static code analysis can catch some of these issues, it requires proper usage and adherence to warnings, and even then, it won’t catch everything. Many of these traps can lead to hard-to-debug issues, safety problems, and security vulnerabilities.
In this talk, we’ll explore some of the most notorious C++ pitfalls and sharp edges, discussing strategies to avoid them and write safer, more resilient code. We’ll walk through both design best practices and C++ coding guidelines to help you navigate the language’s trickier corners with confidence.

In this talk, we will explore the power of C++20 ranges and how custom views can simplify complex data transformations and improve code expressiveness. By creating reusable, lazy-evaluated views that operate on ranges, developers can avoid unnecessary intermediate containers and simplify complex data transformations. While standard views like std::views::transform and std::views::filter offer powerful tools for basic operations, custom views provide additional flexibility, allowing developers to create highly specialized transformations and handle more complex, state-dependent logic.  Through real-world examples, we will demonstrate how custom views enhance performance and maintainability, showcasing how they can streamline everything from basic filtering to complex, state-dependent transformations in modern C++ applications.