Structured bindings in C++17, 8 years later

by Bartlomiej Filipek

From the article:

An excellent demonstration of structured bindings is an iteration through a map object.

If you have a std::map of elements, you might know that internally, they are stored as pairs of <const Key, ValueType>.

Now, when you iterate through elements, you can do:

for (const auto& elem : myMap) { ... } 

You need to write elem.first and elem.second to refer to the key and the value.

std::map<KeyType, ValueType> myMap = getMap(); 
// C++14: 
for (const auto& elem : myMap) {  
     // elem.first - is the key  
     // elem.second - is the value 
}

You should use QPainterPath they said...

by Jens Weller

From the article:

This post is about what I learned while playing around with QPainterPath for this years t-shirt at Meeting C++ 2025 sponsored by Hudson River Trading.

One of the issues from last years t-shirt was when using drawText from QPainter, one does not really *draw* text in an svg exported. Instead you'll get the text and the font kinda embedded in an svg. What good is that in a vector graphic? This was a bit of a surprise when I ran into issues with this last year during printing. While this could be solved with the printing company picking a different font, it would have been also solved by using QPainterPath. At least this was the feedback from some of the Qt experts present onsite or online...

 

Final call for sponsors for Meeting C++ 2025

by Jens Weller

From the article:

With Meeting C++ 2025 just being 5 weeks away, I share a call for sponsors with you.

Maybe your employer is interested in being present as a sponsor at this years Meeting C++ conference? Have you thought about the possibilty that you could have your employer sponsor Meeting C++ 2025?

As an organization Meeting C++ gets its funding through sponsorship and ticket sales for the conference mostly.

How to Look up Values in a Map

by Sandor Dargo

From the article:

Let’s explore the different options — along with their pros and cons.

operator[]

Using operator[] is the old-fashioned way to access elements of a map. It takes a key and returns a reference to the corresponding value. The complexity is log(n) for std::map and average constant time (with worst-case linear) for std::unordered_map.

However, there’s a big caveat.

What if the key is not present in the map?

Unlike a vector — where accessing an invalid index with operator[] leads to undefined behavior — a map will instead insert a new entry with the given key and a default-constructed value. This side effect makes operator[] unsafe for lookups where insertion is not desired.

Safely passing std::strings and std::string_view

by Niek J Bouman

From the article:

Many of you will agree that C++ is a language that comes with sharp edges. One example is `std::string_view`; introduced as a type to prevent unnecessary std::string-copies, but it introduces a new footgun, namely when passing a temporary string into it:

A safe pointer in C++ that protects against use after free and updates when the pointee is moved

by Niek J. Bouman

From the article:

We propose a design for a safe pointer to an object of type T that is weak in that it does not have ownership semantics, and gets notified in case the pointee is either destructed or moved.

We will pay a price at runtime for these extra guarantees in terms of a small heap-allocated state, a double pointer indirection when accessing the pointee (comparable to a virtual function call), and a check against nullptr.

The main idea of our design is to internally use a std::shared_ptr<T*> to share ownership of a (heap-allocated) pointer T*. The ownership is shared by the pointee and all safe_ptr<T> instances. The pointee type T must derive from the base class safe_ptr_factory (templated on T, using the Curiously Recurring Template Pattern) with a destructor that automatically notifies the shared state about destruction by setting T* to nullptr, and with a move constructor and move assignment operator that update T* to the new this pointer (which we must properly cast with static_cast<T*>). The double indirection thus comes from having to dereference the shared_ptr to obtain an ordinary pointer T*, after which you must dereference once more to access the pointee. You might recognize an instance of Gang-of-Four’s observer pattern in our design.

Linus Torvalds and the Supposedly “Garbage Code”

by Giovanni Dicanio

From the article:

So, the correct explicit code is not something as simple as “(a << 16) + b”.

[...] As you can see, the type casts, the parentheses, the potential bit-masking, do require attention. But once you get the code right, you can safely and conveniently reuse it every time you need!

CppCon 2025 Trip Report

by tipi.build by EngFlow

About the report

tipi.build by EngFlow attended both as a developer team and as a CppCon sponsor. Discover in our trip report the highlights from the sessions we attended and the talks we gave, How monday’s afternoon break started with ice cream + key takeaways and resources if you’d like to dive deeper.

C++26: Concept and variable-template template-parameters

by Sandor Dargo

From the article:

C++ already allows passing templates as template parameters, but only if they are class templates. A common reason for doing this is to allow higher-level abstractions. For instance, you may want to pass in a container template like std::vector, without specifying the type it contains.

Jason Turner explains this well in C++ Weekly - Ep 368 - The Power of template-template Parameters: A Basic Guide, but here’s his example for quick reference:

template<template <typename Contained, typename Alloc = std::allocator<Contained>>
		 typename ResultType>
auto get_data() {
	ResultType<double> result;
	// ...
	return result;
}

int main() {
	auto data = get_data<std::vector>();
}

Highlighting the student and support tickets for Meeting C++ 2025

by Jens Weller

From the article:

I'd like to point towards the programs for those that can't afford to pay for a ticket for Meeting C++ 2025: the programs for the student and support tickets.

And let me start with thanking those that enable these programs through their ticket buying: the attendees and sponsors of Meeting C++ 2025! With the schedule published, I'd like to highlight the student and support tickets for Meeting C++ 2025. For a few years now Meeting C++ has hosted programs to give students, underrepresented folks and those who can't afford a ticket access to the conference.

 

Use concepts with std::remove_cvref_t

by Sandor Dargo

From the article:

By now, it’s well known that using unconstrained templates is discouraged. Even the C++ Core Guidelines strongly recommend against it.

T.47 only advises avoiding highly visible unconstrained templates with common names due to the risks of argument-dependent lookup going wrong. T.10 goes further, recommending that we specify concepts for every template argument to improve both simplicity and readability.

The same idea appears in I.9, which suggests documenting template parameters using concepts.

It’s hard to argue with these guidelines. Concepts make code more readable — just by looking at a function, class, or variable template, the reader can immediately tell what kinds of types are accepted.

If you want to learn more about concepts, check out my concepts-related articles or my book on concepts.

But what makes a good concept? That’s a more complex topic — and one we can’t fully cover in a single article.

Simple Compile-Time Dynamic Programming in Modern C++

by Andrew Drakeford

From the article:

Modern C++ enables us to solve mathematical optimisation problems at compile time. With the expanded constexpr capabilities [Fertig21, Turner18, Turner19, Wu24], we can now write clear and efficient optimisation logic that runs during compilation. Fixed-size containers such as std::array fit naturally into these routines. Even standard algorithms, such as std::sort and std::lower_bound, are now constexpr, enabling more straightforward code and more powerful compile-time computations. Additionally, compile-time optimisation generates constant results, which enables the compiler to create even more efficient code. We will use the matrix chain multiplication problem as our worked example.

Matrix chain multiplication

Matrix chain multiplication is a classic dynamic programming problem [Corman22, Das19, Mount]. It aims to determine the most efficient method for multiplying a sequence of matrices. Since matrix multiplication is associative, the order of grouping does not affect the result. However, the number of scalar multiplications involved can vary depending on the grouping.

Consider the three matrices A₁ (10×100), A₂ (100×5), and A₃ (5×50), multiplied in a chain, A₁ × A₂ × A₃.

There are two ways to multiply them:

1. Grouping as (A₁ × A₂) × A₃ first computes a 10×5 matrix, then multiplies that with A₃. This results in 5,000 operations for the first multiplication, and another 2,500 for the second – a total of 7,500 scalar multiplications.
2. Grouping as A₁ × (A₂ × A₃) first multiplies A₂ and A₃, then A₁. This results in 25,000 operations for the first step and 50,000 for the second – a total of 75,000, which is clearly worse.

C++26 reflection at compile-time

by Andreas Fertig

From the article:

While the new standard will have plenty of great improvements the one that will most likely change a lot is reflection at compile-time! In Sofia we voted seven reflection papers into C++26:

• P1306R5 Expansion statements
• P2996R13 Reflection for C++26
• P3096R12: Function parameter reflection in reflection for C++26
• P3293R3: Splicing a base class subobject
• P3394R4: Annotations for reflection
• P3491R3: define_static_
• P3560R2: Error handling in reflection

The papers above should give you enough to read for your vacation. I'll leave that theoretical study up to you for now.

Let's talk practical

The main question is, what can you do with that new feature? Well, I'm not the first one who published their ideas.

Format your own type (Part 2)

by Sandor Dargo

From the article:

Add more options for semantic versioning

Let’s dream big. Instead of only handling major and minor versions (like Python 3.12), let’s aim to fully support semantic versioning.

Semantic versioning (SemVer) is a versioning scheme that conveys meaning about the underlying changes in a release. It typically consists of three parts: MAJOR.MINOR.PATCH.

We should be able to print all these correctly:

ProgrammingLanguage cpp{"C++", 20};
ProgrammingLanguage python312{"Python", 3, 12};
ProgrammingLanguage python31211{"Python", 3, 12, 11};


std::cout << std::format("{:%n%v} is fun", cpp) << '\n';  // C++20 is fun
std::cout << std::format("{:%n %v} is fun", python312) << '\n';  // Python 3.12 is fun
std::cout << std::format("{:%n %v} is fun", python31211) << '\n';  // Python 3.12.11 is fun

Registration is now open for CppCon 2025!

The Programmer CEO

Wednesday, September 17 16:45 - 17:45 MDT

by Greg Law

Summary of the talk:

Many programmers think about starting a company. It’s often not about getting rich so much as to pursue a vision for a computer program that is much bigger than one person could write alone. Like most programmers who start up, I had no formal training and little experience outside of software development. I was naively confident, and didn’t know what I didn’t know (it turned out that that was a LOT!)

The talk includes some of the lessons I’ve learned along the way, many of which were a complete surprise. I’ll cover getting investment, building the product, building a team, and getting and keeping customers. Little of this talk is directly about programming, but it is aimed at programmers who want to create code in order to create a business, or who want to create a business so that they can create the code they want.

Much of the content is also relevant for programmers who find themselves doing non-programming tasks, such as managing people or customer-facing roles, and anyone working at a start-up. Contains candid, warts-and-all war stories, and because it’s for programmers, comes with a no adverts and no business-talk BS guarantee.

Greg is co-founder and CEO at Undo. He is a programmer at heart, but likes to keep one foot in the software world and one in the business world. Greg finds it particularly rewarding to turn innovative software technology into a real business. Greg has over 25 years' experience in innovative start-up software companies.

Registration is now open for CppCon 2025!

Engineers Are Users Too: A Case Study in Design Thinking for Infrastructure

Tuesday, September 16 15:15 - 16:15 MDT

by Grace Alwan

Summary of the talk:

Bringing together strong engineering skills with a foundation in UX Design can open unexpected doors—especially in fields like infrastructure, where there are few engineers trained in design. As a software engineer on an infrastructure team at a fintech company, I work on low-level systems that power how engineers manage compute at scale. But it’s my background in UX and human-computer interaction that’s made me an invaluable asset. By applying design thinking to infrastructure – through prototyping, user interviews, and iteration – I transformed a complex internal workflow and quickly became a subject matter expert.

This talk will walk you through that journey and give you the tools to be a design trailblazer in your own career. You'll leave with practical techniques for integrating empathy and user-centric thinking into deeply technical work—and insights on how expanding your skillset can accelerate your growth as a C++ or systems engineer.

Grace Alwan graduated from Stanford University in 2023, where she got her BS and MS in Computer Science specializing in Human-Computer Interaction. She is now a software engineer in the Technology Infrastructure org at Bloomberg, where she works on cluster and host management.

Planning the next Meeting C++ job fairs

by Jens Weller

From the article:

The next Meeting C++ online job fair is planned for October 14th & 15th, also I'd like to talk about the onsite job fair plans for Meeting C++ 2025!

If you have open positions you should advertise them in the bi-weekly Meeting C++ Jobs Newsletter, which now also powers the candidate listing of Meeting C++ with 80+ international candidates at the moment.

 

Format your own type (Part 1)

by Sandor Dargo

From the article:

std::format was introduced in C++20 and is based on Victor Zverovich’s <fmt> library, which in turn was inspired by Python’s string formatting capabilities.

Let’s skip the fancy formatting options and simply see how to interpolate values using std::format.

#include <format>
#include <iostream>
#include <string>

int main() {
    std::string language{"C++"};
    int version{20};
    std::cout << std::format("{}{} is fun", language, version) << '\n';
}

/*
C++20 is fun
*/

That was easy.

Now imagine you want to print your own type. That won’t work by default.

Registration is now open for CppCon 2025!

Changing /std:c++14 to /std:c++20 - How Hard Could It Be?

Monday, September 15 15:15 - 16:15 MDT

by Keith Stockdale

Summary of the talk:

Rare put in huge amounts of work to bring Sea of Thieves to PlayStation 5 and to upgrade from the old XDK and UWP platforms to the new GDK platform. In this session, Rare will discuss why they made the decision to take this opportunity to also upgrade from C++14 to C++20. It shouldn’t be much harder than changing a 14 to a 20, right? How hard could it be?

Rare will discuss all the work that was involved in upgrading their language standard and share some anecdotes of some of the challenges that were met along the way. They will go through the benefits that they have felt from this upgrade along with some plans for continuing this work in the future.

Keith Stockdale is a Northern Irish senior software engineer who has been working on the Engine and Rendering teams at Rare Ltd for the last 8 years working on Sea of Thieves. At Rare, Keith's main areas of focus are involved in maintaining and creating general purpose simulations that run on the GPU. For example, he is the owner of the GPU particle system that drives the visual effects in Sea of Thieves. Keith is enthusiastic about promoting writing good quality code, whether it is running on the CPU on the GPU. He is driven towards ensuring that the code-bases he works in are enjoyable to work in for all current and future developers on his team.

C++ Day 2025

An event organized by the Italian C++ Community and SEA Vision.

Sponsors: SEA Vision, ELT, Sigeo (and others in the pipeline).

 

All talks will be in English.

 

In a nutshell

Launched in 2016, C++ Day is a community-driven event format by the Italian C++ Community, co-organized with external partners like companies and universities.

The C++ Day 2025 will be held in person on October 25 in Pavia, a joint effort between the Italian C++ Community and SEA Vision, who is also generously hosting the event at their venue.

The event is free to attend, runs for an entire day, and includes coffee breaks and lunch.

 

Who should attend the C++ Day 2025?

This event is made by passionate C++ professionals for C++ professionals, companies, students and enthusiasts.

 

What can I find at the C++ Day 2025?

• 6 tech talks
• 2+ hours of networking
• Some Sponsors on site
• 2 coffee breaks and lunch included
• Cozy atmosphere, games and gadgets

You can refer to the detailed program for more information.

 

When does the C++ Day 2025 take place?

The event will be held on October 25, 2025 at SEA Vision headquarters, in Pavia.

Open doors at 8.30 AM. The event starts at 9.15 AM and will last for a full day.

 

Who supports this event?

Sponsors: SEA Vision, ELT, Sigeo (and others in the pipeline).

 

Do I need to register?

The C++ Day 2025 is free, but you must register to facilitate the organization of the event. You can register here.

Registration is now open for CppCon 2025!

Clean code! Horrible performance?

Friday, September 18 14:45 - 15:45 MDT

by Sandor Dargo

Summary of the talk:

Clean code promises readability, maintainability, and clarity. But is it possible that the pursuit of clean code comes at a catastrophic cost to performance? Some sceptics argue that adhering to clean code practices means sacrificing years - if not decades - of hardware advancements. Is clean code really that expensive? Let’s explore the complex relationship between clean code and software performance. In this talk, we’ll delve into what makes software performant. We’ll demystify the effects of clean code on performance and discover what real bottlenecks are that you’ll encounter while working on enterprise software.

But what is performance, really? While many immediately think of raw runtime speed, the landscape is far more intricate. We’ll explore different facets of performance, including compile-time efficiency, memory usage, and the performance of developers themselves. However, our primary focus will be on runtime performance.

The pivotal question we aim to answer is whether sheer runtime performance always reigns supreme. Can you truly achieve a 10x scale-up by eliminating dynamic polymorphism and virtual function calls? The very idea might seem absurd, but, believe it or not, in some specialized niches, that’s part of the solution. Still, the vast majority of us don’t work in those niches. We face different challenges.

We’ll navigate through real-life examples where awful algorithms hardly mattered, where prudent database and network management became the true path to scalability. I don’t claim that writing code that’s easy to understand and modify always yields optimal performance. Yet, more often than not, performance bottlenecks and the road to performant software lie elsewhere.

Sandor is a passionate software developer focusing on reducing the maintenance costs by developing, applying and enforcing clean code standards. His other core activity is knowledge sharing both oral and written, within and outside of his employer. When not reading or writing, he spends most of his free time with his two children and his wife baking at home or travelling to new places.

Registration is now open for CppCon 2025!

Graphics Programming with SDL 3

Friday, September 19 13:30 - 14:30 MDT

by Mike Shah

Summary of the talk:

The C++ programming language does not have a standard graphics library, However, there exists many popular graphics frameworks for cross-platform graphics. In this talk, I will provide an introduction to the Simple Directmedia Layer (SDL) library, which has at the start of 2025 released version 3. This library for several decades has been a standard in the games and graphics industry. Throughout this talk, I will show how to get started with the library, some more advanced examples (including compiling graphics applications to web), and then talk about what a standard graphics library could look like in C++, or if it is even necessary. I will also talk about the 3D GPU library in SDL3. Attendees will leave this talk ready to build multimedia / game applications and with an understanding on if SDL3 is the right tool for them.

Mike Shah is currently a teaching faculty with primary teaching interests  in computer systems, computer graphics, and game engines. Mike's research interests are related to performance engineering (dynamic analysis), software visualization, and computer graphics. Along with teaching and research work, Mike juggles occasional consulting work as a 3D Senior Graphics Engineer in C++ and producing programming content at his YouTube channel https://www.youtube.com/@MikeShah

Planning a 5th track for Meeting C++ 2025

by Jens Weller

From the article:

I'm working on adding a 5th Track to Meeting C++ 2025 for onsite.

Already last year I've been thinking about this, but in the end its been to expensive to do, and hence only feasible with a large increase in onsite attendees. This year I'm able to go a different route through sponsorship, and thus for onsite the cost is covered by sponsors. Which in turn then also contribute talks. I hope that most talks will be in the schedule by October, and I plan to release the first talks in September for the new track. Right now the track is not visible in the schedule, as I don't want to add an empty track. We may also stream the online track into the conference in a room.

 

Registration is now open for CppCon 2025!

The Pattern Matching We Already Have

Friday, September 19 09:00 - 10:00 MDT

by Braden Ganetsky

Summary of the talk:

All the way since C++98, we have already had pattern matching in C++! It's limited to specific places, but it's there. Template argument deduction, function overload resolution, and class template specializations are all instances of pattern matching in the C++ language, dating all the way back to the original standard.

The C++11 additions to the language also require library constructs to help deal with type deduction in forwarding references, namely std::forward, among others. Even experienced C++ developers may run into unexpected situations using it, especially in newer scenarios like concepts from C++20. This talk will lay clear the rules of forwarding and std::forward, and how you can forward your arguments properly every time.

This interactive talk is a deep dive into template argument deduction, helping you to understand it at deeper level across all of C++'s lifespan. Almost all that applies in C++98 still applies today, so a foundational understanding is important. Additionally, newer language standards have introduced further wrinkles, like C++11's move semantics and variadic template parameters, as well as C++17's class template argument deduction. By the end of this talk, you will have a solid understanding of how C++ deduces the types used in your code.

Braden Ganetsky graduated from the University of Manitoba with a degree in mechanical engineering, fueled by his passion for mechanical puzzles. During his final year of school, when all classes and activities were remote, he discovered C++ and has been hooked ever since. He interned as a C++ developer, which turned into a full time job, completing a successful pivot of his career. Now he spend his nights working on fun projects like parser combinators, and getting involved in the C++ community. Since 2023, Braden sits on the ISO C++ Committee as a representative of Canada.

Registration is now open for CppCon 2025!

Using Distributed Trace for End-to-End Latency Metrics

Thursday, September 18 15:15 - 16:15 MDT

by Kusha Maharshi

Summary of the talk:

In this talk, we'll delve into how we utilized distributed trace to address a prevalent need at a large technology company that serves the finance industry: timing requests from point A to point Z in a complex system, where a whole alphabet's worth of steps occur in between. We'll show how tracing, an open source telemetry standard, helped us generate insights from tracking requests in a complicated, microservices-driven architecture. We'll discuss the challenges faced and lessons learned while building a C++ solution that turns trace data into end-to-end latency metrics. We hope to inspire attendees to apply these lessons to telemetry solutions tailored to their own firms' needs.

Distributed tracing was introduced within our company before it was a stable, open standard. We saw its potential and invested in solutions that utilized its rich, cross-service information. However, existing open source or commercial products didn't fit the complexity and scale of our trace data. Our engineers, incident responders, and managers wanted end-to-end latency metrics to observe complex workflows, so we built our own solution! The resulting metrics now drive service level objectives (SLOs) that set measurable targets that define a system's quality and reliability. When these targets are not met, teams are alerted, thus driving quick remediation. Furthermore, the traces corresponding to any degradation in system health can be used to pinpoint faulty components, as well as aid in the development and testing phases when building new solutions.

From a technical point of view, trace data is represented as directed acyclic graphs (DAGs), and our challenge was processing more than 50 billion daily nodes, with deep fan-outs and fan-ins. These graphical structures mirror real-world scenarios like queuing systems for high-volume messaging, order processing or batched email notifications, and present concurrency choke points at scale. In this talk, we'll break down the design of the C++ microservices we built to process large-scale streaming graphs into metrics, while also addressing scalability bottlenecks. We'll also highlight why we chose C++ and its libraries, powerful profiling tools, and efficient data structures. If you're into building low-latency, high-throughput distributed systems, want to build telemetry solutions that best suit your needs, or just enjoy geeking over graphs, this talk is for you!

Kusha Maharshi is a Senior Software Engineer at Bloomberg, where she passionately works on distributed tracing and observability infrastructure. An avid public speaker, she loves breaking down complex technical challenges with clarity – and a dose of humor. Kusha holds a degree in Computer Science from Carnegie Mellon University, where she specialized in computer systems. Her favorite programming language? Assembly.

A Library Approach to Constant Template Parameters

by Barry Revzin

From the article:

This library achieves two things.

First, it is just, in general, very useful. I’m hoping to make it more of a Real Library™️ once Reflection gets implemented in more than just the Bloomberg fork of Clang that Dan Katz implemented.

Second, I think it demonstrates the power of Reflection. There are so many problems that were not possible in C++23 that become solvable in C++26. We’re going to spend the next several years discovering more of those, and that makes it a pretty exciting time for C++.

Registration is now open for CppCon 2025!

C++ Parallel Programming Models

Thursday, September 18 14:00 - 15:00 MDT

by Eran Gilad

Summary of the talk:

Modern C++ offers a wealth of parallel programming features. Those features belong to four different programming models: low-level, a-sync, cooperative multitasking, and data parallel. The low-level model (or rather, non-model) contains the basic building blocks – threads, atomics, mutex etc. The a-sync model contains async, future and related classes. The cooperative multitasking model relies on coroutines. Lastly, the data parallel model contains the parallel algorithms. The four models aren’t just different abstraction levels – each is appropriate for a different program structure. This talk will review the four models, describe the central features used by each model, and discuss the expected use case for each one. Since many of the parallelism features are not new to the language at this point, the talk will not focus on the details of the features themselves. Instead, the talk will put them in the context of a programming model and make the choice of parallel programming features easier for C++ developers.

Eran Gilad is a software engineer at Regatta Data, where he works on one of the most fascinating areas of software development: database internals. Before diving deep into database engineering, Eran was a principal research engineer at Yahoo Research and a member of a systems research group. He holds a PhD in Computer Science from the Technion, where his work centered on various aspects of parallel programming and execution. Beyond his professional work, Eran is passionate about developer communities. He co-organizes the Core C++ conference, the Haifa::C++ meetup group, and the Medabrim C++ WhatsApp group. His involvement in these communities stems from his first job experience, where he was the sole C++ developer at his company for several years.

C++26: std::format improvements (Part 2)

by Sandor Dargo 

From the article:

Runtime format strings

P2216R3 brought quite some improvements to std::format, including compile-time checking for format strings. Sadly, in use cases where format strings were only available at runtime, users had to go with the type-erased formatting version, std::vformat:

std::vformat(str, std::make_format_args(42));

Using two different APIs is not a great user experience, moreover, std::vformat was designed to be used by formatting function writers and not by end users. In addition, you might run into undefined behaviour, detailed in the next section.

To overcome this situation, P2918R2 adds std::runtime_format so you can mark format strings that are only available at run-time. As such you can opt out of compile-time format strings checks. This makes the API cleaner and the user code will read better as it shows better the intentions.

Registration is now open for CppCon 2025!

Back to Basics: static, inline, const, and constexpr

Thursday, September 18 09:00 - 10:00 MDT

by Andreas Fertig

Summary of the talk:

C++ comes with a whole toolbox of keywords you can apply to types and functions. You think it's straightforward? My experience says otherwise. There are false-friends like static , which I often see misapplied.

In this talk, I will demystify those tricky little keywords. You'll learn what they really mean, how they behave in different contexts, and — most importantly — when to use them (and when not to). Think const, constexpr, consteval, constinit: yes, C++ has more flavors of constness than your local ice cream shop. We'll explore them all.

We'll go beyond syntax and dive into what's actually happening in the language.

While the talk includes some features from C++23, most of what we cover is rooted in C++11 or even classic C++98. We'll touch on important concepts like the One Definition Rule (ODR) and top-level qualifiers, giving you a deeper understanding of how these keywords shape your code.

After this session, you'll walk away knowing exactly where each keyword belongs. No more guesswork. Just the right keyword in the right place.

Andreas Fertig, CEO of Unique Code GmbH, is an experienced trainer and consultant for C++ for standards 11 to 23. Andreas is involved in the C++ standardization committee, developing the new standards. At international conferences, he presents how code can be written better. He publishes specialist articles, e.g., for iX magazine, and has published several textbooks on C++. With C++ Insights (https://cppinsights.io), Andreas has created an internationally recognized tool that enables users to look behind the scenes of C++ and thus understand constructs even better. Before training and consulting, he worked for Philips Medizin Systeme GmbH for ten years as a C++ software developer and architect focusing on embedded systems. You can find Andreas online at andreasfertig.com.

Registration is now open for CppCon 2025!

Welcome to v1.0 of the meta::[[verse]]!

Wednesday, September 17 16:45 - 17:45 MDT

by Inbal Levi

Summary of the talk:

This talk will introduce what is (likely) the final version of the "Reflection" feature targeting C++26.

With a proposal to introduce reflection to C++26 (including the “std::meta” namespace) slated to be voted into the standard in June 2025, we can already start imagining a whole new world of possibilities.

In this session, we will dive into reflection and its transformative potential within our codebases. We will start with a brief history of "reflection" history. We'll continue with an introduction of utilities from the latest reflection proposal. Then, we delve deeper into practical applications and demonstrate solutions to problems that commonly use reflection and the power it holds. For the last part, we will explore the possibilities within “Reflection Libraries”. This includes both “traditional” libraries which provide functionality, and more “novel” approaches which reshape users’ code. We will look at examples of what such libraries can cover, and demonstrate potential directions the future holds. Last but not least, we will discuss how "Reflection" may impact the way we manage our codebases and the delivery process.

Join us as we traverse the meta::[[verse]]!

​Inbal Levi is a Lead Software Engineer at Millennium (MPGC Services Ltd) with a passion for high performance, readability, compilers, language, and software design. She is an active member of the ISO C++ Standards Committee as Library Evolution Work Group Chair, and as the ISO C++ Israeli NB Chair. Inbal is also a director at ISO C++ Foundation and the Boost Foundation and puts effort into evolving both the local and international C++ communities, as an organizer of the CoreC++ conference and meetup group, and as the program chair of C++Now.

C++26: std::format improvement (Part 1)

by Sandor Dargo

From the article:

Arithmetic overloads of std::to_string and std::to_wstring use std::format

P2587R3 by Victor Zverovich proposes replacing sprintf with std::format in the arithmetic overloads of std::to_string and std::to_wstring.

The motivation?

std::to_string has long been known to produce not-so-great and misleading results (differing from iostreams), especially with floating-point values. std::to_string uses the global C locale. In practice, it’s unlocalized. Also, it often places the decimal points to suboptimal places:

std::cout << std::to_string(-1e-7); // prints: -0.000000 
std::cout << std::to_string(0.42); // prints: 0.420000

These outputs are imprecise and often unnecessary. By leveraging std::format (and ultimately std::to_chars), we now get clearer, shorter representations. The representations of floating-point overloads become also unlocalized and use the shortest decimal representations.

As a result, the above outputs would change as follow:

    std::cout << std::to_string(-1e-7);  // prints: -1e-7
    std::cout << std::to_string(0.42); // prints: 0.42

Registration is now open for CppCon 2025!

C++: Some Assembly Required

Friday, September 19 16:15 - 18:00 MDT

by Matt Godbolt

Summary of the talk:

Join Matt in exploring how the C++ ecosystem has evolved through the interplay of intentional design and emergent collaboration. Standards committees craft language features and compiler teams implement them, but something amazing happens in the spaces between: tools appear, communities form, and solutions emerge that nobody quite planned for. What started as individual developers solving their own problems has grown into an interconnected ecosystem that shapes how we all write C++.

From documentation to testing, from build systems to package managers, we'll examine how the C++ community has assembled itself around shared pain points and accidental standards. Using examples and perhaps too many rainforest metaphors, this talk celebrates not just the language we've built, but the organic ecosystem that's grown up around it. Come discover why C++'s greatest strength might be that it's always required some assembly.
Presenters

Matt Godbolt is the creator of the Compiler Explorer website. He is passionate about writing efficient code. He has previously worked at a trading firm, on mobile apps at Google, run his own C++ tools company and spent more than a decade making console games. When he's not hacking on Compiler Explorer, Matt enjoys writing emulators for old 8-bit computer hardware.

Registration is now open for CppCon 2025!

Keynote: More Speed & Simplicity:Practical Data-Oriented Design in C++

Thursday, September 18 10:30 - 12:00 MDT

by Vittorio Romeo

Summary of the talk:

Data-Oriented Design (DOD) presents a different way of thinking: prioritizing data layout not only unlocks significant performance gains via cache efficiency but can also lead to surprising simplicity in the code that actually processes the data.

This talk is a practical introduction for C++ developers familiar with OOP. Through a step-by-step refactoring of a conventional OOP design, we’ll both cover how data access patterns influence speed and how a data-first approach can clarify intent.

We’ll measure the performance impact with benchmarks and analyze how the refactored code, particularly the data processing loops, can become more direct and conceptually simpler.

Key techniques like Structure-of-Arrays (SoA) vs. Array-of-Structures (AoS) will be explained and benchmarked, considering their effects on both execution time and code clarity. We’ll pragmatically weigh the strengths (performance, simpler data logic) and weaknesses of DOD, highlighting how it can complement, not just replace, OOP.

We’ll also demonstrate that DOD doesn’t necessitate abandoning robust abstractions, showcasing C++ techniques for creating safe, expressive APIs that manage both complexity and performance.

Let’s learn how thinking “data-first” can make your C++ code faster and easier to reason about!

Vittorio Romeo (B.Sc. Computer Science, 9+ YoE at Bloomberg) works on mission-critical C++ infrastructure and provides Modern C++ training to hundreds of fellow employees. He began programming around the age of 8 and became a C++ enthusiast shortly after discovering the language. Vittorio created several open-source C++ libraries and games, published many video courses and tutorials, actively participates in the ISO C++ standardization process, and maintains the popular SFML library. He co-authored the acclaimed "Embracing Modern C++ Safely" book (published in January 2022) with J. Lakos, R. Khlebnikov, and A. Meredith. Vittorio is an active member of the C++ community with an ardent desire to share his knowledge and learn from others: he presented and offered workshops over 20 times at international C++ conferences (including CppCon, C++Now, ++it, ACCU, C++ On Sea, C++ Russia, and Meeting C++), covering topics of various nature. He also maintains a website with advanced C++ articles and a YouTube channel featuring well-received modern C++11/14 tutorials. Lastly, he's active on StackOverflow, taking great care in answering interesting C++ question (90k reputation). When he's not writing code, Vittorio enjoys weightlifting, playing volleyball, scuba diving, canyoning, gaming, and enjoying sci-fi content.

Release 1.89 of the Boost C++ Libraries is now available.

One new library and updates to 28 more.

Bloom, configurable filters for probabilistic lookup: https://boost.org/libs/bloom

Registration is now open for CppCon 2025!

Crafting the Code You Don't Write: Sculpting Software in an AI World

Tuesday, September 16 10:30 - 12:00 MDT

by Daisy Hollman

Summary of the talk:

It’s shockingly uncontroversial to say that the fields of developer experience and developer productivity have changed more in the past six months than in the 25 years before that.

As part of the Claude Code team at Anthropic, I’ve had the privilege of witnessing the evolution of agentic coding from proof-of-concept experiments to nearly autonomous software engineers in just six months. In this keynote, I’ll share some of my experiences and learnings from that journey, talk about how LLMs work more generally, attempt some live demonstrations of the latest functionality, explore the future of agentic programming, and tie all of this back to what it means for your workflow as a software engineer.

When I agreed to give this talk earlier this year, there was some portion of the narrative that involved “why you should be using agents to accelerate your development process.” Since then, the world of software engineering has evolved such that the interesting question is no longer “why” but “how.” Like sculptors facing the invention of power tools, or painters around the invention of photography, we now live in a world where vast quantities of rough-draft code can be generated with a very low barrier to entry. How does the role of a software engineer evolve when AI can autonomously implement features from requirements? How do we build safety features into the power tools we’re chiseling away at our codebases with? What aspects of software craftsmanship become more important, not less, in an age of abundant code generation? And critically for the C++ community: how do we leverage these tools where correctness and performance are non-negotiable? The future isn’t about AI replacing programmers, but about a fundamental shift in how we think about software creation. And surprisingly, you might not miss the old way of doing things.

Dr. Daisy Hollman is a distinguished software engineer and programming language expert, known for her impactful contributions to the C++ standards committee since 2016. She has worked on C++ language and library design at Google, and more recently joined Anthropic, where she explores the intersection of programming languages and AI systems.

Registration is now open for CppCon 2025!

Keynote: Reflection: C++’s Decade-Defining Rocket Engine

Wednesday, September 17 10:30 - 12:00 MDT

by Herb Sutter

Summary of the talk:

In June 2025, C++ crossed a Rubicon: it handed us the keys to its own machinery. For the first time, C++ can describe itself—and generate more. The first compile-time reflection features in draft C++26 mark the most transformative turning point in our language’s history by giving us the most powerful new engine for expressing efficient abstractions that C++ has ever had, and we’ll need the next decade to discover what this rocket can do.

This session is a high-velocity tour through what reflection enables today in C++26, and what it will enable next. We’ll start with live compiler demos (Godbolt, of course) to show how much the initial C++26 feature set can already do. Then we’ll jump a few years ahead, using Dan Katz’s Clang extensions and my own cppfront reflection implementation to preview future capabilities that could reshape not just C++, but the way we think about programming itself.

We’ll see how reflection can simplify C++’s future evolution by reducing the need for as many bespoke new language features, since many can now be expressed as reusable compile-time libraries—faster to design, easier to test, and portable from day one. We’ll even glimpse how it might solve a problem that has long eluded the entire software industry, in a way that benefits every language.

The point of this talk isn’t to immediately grok any given technique or example. The takeaway is bigger: to leave all of us dizzy from the sheer volume of different examples, asking again and again, “Wait, we can do that now?!”—to fire up our imaginations to discover and develop this enormous new frontier together, and chart the strange new worlds C++ reflection has just opened for us to explore.

Reflection has arrived, more is coming, and the frontier is open. Let’s go.

Herb is an author, designer of several Standard C++ features, and chair of the ISO C++ committee and the Standard C++ Foundation. His current interest is simplifying C++.

Registration is now open for CppCon 2025!

To Err is Human: Robust Error Handling in C++26

Wednesday, September 17 15:15 - 16:15 MDT

by Sebastian Theophil

Summary of the talk:

Every program may encounter errors, some originating from internal bugs in the program, others coming from the environment the program is operating in. Ignoring all errors will make the program utterly unreliable, while treating every conceivable one introduces lots of extra complexity with little benefit. So which errors should you handle? And how should you handle them? This talk describes our proven approach to error handling so that you can write more reliable software with less effort.

C++23 and C++26 have seen several improvements to C++ error handling: std::stacktrace, std::expected, contracts and library hardening. We will cover these features as well and how to best use them in practice to catch more errors, report them and fix them.

Sebastian has been working at think-cell since its founding in 2002. In the last few years, among many other things, he has ported think-cell to run on macOS. He is also the maintainer of the typescripten project which lets programmers call JavaScript libraries from C++ code compiled to WebAssembly in a convenient and type-safe way. He enjoys leaving his desk from time to time to talk at international C++ conferences.

Registration is now open for CppCon 2025!

Mastering the Code Review Process

Wednesday, September 17 15:15 - 16:15 MDT

by Peter Muldoon

Summary of the talk:

In software development, significant attention is given to writing clean, maintainable code. Yet, despite the best of intentions, many codebases drift from structured practices due to inconsistent or ineffective code reviews. This is a real problem as it is the last line of defense before merging and deploying changes to production.

Engineers spend far more time reading code than writing it. Even small changes demand a thorough understanding of the surrounding code to prevent errors and unintended consequences. An effective code review process significantly amplifies good coding practices, structured problem-solving, and overall code quality.

This talk outlines core principles for conducting impactful code reviews emphasizing methodologies that balance consistent evaluation with the flexibility for handling the inevitable unusual situations.

We will also explore practical ways to measure code review effectiveness , enabling teams to continuously improve their code review process. What would a code review checklist look like? What are the consequences and friction points of a poor code review process?

As the code review process matures within an organization, it can also be shown to act as an effective instructional tool and drive positive organizational change , enhancing both the quality of the codebase and the capability of individual teams.

Pete Muldoon has been using C++ since 1991. Pete has worked in Ireland, England and the USA and is currently employed by Bloomberg. A consultant for over 20 years prior to joining Bloomberg, Peter has worked on a broad range of projects and code bases in a large number of companies both tech and finance. Such broad exposure has, over time, shown what works and what doesn't for large scale engineering projects. He's a proponent of applied engineering principles, elegant solutions and expressive code.

Once More About dynamic_cast, a Real Use Case

by Sandor Dargo

From the article:

I wrote a couple of times about dynamic_cast and I discouraged you from using it. In general, it makes code worse in terms of readability. When you get rid of dynamic_cast, either via self-discipline or by turning RTTI off, you’ll have to rely on dynamic dispatching and better abstractions.

But there might be cases, when it’s not possible or at least it’s not meaningful to remove dynamic_cast, here is one, sent by one of you.

Versioning with the help of dynamic_cast

They have an SDK that anyone can implement. As there are new features added every now and then, the API keeps changing. Not surprisingly, the owners of the SDK want to prevent their users’ code from breaking. They achieve this by having different “versioned” interfaces for the same service where a new version inherits from the previous one.

Let’s see a simplified example.

Registration is now open for CppCon 2025!

Best Practices for AI Tool Use

Wednesday, September 17 09:00 - 10:00 MDT

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?!

Jason is host of the YouTube channel C++Weekly, co-host emeritus of the podcast CppCast, author of C++ Best Practices, and author of the first casual puzzle books designed to teach C++ fundamentals while having fun!

Trip report: C++ On Sea 2025

by Sandor Dargo

From the article:

First, a heartfelt thank-you to the organizers for inviting me to speak, and an equally big thank-you to my wife for taking care of the kids while I spent three days in Folkestone — plus a few more in London to visit the Spotify office and catch up with some bandmates.

If you have the chance, try to arrive early or stay around Folkestone for an extra day. It’s a lovely town and it’s worth exploring it. The conference program is very busy even in the evenings, so don’t count on the after hours.

This year, I arrived an half a day in advance and I had a wonderful hike from Folkestone to Dover. It was totally worth it.

In this post I’ll share:

• Thoughts on the conference experience.
• Highlights from talks and ideas that resonated with me.
• Personal impressions, including reflections on my own sessions — both the main talk and the lightning talk.

Registration is now open for CppCon 2025!

std::optional --- Optional Over References

Tuesday, September 16 15:15 - 16:15 MDT

by Steve Downey

Summary of the talk:

Optionals were first proposed for C++ in 2005.

Optional , where T is constrained not to be a reference, was added in 2017.

Optionals for lvalue references are on track to be added in C++ 26.

What are we getting and what design choices were made? This talk will show the results.

This talk will discuss the early history of Optionals, starting with Boost.Optional and “N1878: A Proposal to Add an Utility Class to Represent Optional Objects (Revision 1)”, and what the early concerns were for the reference specialization. “P1175R0: A Simple and Practical Optional Reference for C++” then re-proposed reference support for C++20, which was not adopted. In 2020, “P1683R0: References for Standard Library Vocabulary Types - an optional<> case study” surveyed existing behavior of optional references in the wild, and pointed out the trap of assignment behavior being state dependent. In 2023, “P2988R0: Std:Optional” picked up the torch again, and Revision 10 of that is the proposal that is approved by the Library Working Group.

In 2024, “P3168R0: Give Std:Optional Range Support”, the proposal to make optional a range -- as opposed to having a separate range of zero or one -- was adopted. The reference implementation for optional

Steve Downey has been a programmer for more than 30 years. Steve graduated from SUNY Purchase with a BS in Mathematics. A Computer Science degree would have involved two classes before 11:00 am, so was impossible.

He has worked at Bloomberg since 2003, and is currently working as an Engineer on the C++ Infrastructure team.

Registration is now open for CppCon 2025!

Back to Basics: Refactoring

Tuesday, September 16 09:00 - 10:00 MDT

by Amir Kirsh

Summary of the talk:

Writing C++ code is one thing, keeping it clean, readable and maintainable over time is another. In this talk, we'll review the basics of refactoring C++ code, focusing on strategies to improve code clarity, reduce duplication, and make your code easier to maintain. You'll learn how to identify code smells, recognize when refactoring is needed, and apply techniques to improve readability. We will also explore how to modernize your code by leveraging new C++ features when relevant, ensuring that your code not only adheres to best practices but is also aligned with the evolving standards of the language. Participants will gain practical knowledge on how to refactor C++ code to enhance clarity, reduce complexity, and improve long-term maintainability, a skill that becomes even more essential as AI starts generating parts of our codebase. This talk is part of the Back to Basics track and is designed for C++ beginners, but it can also be useful for intermediate and experienced developers who want to revisit the fundamentals of maintaining clean, well-structured C++ code through effective refactoring.

Amir Kirsh is a C++ lecturer at the Academic College of Tel-Aviv-Yaffo and Tel-Aviv University, previously the Chief Programmer at Comverse, after being CTO and VP R&D at a startup acquired by Comverse. He is also a co-organizer of the annual Core C++ conference and a member of the ISO C++ Israeli National Body.

A virtual destructor in C++, when?

by Andreas Fertig

From the article:

In today's post, I would like to explain a design rationale used in my post Understanding the inner workings of C++ smart pointers - The shared_ptr.

Keen readers spotted that in my implementation of ctrl_blk_base, I didn't make the destructor virtual. Here is the original code for easy reference:

PVS-Studio 7.38: new C++ analyzer core, user annotations in Java, enhanced taint analysis, and more

by Aleksandra Uvarova

From the article:

The C and C++ analyzer got a new core with completely redesigned components like a parser, a semantic analyzer, and a type system. The new core provides more accurate handling of template constructs and better parsing of the standard library and code based on modern C++ standards. During the extended testing period (EAP), the new core demonstrated stable performance across a wide range of real-world projects.

The Missing Step: Making Data Oriented Design One Million Times Faster

Tuesday, September 16 09:00 - 10:00 MDT

by Andrew Drakeford

Summary of the talk:

Data-oriented design (DOD) has gained traction for its practical approach to solving real-world problems. Refactoring data into an Entity-Component format sets the stage for cleaner, more efficient implementations, where lambdas process ranges and SIMD operations exploit the power of contiguous data layouts. DOD is widely recognised for addressing hardware-related performance challenges, but where do these challenges originate? The engineers behind our hardware platforms didn’t design performance bottlenecks; they created performance opportunities. By engineering how our code interacts with hardware, we can unlock these opportunities and achieve substantial speed-ups. The key lies in understanding and exploiting the state of the system. From the instruction cache and registers to the L1 cache and memory access patterns, the processor's statefulness plays a crucial role in performance. Writing "hardware-friendly" code is fundamentally about aligning with this state. But hardware is only part of the equation. What about the statefulness of our software? By carefully engineering the sequence of operations and algorithms to align with both hardware and software states, we can achieve unparalleled optimization. This is the missing step. Engaging with the design problem in full can be very difficult. We leverage George Polya’s problem-solving process and heuristics to guide our approach. This presentation explores these principles through real-world examples in machine learning and mathematical finance, demonstrating how addressing both sides of the problem can improve performance by orders of magnitude. (Yes, even six orders of magnitude.) Attendees will leave with insights into the exploration process and actionable techniques that might lead to achieving similar gains in their own work. It has been noted that some attendees might start drawing more diagrams when problem-solving and have an overwhelming urge to get Polya’s book.

Andrew Drakeford A Physics PhD who started developing C++ applications in the early 90s at British Telecom labs. For the last two decades, he has worked in finance developing efficient calculation libraries and trading systems in C++. His current focus is on making quant libraries more ecologically sound. He is a member of the BSI C++ panel.

Reflecting JSON into C++ Objects

by Barry Revzin

From the article:

Last week, C++26 was finalized in Sofia, Bulgaria — and C++26 will include all of the reflection papers that we were pushing for:

1. P2996R13: Reflection for C++26
2. P3394R4: Annotations for Reflection
3. P3293R3: Splicing a Base Class Subobject
4. P3491R3: define_static_{string,object,array}
5. P1306R5: Expansion Statements
6. P3096R12: Function Parameter Reflection in Reflection for C++26
7. P3560R2: Error Handling in Reflection

Those are in the order in which they were adopted, not in the order of their impact (otherwise splicing base classes would go last). This is a pretty incredible achievement that couldn’t have happened without lots of people’s work, but no one person is more responsible for Reflection in C++26 than Dan Katz.

So today I wanted to talk about a very cool example that Dan put together on the flight home from Sofia, while I was unconscious a few seats over: the ability to, at compile time, ingest a JSON file and turn it into a C++ object. That is, given a file test.json that looks like this:

{ "outer": "text", 
"inner": { "field": "yes", "number": 2996 } 
} 

We can write this:

constexpr const char data[] = { 
     #embed "test.json" 
     , 0 

}; constexpr auto v = json_to_object<data>;

Registration is now open for CppCon 2025!

What's New for Visual Studio Code: Performance, Debugging, & GitHub Copilot Agents

Tuesday, September 16 09:00 - 10:00 MDT

by Alexandra Kemper

Summary of the talk:

Join us for a deep dive into the latest advancements for C++ in Visual Studio Code, designed to help modern C++ developers tackle real-world challenges with a faster, smarter, and more customizable development environment. In this talk, we’ll showcase updates to the C++ extension, featuring several performance improvements and new LLDB debugging capabilities that will streamline the process of identifying and resolving issues in your code. We’ll also explore updates to the CMake Tools extension, including new CMake language services that are now available in-house to provide rich language support for CMake files. Additionally, discover how GitHub Copilot support for C++ developers has evolved in the last year, including the new Agent mode that can help you with complex, multi-step coding tasks such as modernizing your C++ repo. Whether you are maintaining legacy code or building for the future with C++, Copilot can help you write, build, and refactor your C++ code to streamline your development experience – all within VS Code.

Alexandra Kemper graduated from the University of Virginia with a BS in Computer Science. She works at Microsoft as the PM of the C++ Extension.