Blog : Standard C++

Home » Blog

Blog

CppCon 2025 Implementing Your Own C++ Atomics -- Ben Saks

By Blog Staff | Apr 14, 2026 09:23 AM | 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!

Implementing Your Own C++ Atomics

by Ben Saks

Summary of the talk:

Atomic objects are extremely useful for concurrent programming. Unfortunately, some embedded toolchains like AVR-GCC omit portions of the C++ Standard Library, including headers like ＜atomic＞ .This makes it much harder to program concurrent software on these platforms, since many tutorials and open-source libraries assume Standard Library support. For example, these talks from past CppCons present lock-free data structures and algorithms that rely strongly on lock-free instantiations of std::atomic＜T＞:

Single Producer Single Consumer Lock-free FIFO From the Ground Up – Charles Frasch – CppCon 2023
Introduction to Wait-free Algorithms in C++ Programming – Daniel Anderson – CppCon 2024
User API & C++ Implementation of a Multi Producer, Multi Consumer, Lock Free, Atomic Queue – Erez Strauss – CppCon 2024

This session will show you how to implement your own atomic types in the absence of library support. These atomic types can greatly expand the number of tutorials and open-source libraries available for you to use. A clear understanding of how atomic types are implemented will also help you use objects of those types more effectively on platforms that do provide native support.

Power of C++26 Reflection: Strong (opaque) type definitions -- r/cpp

By Blog Staff | Apr 9, 2026 02:35 PM | Tags: None

Inspired by a similar previous thread showcasing cool uses for C++26 reflection.

Power of C++26 Reflection: Strong (opaque) type definitions

From the article:

With reflection, you can easily create "opaque" type definitions, i.e "strong types". It works by having an inner value stored, and wrapping over all public member functions.

Note: I am using queue_injection { ... } with the EDG experimental reflection, which afaik wasn't actually integrated into the C++26 standard, but without it you would simply need two build stages for codegen. This is also just a proof of concept, some features aren't fully developed (e.g aggregate initialization)
struct Item { /* ... */ }; // name, price as methods

struct FoodItem;
struct BookItem;
struct MovieItem;

consteval { 
    make_strong_typedef(^^FoodItem, ^^Item); 
    make_strong_typedef(^^BookItem, ^^Item); 
    make_strong_typedef(^^MovieItem, ^^Item); 
}

// Fully distinct types
void display(FoodItem &i) {
    std::cout << "Food: " << i.name() << ", " << i.price() << std::endl;
}
void display(BookItem &i) {
    std::cout << "Book: " << i.name() << ", " << i.price() << std::endl;
}

int main() {
    FoodItem fi("apple", 10); // works if Item constructor isn't marked explicit
    FoodItem fi_conversion(Item{"chocolate", 5}); // otherwise
    BookItem bi("the art of war", 20);
    MovieItem mi("interstellar", 25);

    display(fi);
    display(bi);
    // display(Item{"hello", 1}); // incorrect, missing display(Item&) function
    // display(mi); // incorrect, missing display(MovieItem&) function
}

CppCon 2025 Back to Basics: Custom Allocators Explained - From Basics to Advanced -- Kevin Carpenter

By Blog Staff | Apr 7, 2026 10:16 AM | Tags: None

Back to Basics: Custom Allocators Explained - From Basics to Advanced

by Kevin Carpenter

Summary of the talk:

Effective memory management is crucial for building efficient and reliable C++ applications. Custom memory allocators provide a powerful tool for optimizing memory usage, reducing fragmentation, and improving performance. This talk will explore the intricacies of memory allocation in C++, from the basics of dynamic memory management to the implementation of custom allocators. Attendees will gain insights into the standard allocator model, techniques for designing custom allocators, and practical examples of their use in real-world applications.

Join us to unlock the full potential of memory management in your C++ projects.

CppCon 2025 Cache Me Maybe: The Performance Secret Every C++ Developer Needs -- Michelle D'Souza

By Blog Staff | Apr 3, 2026 10:14 AM | Tags: None

Cache Me Maybe: The Performance Secret Every C++ Developer Needs

by Michelle D'Souza

Summary of the talk:

Calling all code detectives! Grab your trench coats and magnifying glasses ... it's time to crack the case of sluggish C++ performance. In this thrilling investigation, we'll uncover the hidden world of your computer's built-in cache and how to harness it to turbocharge your code.

We'll comb through the fundamentals of caches like seasoned sleuths, uncover clues on optimizing access patterns, and interrogate suspects like false sharing and cache unfriendly data structures. We will also examine benchmark evidence based on real-world production code, exposing how each technique delivers the goods.

By the end of this mission, you'll be armed with a detective's toolkit of cache savvy strategies, ready to solve cross-platform performance mysteries and bring blazing fast code to justice. Cache you at this session, maybe!

std::vector — Four Mechanisms Behind Every push_back() -- Gracjan Olbinski

By Gracjan Olbinski | Apr 2, 2026 04:47 PM | Tags: None

A walkthrough of four mechanisms working behind every push_back() call — exponential growth and amortized O(1), the growth factor's effect on memory reuse, cache performance from contiguity, and the silent noexcept trap in move semantics during reallocation.

std::vector — Four Mechanisms Behind Every push_back()

by Gracjan Olbinski

From the article:

"You call push_back() a thousand times. The vector reallocates about ten. Behind that simple interface, four mechanisms are working together — each one invisible during normal use, each one shaping your performance in ways that push_back() will never tell you about."

CppCon 25 Matrix Multiplication Deep Dive || Cache Blocking, SIMD & Parallelization -- Aliaksei Sala

By Blog Staff | Mar 31, 2026 10:10 AM | Tags: None

Matrix Multiplication Deep Dive || Cache Blocking, SIMD & Parallelization

by Aliaksei Sala

Summary of the talk:

Matrix multiplication is a fundamental operation in scientific computing, game development, AI, and numerous high-performance applications. While its mathematical definition is simple, achieving optimal performance in C++ is far from trivial.

In this talk, we will explore different optimization techniques for matrix multiplication, from naive implementations to highly tuned versions leveraging modern hardware features. We will cover key performance-enhancing strategies such as loop unrolling, cache blocking, SIMD vectorization, parallelization using threads and more. Through benchmarking and profiling, we will measure the real impact of these optimizations.

By the end of this session, attendees will gain insights into two critical questions:

How hard is it to implement an optimized matrix multiplication in C++? How effective is C++ for achieving peak performance in this task?

This talk is suitable for developers interested in performance optimization, computational efficiency, and modern C++ techniques for numerical computing.

The hidden compile-time cost of C++26 reflection -- Vittorio Romeo

By Vittorio Romeo | Mar 30, 2026 06:18 PM | Tags: None

How much does C++26 Reflection actually cost your build?

In this article, we'll perform some early compilation time benchmarks of one of the most awaited C++26 features.

The hidden compile-time cost of C++26 reflection

by Vittorio Romeo

From the article:

Fast compilation times are extremely valuable to keep iteration times low, productivity and motivation high, and to quickly see the impact of your changes.

I would love to see a world where C++26 reflection is as close as possible to a lightweight language feature [...]

So, I decided to take some early measurements.

Stop Choosing: Get C++ Performance in Python Algos with C++26 -- Richard Hickling

By Blog Staff | Mar 27, 2026 12:10 PM | Tags: None

In algorithmic trading, the Python-vs-C++ debate is usually framed as flexibility versus speed — rapid strategy development on one side, ultra-low-latency execution on the other. But with C++26 reflection, that trade-off starts to disappear, making it possible to generate Python bindings automatically while keeping the core logic running at native C++ performance.

Stop Choosing: Get C++ Performance in Python Algos with C++26

by Richard Hickling

From the article:

The “religious war” between Python and C++ in algorithmic trading usually boils down to a single trade-off: Python is faster for getting ideas to market, while C++ is faster for getting orders into the book.

But why choose? With the advent of C++26 Reflection, you can now have the flexibility of a Python-based strategy without the performance penalty of slow loops.

Bring in C++ Rapidly: How Reflection Works

The biggest hurdle in hybrid trading systems has always been the “bridge.” Traditionally, if you wrote a complex pricer in C++, you had to manually write “boilerplate” code to tell Python how to talk to it. If you added a new function, you had to update the bridge. It was tedious and error-prone.

Reflection changes the game by allowing the code to “look in the mirror”. Instead of you manually describing your C++ functions to Python, the compiler does it for you. It programmatically inspects your classes and generates the bindings automatically.

CppCon 2025 Practical Reflection With C++26 -- Barry Revzin

By Blog Staff | Mar 26, 2026 10:07 AM | Tags: None

Practical Reflection With C++26

by Barry Revzin

Summary of the talk:

With the adoption of Reflection for C++26, the landscape of what is possible has shifted. This talk will focus on implementing Struct-of-Arrays for an arbitrary aggregate, but will also take some detours to cover some techniques that will prove useful for solving a wide range of problems.

A Brief History of Bjarne Stroustrup, the Creator of C++ -- CultRepo

By Blog Staff | Mar 25, 2026 12:06 PM | Tags: None

In this portrait, we meet Bjarne Stroustrup where we talk about his childhood, his accidental entry into computer science (what is "datologi" anyway?), and the ideas that shaped one of the most influential programming languages ever made -- among many, many other things... like how pronouncing his last name involves a potato.

A Brief History of Bjarne Stroustrup, the Creator of C++

by CultRepo

Watch now:

<iframe width="560" height="315" src="https://www.youtube.com/embed/uDtvEsv730Y?si=QD_WmemwpsAfNsVI" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>