: Standard C++

Home »

« Prev Next »

Upcoming C++ User Group meetings in June 2026

By Meeting C++ | May 31, 2026 05:37 AM | Tags: meetingcpp community

Meeting C++ returns to posting the monthly overview posts on C++ User Group meetings!

Upcoming C++ User Group meetings in June 2026

by Jens Weller

From the article:

In early April of 2023 I've posted the last list of upcoming C++ User Group meetings, as a change in Meetup made this feature not accessible.

I've noticed last week that this has changed now, and so will return to posting this monthly list again. I'm working on also integrating these into the website it self in June.
Its nice to see so many C++ User Groups to still be active!

Annotations for C++26 Hashing -- Krystian Piękoś

By Blog Staff | May 29, 2026 04:32 PM | Tags: None

Static reflection already makes generic hashing in C++26 far more expressive, but annotations push it into genuinely ergonomic territory. By letting types explicitly opt-in to hashing and allowing individual members or base classes to be cleanly excluded, we get a solution that is both powerful and readable.

Annotations for C++26 Hashing

by Krystian Piękoś

From the article:

In my recent post, I demonstrated how to use static reflection from C++26 to implement generic hash computation for custom types. Let's review the final implementation. The core of the solution is the calculate_hash() function, which iterates over sub-objects (including both base classes sub-objects and class/struct non-static data members) to compute a combined hash.

template <typename T>
concept Hashable = requires {
{ std::hash<T>{}(std::declval<T>()) } -> std::convertible_to<size_t>;
};

template <typename T>
requires std::is_class_v<T>
size_t calculate_hash(const T& obj, size_t seed = 0)
{
constexpr auto ctx = std::meta::access_context::unchecked();

static constexpr auto r_subobjects = std::define_static_array(std::meta::subobjects_of(^^T, ctx));

template for (constexpr auto r_sub : r_subobjects)
{
    using Subobject_t = typename[:std::meta::type_of(r_sub):];
    static_assert(Hashable<Subobject_t>, "Subobject must be hashable");
    Utility::hash_combine(seed, obj.[:r_sub:])
}

return seed;
}

How ref qualifiers led to deducing this

By Meeting C++ | May 29, 2026 07:22 AM | Tags: meetingcpp community c++23 c++11

A follow up on last weeks post on ref qualifiers:

How ref qualifiers led to deducing this

by Jens Weller

From the article:

Last week I shared an overview on ref qualifiers with you, this is a follow up on this post. Featuring deducing this, a C++23 feature that should be available in your compiler if its been released in 2025 or later.

Lets start with two more things you may want to know about ref qualifiers. First, const is also supported for the rvalue version: m::f()const && exists, though this is mostly not very useful. Thats why you rarely see it covered, as const rvalues are unusual to unvalid. But thats where m::f()const&&=delete comes in, it allows you to turn these object states in to compilation errors.
As ref qualifiers are also often used...

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: