: Standard C++

Home »

« Prev Next »

What reinterpret_cast doesn't do -- Andreas Fertig

By Blog Staff | May 18, 2026 03:45 PM | Tags: None

In today's post, I will explain one of C++'s biggest pitfalls: reinterpret_cast. Another title for this post could be: This is not the cast you're looking for!

What reinterpret_cast doesn't do

Andreas Fertig

From the article:

My motivation for this blog post comes from multiple training classes I thought over the past several months and a couple of talks I gave. Since C++23, you have a new facility in the Standard Library: std::start_lifetime_as. When teaching class with a focus on embedded environments or presenting talks with such a focus, I started to add std::start_lifetime_as to the material. With an interesting outcome.

The feedback I get is roughly:

why do I need std::start_lifetime_as, I already have reinterpret_cast?

why can I use reinterpret_cast?

If you never heard of start_lifetime_as please consider reading my post, The correct way to do type punning in C++ - The second act.

PVS-Studio in CMake: It's official now

By Andrey Karpov | May 18, 2026 07:08 AM | Tags: sast pvs-studio cmake

If you're working on a cross-platform project in C or C++, you usually don't rely on a single build system, but instead use a build script generator. CMake, the most popular one, has recently been officially integrated with PVS-Studio static analyzer for these languages.

PVS-Studio in CMake: It's official now

by Taras Shevchenko

From the article:

Using the built-in integration to analyze code limits your options for interacting with the analysis results: the PVS-Studio report is not saved, since source code files are analyzed individually. So, the report conversion via plog-converter is unavailable, but you can aggregate analyzer warnings in CDash—a test result monitoring system also developed by Kitware. The developers on the CMake team did just that—you can see the result of the integration here.

BeCPP Symposium 2026 - Gabriel Dos Reis - Tightening the Screws with C++ Profiles

By Marc Gregoire | May 16, 2026 01:41 AM | Tags: c++26 becppsymposium2026 becpp

BeCPP Symposium 2026 (organized by BeCPP): Now on YouTube!

Gabriel Dos Reis - Tightening the Screws with C++ Profiles

Abstract:

The C++ community has been challenged to provide practical solutions to the problem of memory safety prevalent in some software with large blast radius. By "practical", I mean solutions that scale to billions of lines of existing running code that deliver value every single day. The constraints we are dealt afford us neither the luxury of pausing the world for complete rewrite from scratch, nor only focusing on "future", yet to be written, code. C++ profiles are a tooling-based evolutionary approach that meets those constraints. They enable the C++ community to tackle similar problems in a single, extensible, and flexible framework.

About the Speaker:

Dr. Gabriel Dos Reis is an Architect for Visual Studio at Microsoft, working in the area of large scale software construction, tools, and technique. His contributions to C++ include scalable generic programming, pioneering compile-time computation, language support for modularity, safety, and security. He is interested in all aspects of software construction with bias towards computational logic, formal methods, and the fun of building useful tools.

What Happens When a Destructor Throws -- Sandor Dargo

By Blog Staff | May 15, 2026 03:41 PM | Tags: None

Even experienced C++ developers sometimes stumble on a deceptively simple question: what actually happens when a destructor throws an exception? This post breaks down the mechanics behind stack unwinding, noexcept, and why throwing from destructors is almost always a bad idea

What Happens When a Destructor Throws

by Sandor Dargo

From the article:

Recently I wrote about the importance of finding joy in our jobs on The Dev Ladder. Mastery and deep understanding are key elements in finding that joy, especially now that generating code is cheap and increasingly done better by AI than by us.

Then a memory surfaced. I frequently ask during interviews — as part of a code review exercise — what happens when a destructor throws. Way too many candidates, even those interviewing for senior positions, cannot answer the question. Most say it’s bad practice, but cannot explain why. Some say the program might terminate. Getting an elaborate answer is rare.

I’m not saying it’s a dealbreaker, but it definitely doesn’t help.

Let’s see what actually happens.

The role of a destructor

A destructor is the key to implementing the RAII idiom. RAII matters because after you acquire a resource, things might go south. A function might need to return early, or it might throw. Making sure resources are released is cumbersome, and the cleanest way to achieve it is to wrap both acquisition and release in an object that handles this automatically.

But what if the release itself is not successful?

Destructors have no return value, so error reporting is limited. Typical options include logging, storing error state, or (discouraged) throwing.

Why did I mark throwing an exception discouraged?

C++: The Documentary trailer

By Blog Staff | May 14, 2026 08:00 AM | Tags: None

Sponsored by HRT and produced by CultRepo, we're pleased to share the official trailer for C++: The Documentary.

The trailer premieres today at 19:00 UTC. Click Notify me on the YouTube Premiere page to get a reminder when it goes live.

The film will have its world premiere on May 28 at a special live event in New York City’s Financial District, followed by a panel discussion that will be recorded for later release. C++: The Documentary will be released worldwide on YouTube on June 4, with the panel recording following a few days later.

CppCon 2025 Crafting the Code You Don’t Write: Sculpting Software in an AI World -- Daisy Hollman

By Blog Staff | May 13, 2026 02:35 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!

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

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.

Evolving a Translation System with Reflection in C++

By Blog Staff | May 12, 2026 03:39 PM | Tags: None

A nice example of C++26 reflection moving from theory into something practical.

Evolving a Translation System with Reflection in C++

By GitHub user: friedkeenan

From the post:

Lately, I’ve been using C++26 reflection to create some crazy and cursed stuff. But even though I quite enjoy that work, it is as well quite far from the norm of what reflection is going to offer us in our everyday code.

Reflection is definitely not just that craziness, and so I want to present reflection in a more grounded environment, and in a way that will probably land as more typical usage as our codebases gradually come into contact with it.

So then, in this blogpost, I will be exploring a spectrum of options for how reflection can upgrade a translation system that I already use in one of my projects. We’ll look at where it’s at now without reflection, identify places in which reflection could plausibly help, and then explore a series of modifications we could make to soothe those problem points.

The purpose of looking at each of these options will not be to declare that one is clearly the best option or the one that makes the most sense, but rather to get a better feel for what could make sense to do, and whether some things are really worth the effort. We’re trying to gauge the benefits that reflection can bring to our code.

And who knows, even if one option is less appealing for this particular situation, maybe in a different situation it could be the perfect fit.

CppCon 2025 Reflection: C++’s Decade-Defining Rocket Engine -- Herb Sutter

By Blog Staff | May 11, 2026 02:32 PM | Tags: None

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

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.

CppCon 2025 Back to Basics: Move Semantics -- Ben Saks

By Blog Staff | May 7, 2026 02:30 PM | Tags: None

Back to Basics: Move Semantics

by Ben Saks

Summary of the talk:

While many C++ programmers are familiar with the broad idea of move semantics, even experienced C++ programmers often struggle with the fine details. For example, many programmers are unclear on exactly when an object is considered implicitly movable and when std::move() is required to make the object movable. This is especially unfortunate because using std::move() when it's unnecessary sometimes degrades performance.

This session starts by explaining how move semantics can substantially improve performance for certain types. It then shows how to implement a type with move semantics, and explores some important design issues in creating these types. After that, it explains how types like std::vector＜T＞ can operate much more efficiently on objects of types that support move semantics.

You'll leave this session with a clearer understanding of:

how to implement move-semantic types,

how to take maximum advantage of move-semantic types, and

how move semantics are related to other language features like return-value optimization.

The ACCU on Sea 2026 Schedule is Now Announced -- ACCU

By Phil Nash | May 7, 2026 11:39 AM | Tags: community

C++ on Sea and the ACCU Conference combine, this, year for one big festival of C++ by the sea!

The 2026 Schedule is Here!

by ACCU

From the article:

Four days, five tracks, and a lineup that spans the full breadth of what ACCU on Sea is about: deep C++ content, broader software craft, and the kind of talks that make you rethink something you thought you understood.