2025-08 Mailing Available

By Administrator | Aug 15, 2025 05:33 PM | Tags: None

The 2025-08 mailing of new standards papers is now available.

A virtual destructor in C++, when? -- Andreas Fertig

By Blog Staff | Aug 15, 2025 08:04 AM | Tags: None

When should a destructor be virtual in C++? In this post, we’ll explore a real-world example from smart pointer implementation to illustrate when virtual destructors are necessary — and when they’re not.

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

By Andrey Karpov | Aug 15, 2025 01:42 AM | Tags: sast pvs-studio parser misra

PVS-Studio 7.38 has been released. This version brings the new core for the C and C++ analyzer, the user annotation mechanism in the Java analyzer, enhanced taint analysis, and that's not all! See more details in this note.

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.

CppCon 2025 Missing Step: Making Data Oriented Design One Million Times Faster -- Andrew Drakeford

By Blog Staff | Aug 14, 2025 09:31 AM | Tags: None

Registration is now open for CppCon 2025! The conference starts on September 13 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2025!

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 -- Barry Revzin

By Blog Staff | Aug 13, 2025 08:59 AM | Tags: None

C++26 marks a transformative milestone with the adoption of full compile-time reflection, enabling powerful new metaprogramming capabilities. In this post, we’ll explore how reflection lets you turn a JSON file directly into a fully-typed C++ object — all at compile time.

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>;

CppCon 2025 What's New for VS Code: Perf., Debugging, & GitHub Copilot Agents -- Alexandra Kemper

By Blog Staff | Aug 12, 2025 09:19 AM | Tags: None

Registration is now open for CppCon 2025! The conference starts on September 13 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today 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.

CppCon 2025 Type Traits without Compiler Instrinsics: Promise of Static Reflection -- Andrei Zissu

By Blog Staff | Aug 10, 2025 09:16 AM | Tags: None

Registration is now open for CppCon 2025! The conference starts on September 13 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2025!

Type Traits without Compiler Instrinsics - The Promise of Static Reflection

Monday, September 15 14:00 - 15:00 MDT

by Andrei Zissu

Summary of the talk:

Type traits are a powerful feature of C++ that allows programmers to query and manipulate the properties of types at compile time. They are widely used in generic programming and metaprogramming to enable static polymorphism, type-based dispatching, and compile-time optimization. However, not all type traits can be implemented using the C++ language alone. Some type traits, such as std::is_class, require special support from the compiler in the form of compiler intrinsics or built-ins. These intrinsics are non-portable functions or variables that are recognized and handled by the compiler directly, rather than being defined in a library.

In this talk, we will have a quick overview of the current state of type traits and of static reflection in C++. We will then see how these two worlds can join forces to give us a superior portable product, which no longer requires the use of compiler intrinsics. We will conclude by discussing a possible future where compiler and library are not necessarily mutually dependent, affording any C++ project greater freedom of choice.

Andrei Zissu is a veteran cross-industry C++ developer, notably having worked on low-level reverse engineering systems employing API hooking, DLL injection and other advanced techniques. He has been a member of the WG21 C++ Standards Committee since early 2022, and as such is actively involved in the contracts study group (SG21) and is also keeping a keen eye on reflection work in SG7. He is currently employed as Windows Tech Lead at Morphisec, a revolutionary Israeli cybersecurity company.

Discover C++26’s Compile-Time Reflection -- Daniel Lemire

By Blog Staff | Aug 9, 2025 09:53 AM | Tags: None

C++26 is bringing a long-awaited feature to the language: compile-time reflection, enabling programs to introspect and manipulate their own structure during compilation. This powerful capability opens the door to eliminating boilerplate, improving performance, and writing more expressive, reusable code with ease.

Discover C++26’s Compile-Time Reflection

by Daniel Lemire

From the article:

Herb Sutter just announced that the verdict is in: C++26, the next version of C++, will include compile-time reflection.

Reflection in programming languages means that you have access the code’s own structure. For example, you can take a class, and enumerate its methods. For example, you could receive a class, check whether it contains a method that returns a string, call this method and get the string. Most programming languages have some form of reflection. For example, the good old Java does have complete reflection support.

However, C++ is getting compile-time reflection. It is an important development.

I announced a few months ago that thanks to joint work with Francisco Geiman Thiesen, the performance-oriented JSON library simdjson would support compile-time reflection as soon as mainstream compilers support it.

CppCon 2025 Building Robust Inter-Process Queues in C++ -- Jody Hagins

By Blog Staff | Aug 8, 2025 08:13 AM | Tags: None

Registration is now open for CppCon 2025! The conference starts on September 13 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2025!

Building Robust Inter-Process Queues in C++

Monday, September 15 14:00 - 15:00 MDT

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.

Jody Hagins has been using C++ for the better part of four decades. He remains amazed at how much he does not know after all those years. He has spent most of that time designing and building systems in C++, for use in the high frequency trading space.

Explore the Doom C Codebase in VS Code | Learn to Navigate C and C++ Code on Linux -- Greg Law

By philsquared | Aug 8, 2025 01:18 AM | Tags: None

How do you quickly explore an unfamiliar C or C++ codebase? We'll use Doom as an example to demonstrate how to navigate an unfamiliar codebase.

Explore the Doom C Codebase in VS Code | Learn to Navigate Complex C and C++ Code on Linux

by Greg Law

From the description:

Using the classic Doom C program on Linux as our real-world example, we trace the exact moment a zombie is killed and backtrack through the codebase to understand how it happened [..] using Undo’s Time Travel Debugging technology.