: Standard C++

Home »

« Prev Next »

CppCon 2025 Back to Basics: Master C++ Friendship -- Mateusz Pusz

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

Back to Basics: Master C++ Friendship

by Mateusz Pusz

Summary of the talk:

C++ offers a rich set of access specifiers to control the visibility of class members. However, the friend keyword introduces a unique and often misunderstood concept. This talk explores the nuances of friendship, examining its role in code design, testing, and compilation performance optimization.

We'll delve into the intricacies of friendship, exploring its benefits and potential pitfalls. We'll examine how to leverage friendship effectively, discuss best practices, and uncover hidden gems and common misconceptions. We will see how friendship affects name lookup and compile-time error messages. We will discuss best practices for using it effectively and learn how to avoid or resolve compilation problems that may occur when C++ templates are involved.

By the end of this session, you'll have a solid grasp of friendship and be able to use it to write more elegant, efficient, and maintainable C++ code.

C++26: Structured Bindings in Conditions -- Sandor Dargo

By Blog Staff | May 26, 2026 03:56 PM | Tags: None

Structured bindings in conditions may look like a small syntax sugar, but they let us write much more expressive conditional logic. By allowing decomposition and condition checking to live side by side, C++26 reduces boilerplate, improves locality, and better supports modern result types that bundle status and data together. This is a pragmatic, well-integrated evolution of a feature that has already proven its value since C++17.

C++26: Structured Bindings in Conditions

by Sandor Dargo

From the article:

Structured bindings were introduced in C++17 as an alternative way of declaring variables. They allow you to decompose an object into a set of named variables, where the collection of those bindings conceptually represents the original object as a whole.
// https://godbolt.org/z/97GaMajMP

#include <cassert> #include <string> 
struct MyStruct {
    int num;
    std::string text;

    bool operator==(const MyStruct&) const noexcept = default;
};

MyStruct foo() {
    return {42, "let's go"};
}

int main() {
    const auto& [n, t] = foo();
    MyStruct ms{n, t};
    assert(ms == foo());
    return 0;
}

CppCon 2025 Could C++ Developers Handle an ABI Break Today? -- Luis Caro Campos

By Blog Staff | May 25, 2026 02:46 PM | Tags: None

Could C++ Developers Handle an ABI Break Today?

by Luis Caro Campos

Summary of the talk:

The C++ Evolution Working Group recently reaffirmed its commitment to ABI stability, prioritizing link compatibility with C and older C++. The C++11 libstdc++ ABI updates introduced in gcc 5.1, although not strictly “breaking”, are still in the collective memory of C++ developers and this experience shows us how sensitive the ecosystem is to ABI updates.

This talk challenges the assumption that a future ABI break would be equally problematic, as the landscape has evolved significantly in the last decade.

On the one hand, the C++ standard has evolved in such a way that even if the standards committee and compiler vendors go through great lengths to avoid breaking the ABI of standard library implementations, library authors are not as cautious - so in practice, the ability to link objects built with different C++ standard levels does not hold true for a lot of cases.

On the other hand, tooling has evolved significantly in this time period. For example, both Conan and vcpkg are able to “tag” binaries on some arbitrary ABI version. We can see similar examples in other tools or ecosystems that need to work around ABI complexities.

This talk is not intended to argue about the merits or risks of future ABI changes - but to ask ourselves the question: are we overestimating the pain of a future ABI break?

Let the Compiler Check Your Units -- Wu Yongwei

By Blog Staff | May 22, 2026 03:53 PM | Tags: None

Mixing your units can be disastrous. Wu Yongwei takes a quick look at C++ unit libraries that can help keep everything in order.

Let the Compiler Check Your Units

by Wu Yongwei

From the article:

I recently came across a C++ standard proposal P3045 [P3045R7], which aims to add physical units to C++. Curious, I looked into the existing unit libraries and went down quite a rabbit hole.

Type safety and user-defined literals

Before exploring these libraries, I was already somewhat familiar with the idea of ‘type safety’. I was also aware that user-defined literals (UDLs) [CppReference-1] allow creating literals of specific types with ease. Typical uses in the standard library include string/string_view literals and the chrono library [CppReference-2], which make code both convenient and safe.

Figure 1 shows some simple examples.
auto msg = "Hello "s + user_name;
auto t1 = chrono::steady_clock::now();
this_thread::sleep_for(500ms);
auto t2 = chrono::steady_clock::now();
auto duration = t2 - t1;
auto what = t1 + t2;      // Can't compile
cout << duration / 1.0ms; // To double, in ms

CppCon 2025 How To Build Robust C++ Inter-Process Queues -- Jody Hagins

By Blog Staff | May 21, 2026 02:42 PM | Tags: None

How To Build Robust C++ Inter-Process Queues

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.

Exploring ref qualifiers in C++

By Meeting C++ | May 21, 2026 08:11 AM | Tags: performance meetingcpp intermediate c++11 advanced

Recently I've been wondering about ref qualifiers in C++.

Exploring ref qualifiers in C++

by Jens Weller

From the article:

Ref qualifiers are today an old C++11 feature, and recently I wanted to know more about them. Especially their potential use cases.

Thats a particular point with this feature, I've seen examples - but often without a compelling use case. This feature is a great way to achieve very specific things in C++...

The road to 'import boost': a library developer's journey into C++20 modules -- Rubén Pérez Hidalgo

By Blog Staff | May 20, 2026 03:50 PM | Tags: None

C++20 modules have been in the standard for more than 5 years already. They promise to deliver a big change to how we write C++, but their adoption hasn't been as widespread as one would have expected. This talk is a deep dive into the practical aspects of C++20 modules, exploring the reality of the ecosystem as it is today.

The road to 'import boost': a library developer's journey into C++20 modules

Rubén Pérez Hidalgo

Watch now:

Slides of the 13th of May 2026 BeCPP Meeting

By Marc Gregoire | May 20, 2026 10:00 AM | Tags: community becpp

On May 13th 2026, I organized the next Belgian C++ Users Group event. There were 2 sessions:

“Designing Data for Performance and Maintainability” by Laurent Carlier
“The fastest Java Virtual Machine is the C++26 compiler” by Koen Samyn

You can find the schedule (with abstracts), slides, and pictures on the BeCPP blog:

Schedule: https://becpp.org/blog/2026/04/06/next-becpp-ug-meeting-planned-for-may-13th-2026/
Slides: https://becpp.org/blog/2026/05/20/slides-of-the-13th-of-may-2026-becpp-meeting/
Pictures: https://becpp.org/blog/2026/05/20/pictures-of-the-13th-of-may-2026-becpp-meeting/

Let's make a programming language

By Andrey Karpov | May 20, 2026 03:03 AM | Tags: None

We’re kicking off a webinar series on how to build your own programming language in C++.

Let's make a programming language. Parser

by Yuri Minaev

Watch now:

We’re continuing our webinar series on building your own programming language. In the previous sessions, we implemented a lexer for our language. In this upcoming webinar (May 21, 2026, 01:00 PM UTC+1), we’ll move on to the next step — the parser. In our experience, any parser starts with parsing expressions, so that’s exactly where we’ll begin. We’ll explain what a parser is, walk through the recursive descent approach, and then demonstrate how to build your own expression parser from scratch.

Past webinars: Intro, Grammars, Lexer.

CppCon 2025 Concept-based Generic Programming -- Bjarne Stroustrup

By Blog Staff | May 19, 2026 02:38 PM | Tags: None

Concept-based Generic Programming

by Bjarne Stroustrup

Summary of the talk:

This talk presents programming techniques to illustrate the facilities and principles of C++ generic programming using concepts. Concepts are C++’s way to express constraints on generic code. As an initial example, it provides a simple type system that eliminate narrowing conversions and provides range checking.

Concepts are used throughout to provide user-defined extensions to the type system. The aim is to show their utility and the fundamental ideas behind them, rather than to provide a detailed or complete explanation of C++’s language support for generic programming or the extensive support provided by the standard library.

The final sections briefly present design rationales and origins for key parts of the concept design, including use patterns, the relationship to Object-Oriented Programming, value arguments, syntax, concept type-matching, and definition checking. They also mention static reflection, a C++26 improvements in the support of general programming.