: Standard C++

Home »

« Prev Next »

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

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

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.

C++: The Documentary

By Blog Staff | Jun 2, 2026 05:09 PM | Tags: None

Sponsored by HRT and produced by CultRepo, C++: The Documentary is about to be released worldwide on YouTube on Thursday at 20:00 UTC. Click Notify me on the YouTube Premiere page to get a reminder when it goes live.

Last week, the film's world premiere event in New York was followed by a live panel discussion with Matt Godbolt (moderator), Bjarne Stroustrup, Gabriel Dos Reis, Nina Ranns, Eric Lubin, and Herb Sutter. That panel was recorded and will be also released in the next few days on the CppCon YouTube channel.

CppCon 2025 Best Practices for AI Tool Use in C++ -- Jason Turner

By Blog Staff | Jun 2, 2026 02:51 PM | Tags: None

Best Practices for AI Tool Use in C++

by Jason Turner

Summary of the talk:

AI (LLMs) are becoming prolific in C++ tooling. Virtually everything has an AI bot built in or available to it. Common wisdom says that these tools simply regurgitate what they find on the internet. As we all know, the internet is full of terrible examples of outdated memory leaks, undefined behavior, and worse!

How do we effectively and safely use these tools while ensuring good code quality?!

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

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?