CppCon 2025 C++ Standard Library:Design, Optimisations, Testing while Implementing Libc++ -- Hui Xie

By Blog Staff | Jun 24, 2026 03:07 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!

Implement the C++ Standard Library: Design, Optimisations, Testing while Implementing Libc++

by Hui Xie

Summary of the talk:

This presentation covers various practical examples in the designs, optimisations and testing in libc++, a standard library implementation.

In space optimisation section, it presents various examples of using compact type, reusing tail padding bytes, reusing unused bits in existing bytes, in various standard types: std::stop_token , std::expected , std::optional , std::variant , std::ranges library and std::move_only_function .

In time optimisations section, it presents examples of how we optimise std::atomic＜T＞::wait 's waiting strategy, how we optimised algorithms for segmented iterators, and also how we keep in mind optimisations by leaving the door open for future optimisations. At the same time, compilation time is also important so it also contains examples how unnecessary template instantiations can be avoided.

Finally, this talk covers the unit tests of libc++, including the high test coverage of standard spec, the technique we share tests between runtime and constexpr, negative testing and so on.

A first look at the program of Meeting C++ 2026

By Meeting C++ | Jun 24, 2026 12:45 AM | Tags: meetingcpp intermediate community c++26 c++23 c++20 c++17 basics advanced

With the voting on the talks ending on Sunday, Meeting C++ has now published its program, take a look at the talk listing.

A first release of the program for Meeting C++ 2026

by Jens Weller

From the article:

With the voting ending on Sunday, there is now a first overview on the program of Meeting C++ 2026 available!

As early bird tickets are selling out, its time to get your tickets!

You can take a look at the accepted talks, this is the main track:

    Robert Leahy - What Are We Synchronizing?
    Ivan Čukić - Contracts and hardened libraries - a bright future for C++ safety?
    Henrik Vallgren - Compile time is the future of Automotive Software
    Dawid Zalewski - C++26 static reflection: All you need is annotations
    Andreas Fertig - When Your Compiler Runs Your Code
    Matt Godbolt - Compiler Explorer in 2026: Sandboxes, Storage & Strangers' Code
    Antoine Morrier - Thread-safety compile-time guaranteed in C++
    Daniela Engert - Same C++, but quicker to the finish line
    Giuseppe D'Angelo - Not-so-trivial relocation in C++
    Guy Davidson - Profiles are coming
    Klaus Iglberger - Design Patterns - The Most Common Misconceptions (3 of N)

 

Silent foe or quiet ally: Brief guide to alignment in C++. Part 3 -- Elizaveta Zhegalova

By Blog Staff | Jun 23, 2026 03:30 PM | Tags: None

We continue our deep dive into memory mechanics. If you are just joining us, I recommend reviewing the foundations first. The first part covered the basics and the magic of simple data alignment, while the second part focused on how ordinary inheritance affects memory layout.

Silent foe or quiet ally: Brief guide to alignment in C++. Part 3

by Elizaveta Zhegalova

From the article:

So far, we've treated an object as a static, rigidly determined data structure. Every field address was known at compile time, and inheritance simply layered parent and child attributes. Alas, object-oriented programming is impossible without dynamic polymorphism, which is implemented in C++ via the RTTI mechanism and virtual functions.

 

What is virtuality?

Let me start from an off-topic question. How does the compiler know which piece of machine code to execute at a specific line in your program? Answering this question will help us understand what virtuality really means.

 

Imagine we write object.print(). For the processor, it's not an abstract action but a command to jump to a certain address in memory with some function instructions. But where do we take that address from?

 

During compilation, each code line becomes one or more machine instructions, each receives a unique sequential address in memory. The same applies to functions. A compiler translates them into machine code and assigns the next available address. Stitching a function call in code to its actual memory address is called binding.

 

Depending on when the call address is bound to the function address, there are two scenarios.

 

1. Static/early binding.

 

By default, static (early) binding is used. A compiler rigidly "hardwires" a specific function address at the call place in code during compilation. This decision relies solely on the pointer or reference type, not the actual object in memory. For instance, when a compiler sees a Base* pointer, it chooses the method address from the base class. It's fast and requires no additional evaluations. So, the jump goes to an already known address. It's also efficient, but it makes the program inflexible at runtime.

CppCon's first-ever keynote panel: Stroustrup, van Rossum, and Torgersen, together at CppCon 2026

By Blog Staff | Jun 21, 2026 11:53 PM | Tags: None

Every year, CppCon promises you a strong keynote lineup, and every year we deliver. But this year we get to do something rarer: announce a once-in-a-lifetime keynote panel of interest not just to C++ developers, but to our whole industry.

On Tuesday morning, September 15, the CppCon main stage will host a Language Designers Panel featuring three of the people who decide what the languages you use every day actually become:

• Bjarne Stroustrup, the creator of C++ (who will have just given his own Monday conference kickoff keynote the day before)
• Guido van Rossum, the creator of Python
• Mads Torgersen, the lead designer of C# and Anders Hejlsberg’s successor in that role
• Moderator: Emma Tracey, founder of CultRepo and producer of its new feature film C++: The Documentary and Python: The Documentary

Three living and growing languages used by millions of developers, three design philosophies, one stage, one conversation.

Bjarne and Guido have never been on stage together anywhere and may never be again; add Mads to the stage, and we expect this special moment to be watched, cited, and argued over for years. You can be in the room when it happens.

Why should a C++ audience care about a panel that is two-thirds “other languages”? The answer is that these languages are two of C++’s closest neighbors and are used together all the time.

• Python is, by the numbers, C++’s truest sister language. In the Standard C++ Foundation’s annual C++ developer survey, when we ask which other languages C++ programmers use, Python always comes first, consistently around 70 percent — ahead even of C, which you might expect to win and is consistently around 45 percent. If you write C++, the odds are very good that you also write Python; the two have grown up side by side, gluing and being glued, and the relationship only deepens each year.
• C# and C++ are the two dominant languages on Windows, and the two are constantly used together — native performance underneath, managed productivity on top — so the person designing C# is designing part of the world that a great many C++ developers ship into.

So this is a conversation among the architects of the three languages most of us actually live in. What do they envy in one another’s designs? Where do they think they got it right, and where would they start over? How do you steer a language with millions of users and decades of existing code without breaking the people who depend on you? And the lessons to learn from their shared experience reach well beyond language design — the same instincts that shape a language will sharpen how you design your own libraries and products. Bring your own questions, too — you will not get a chance like this often.

CppCon 2026 Early Bird registration discount is available until this Friday. After that, registration will continue to be available at the regular rate. CppCon 2026 runs September 12–18 at the Gaylord Rockies in Aurora, Colorado, and conference sessions are onsite-only this year — they will be recorded and posted to our YouTube channel afterward, but only the room gets the live experience and the chance to ask questions of all our speakers. If you have been waiting to register, this is the week to stop waiting.

Register now for CppCon 2026, and we’ll see you in Aurora.

CppCon 2025 Lazy and Fast: Ranges Meet Parallelism in C++ -- Daniel Anderson

By Blog Staff | Jun 18, 2026 03:05 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!

Lazy and Fast: Ranges Meet Parallelism in C++

by Daniel Anderson

Summary of the talk:

Recent advances in the C++ standard have introduced powerful features like ranges and parallel algorithms—both aimed at writing faster, cleaner, and more expressive code. Ranges offer lazy, on-demand computation that improves I/O efficiency and composability. Parallel algorithms, on the other hand, harness multitasking to speed up compute-heavy workloads.

At first glance, these two features seem like a perfect match: lazy evaluation to minimize I/O overhead, and parallelism to maximize throughput. However, in practice, they don’t play well together. Many range operations—especially those over non-random-access sources—are inherently sequential due to their lazy pull-based, one-element-at-a-time nature.

In this talk, we’ll explore a modern library technique that unlocks the synergy between lazy ranges and parallelism. You’ll see how to build lazy, composable range pipelines that are parallel-friendly—capable of efficiently expressing operations like filter, scan, and flatten without sacrificing performance or elegance. We’ll walk through real-world examples where these techniques deliver strong parallel speedups with minimal programming overhead.

Whether you’re a library designer, performance enthusiast, or just curious about making your range-based code scale, this talk will equip you with practical tools to bridge the gap between composability and parallelism in modern C++.

C++26: string and string_view improvements -- Sandor Dargo

By Blog Staff | Jun 17, 2026 03:27 PM | Tags: None

Let’s continue our exploration of C++26 improvements. Today we focus on string_view. Some types got new constructors accepting string_views, and concatenation of strings and string_views just got easier.

C++26: string and string_view improvements

by Sandor Dargo

From the article:

But let’s start with a brief reminder of what a string_view is.

Reminder: the role of string_view

std::string_view was introduced in C++17 and its purpose is to provide read-only access to a string-like object. It can often replace const string& parameters and offers a significant performance gain. It’s generally advisable to use it whenever you’d pass an immutable string-like input that you cannot move from source to target.

We covered the topic earlier in more depth here.

P2495R3: Interfacing stringstreams with string_view

A stringstream is a good old tool for dealing with operations on string-based streams. While C++23 introduced spanstreams, due to fundamental semantic differences, stringstreams are not dead and it’s important to maintain them.

Being a good old tool also means they predate string_view. Given the available set of constructors, if you want to initialize a stringstream from a string_view, you first have to manually convert it into a string.

P2495R3 fixes this by adding new constructors accepting string_views.

It’s worth noting that this is a purely additive library change — it doesn’t break existing code.

At the moment of publication, this change is already available on Clang 19.

CppCon 2025 How to Tame Packs, std::tuple, & the Wily std::integer_sequence -- Andrei Alexandrescu

By Blog Staff | Jun 16, 2026 03:02 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!

How to Tame Packs, std::tuple, and the Wily std::integer_sequence

by Andrei Alexandrescu

Summary of the talk:

Template parameter packs and std::tuple unlock powerful metaprogramming capabilities in C++, but they also introduce a parallel sublanguage—one with unfamiliar rules, verbose idioms, and surprising limitations. Packs were originally designed for perfect forwarding, not compile-time iteration, which makes even simple tasks like filtering or transformation awkward. std::integer_sequence helps, but mostly by shifting the burden rather than removing it.

Existing library utilities offer some relief, but often feel inconsistent and difficult to compose. This talk explores why working with packs and tuples feels harder than it should, and demonstrates a small set of clean, reusable abstractions that make these tasks simpler, safer, and more expressive. Attendees will leave with practical tools—(and, with luck, a renewed hope) that structured metaprogramming in C++ doesn't have to be so hard.

New features in GCC 16: Improved error messages and SARIF output -- David Malcolm

By Blog Staff | Jun 15, 2026 03:21 PM | Tags: None

GCC 16 is about to be released, so I'm sharing some of the new features I worked on this year. Some changes are visible to users, while others improve the system more subtly.

New features in GCC 16: Improved error messages and SARIF output

by David Malcolm

From the article:

A well-known challenge for C++ developers is the readability of template-related error messages. C++ compilers tend to either provide too little information or spew screenfuls of text at you. Either way, the errors can be difficult to decipher.

GCC error messages have a hierarchical structure to them. In GCC 15, I added an experimental option that shows this structure as a collection of nested bullet points.

In GCC 16, this behavior is now the default. You can return to the previous behavior using -fno-diagnostics-show-nesting or -fdiagnostics-plain-output. I fixed several bugs and made use of the hierarchical structure in more places. For example, it is easy to get declarations and definitions out of sync when manually adding const to a parameter:

class foo

{

  public:

    void test(int i, int j, void *ptr, int k);

};

    

// Wrong "const"-ness of param 3.

void foo::test(int i, int j, const void *ptr, int k)

{

}

Trip report: June 2026 ISO C++ standards meeting (Brno, Czechia) -- Herb Sutter

By Blog Staff | Jun 15, 2026 01:08 AM | Tags: None

Hot off the press from the latest ISO C++ meeting:

Trip report: June 2026 ISO C++ standards meeting (Brno, Czechia)

by Herb Sutter

From the article:

tl;dr… A few highlights

• Adopted this week in draft C++29: Complete catalog of all undefined behavior (UB) in C++. Contract pre/post support for virtual functions. Defaulting (=default) for postfix increment/decrement. Designated initializers for base classes. Python-style .lookup(key) for associative containers. And more…
• Other significant progress: Progress on various features targeting C++29, including systematically addressing UB and adding safety profiles for C++.
• Next six months: Telecon line-by-line review of a proposal to systematically address all undefined behavior in C++. Progress adding C++ memory safety subsetting profiles. Both aim for inclusion in C++29.

C++26: Structured Bindings can introduce a Pack -- Sandor Dargo

By Blog Staff | Jun 12, 2026 12:17 PM | Tags: None

In previous posts, we talked about how C++26 improves structured bindings by allowing them to be used in conditionals’ init statements. We also briefly touched on other improvements coming in C++26, such as individual binding annotations and constexpr bindings. There is, however, one important enhancement to structured bindings that we haven’t covered yet on this blog: Structured Bindings can introduce a Pack

C++26: Structured Bindings can introduce a Pack

by Sandor Dargo

From the article:

Before diving into the feature itself, let’s briefly clarify what a pack is. A reasonably accurate (and not overly simplistic) definition is the following:

A parameter pack is a language construct that represents an arbitrary number of types or values, allowing code to accept and operate on an arbitrary number of arguments in a type-safe way.

I deliberately avoided using the word template in this definition. Historically, packs only existed in templated contexts, but that limitation is slowly being relaxed. Earlier versions of the proposal behind this feature even aimed to support structured binding packs in non-templated contexts. That part was eventually dropped due to implementation complexity and related objections — but the direction is still telling.