CppCon 2026

A fundamental control structure of each programming language are loops. And we all expect them to be simple and self explanatory. However, C++ would not be C++, if there would be no tricky details to learn and respect about loops in C++.

This talk takes its time to discuss the various ways and approaches to program loops in C++. Beside basic while and for loops, we talk about the range-based for loop, and all the extensions recently added to these control structures.

In addition, we will look at other ways to program loops in C++, such as using algorithms and how to deal with parallel computing in a loop.

As a result you get a deeper understanding of the various ways loops can be programmed in Modern C++ so that you know better how to use them in practice.

C++20 modules are finally usable end to end, from your own modules to 'import std;' The functional build-system support with real diagnostics. This talk teaches modules the way #include was once taught: with small files, a build, and concrete use cases. Modules stopped being experimental somewhere around 2025. This session builds the mental model from scratch: what a primary module interface unit is, how partitions and implementation units fit together, and, crucially, how import differs from #include in ways that matter day to day. It uses a small library, exposes it as a module, splits it across partitions, consumes import std; and observes the compile-time effect. Then it answers the questions every team hits in week one: how modules interact with macros, with templates in headers, with header-only dependencies, and with a mixed codebase that can't convert everything at once. The examples will be using CMake, clang and recent gcc. You will leave able to structure a small library as a module, explain why a macro didn't cross a module boundary, and plan an incremental adoption that doesn't require converting the whole tree.

Have you ever wondered why your C++ class suddenly doubled in size, or why reordering its members made it smaller? This talk introduces memory alignment in C++ from the ground up - what it is, why it is critical, and how compilers handle it under the hood. We’ll start from first principles: how modern CPUs read memory, the difference between aligned and unaligned access, and the performance costs of getting it wrong. Using benchmarks, we’ll see just how impactful misalignment can be. From there, we’ll dive into how compilers lay out data members in structs and classes, and how simple reordering can reduce memory footprint. Live coding examples will illustrate how padding is introduced and how tools like alignas, alignof, and std::align give you precise control. We’ll also look at packed data structures, which trade alignment guarantees for compactness - common in network protocols. While they can save space, they also introduce risks like undefined behavior when misused. Through real-world examples, you'll learn when packed structures make sense, and when they’re a hazard. By the end of the talk, you'll walk away with a solid intuition for alignment and the confidence to manage memory layout effectively in your programs.

AI coding agents are transforming how we write C++ code and come with a growing extensibility stack. Between hooks, skills, and MCP servers it's not obvious when to reach for which in your day to day workflow. This talk demonstrates the differences through demos in a real C++ codebase. We'll build a hook that runs the project's linter and lets the agent fix any issues it finds, create a skill to flag C++ performance pitfalls, and use an MCP server to verify portability across compilers, with each technique solving a problem the others can't. Along the way, you'll see how these mechanisms compose into a single workflow. Whether you're just getting started with AI tooling or already using it daily, you'll leave knowing exactly which tool to reach for and how to get the most out of your AI coding agent for C++ development.

C++ library maintainers are often in the dark as to everyone who actually depends on their code. Without that knowledge, deprecation decisions are guesses, the downstream impact of any API change is hard to predict, and the case for funding or continued investment is difficult to make rigorously. This talk demonstrates how mapping your downstream ecosystem changes the way you maintain and evolve a library, using dependent-audit, an open-source tool that discovers real-world dependents by searching public source code for #include directives and CMake integration files, and cross-referencing published academic citations. We'll show concrete examples of what this data reveals: where your true API surface lies, which users are candidates for upstream contribution, and how to make the case for your project's real-world significance. Attendees will leave with a lens for library stewardship built on data and ecosystem analysis