: Standard C++

Home »

« Prev Next »

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

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.

The voting on the talks for Meeting C++ 2026 has begun!

By Meeting C++ | Jun 12, 2026 03:40 AM | Tags: meetingcpp events community

The yearly voting for the conference program of Meeting C++ has begun! You can vote on 118 talks until Sunday 21st.

The voting on the talks for Meeting C++ 2026 has begun!

by Jens Weller

From the article:

Once again its time for the C++ community to take a look at the submitted talks for Meeting C++ 2026! Thanks to all folks who have submitted a talk to this years conference! Your contribution will create another great conference in Berlin and online! And special thanks to all folks who have bought tickets already for the conference, you'll have a bit more weight in the voting to shape this years program! Same is true if you spoke at Meeting C++ in the past or attended last years conference.

CppCon 2025 Cache-Friendly C++ -- Jonathan Müller

By Blog Staff | Jun 10, 2026 03:00 PM | Tags: None

Cache-Friendly C++

by Jonathan Müller

Summary of the talk:

When you need a container, pick std::vector＜T＞ by default. This is because std::vector＜T＞ is cache-friendly.

What does that mean, though?

This talk will answer that from the ground-up. We will cover the need for CPU caches and their consequences, how the CPU tricks to make them as seamless as possible, and when and why those tricks sometimes fail. This means that you need to be careful when structuring your program to avoid slowdowns. We will thus explore cache-friendly data structures, data-oriented design, and how to avoid common pitfalls.

CppCon 2025 Cutting Down on Unnecessary Objects -- Prithvi Okade & Kathleen Baker

By Blog Staff | Jun 8, 2026 02:57 PM | Tags: None

C++ Performance Tips: Cutting Down on Unnecessary Objects

by Prithvi Okade & Kathleen Baker

Summary of the talk:

In C++, unnecessary temporary object creation can lead to costly runtime operations, increased code execution, and higher memory usage. Luckily this can be improved! This talk investigates common scenarios that result in the creation of temporary objects and how to detect these scenarios, demonstrated through code examples. We will then explore strategies to reduce the creation of such objects with techniques like explicitly moving objects, passing objects by reference, leveraging lightweight classes like std::string_view and std::span , using functions like reserve and emplace , and more. Join us to learn how to optimize your code’s performance and adopt better practices.

CppCon 2025 Building Vector Math Libraries with Concepts & Customization Points -- Greg von Winckel

By Blog Staff | Jun 4, 2026 02:54 PM | Tags: None

Zero-Overhead Abstractions: Building Vector Math Libraries with Concepts and Customization Points

by Greg von Winckel

Summary of the talk:

This talk demonstrates how C++20's Concepts and Customization Point Objects (CPOs) provide a flexible, opt-in approach to vector algorithms—a compelling alternative to inheritance-based interfaces. Starting with foundational concepts and CPOs, we'll design mathematical abstractions that enable precise compile-time requirements with helpful diagnostics and clear error messages.

Through a practical vector framework implementation, we'll explore patterns essential for high-performance scientific computing applications, including interpolation and iterative methods for linear and nonlinear systems. Attendees will learn how CPOs with intelligent fallbacks parallel the familiar base-class/override structure of OOP, providing similar code reuse and customization opportunities without inheritance entanglements, while enabling seamless interoperability between diverse container types in the spirit of the STL.

As a C++ developer and architect at Sandia National Laboratories for the past decade, I've witnessed the burden of OOP overuse: complicated class hierarchies, parallelism compatibility issues, and testing challenges. The Real Vector Framework I've developed demonstrates how static polymorphism and free functions provide cleaner, more flexible alternatives to inheritance—bringing modern C++ practices to scientific computing while preserving the performance critical to our applications.

tl;dr… A few highlights