C++26

Changes that have been accepted into C++26 include:

Language

• Reflection, which runs at compile-time (unlike languages like Java and C#, which run at runtime). (An experimental fork of Clang by Dan Katz, as well as GCC 16, implement these features. These compilers as well as another implementation from EDG can all be tried through the Compiler Explorer.) This uses a new operator ^^ (colloquially called the "cat-ears operator") for invoking reflection, rather than the Reflection TS keyword reflexpr.
• Annotations, which attach reflective metadata to an object (and are processed later than compiler attributes).
• Contracts adding keyword contract_assert, and additionally identifiers with special meaning, pre and post. (An experimental fork of Clang by Eric W Fiselier and a few GCC variants supporting contracts are available through the Compiler Explorer.)
• User-generated static_assert messages, which support constexpr messages rather than just unevaluated strings
• Introduction of erroneous behaviour for reading uninitialized variables
• [[indeterminate]] attribute, which indicates that a variable or function parameter has an indeterminate value if not initialized
• Deprecate std::memory_order::consume and std::kill_dependency(), due to complicating the memory model and low compiler adoption
• Remove [[carries_dependency]] attribute, due to the deprecation of std::memory_order::consume
• Deleting a pointer to an incomplete type should be ill-formed
• Removing deprecated array comparisons
• Various constexpr improvements:
  • constexpr structured bindings and references to constexpr variables
  • constexpr placement new
  • constexpr cast from void*
  • constexpr containers and adaptors
  • constexpr virtual inheritance
  • constexpr exceptions, allowing exception throwing in constant-evaluation
• Variadic friends
• Oxford variadic comma, i.e. "Deprecate ellipsis parameters without a preceding comma." For example, the syntax void f(int a...); is incompatible with C, detrimental to C++, and easily replaceable with void f(int a, ...);.
• Placeholder variables with no name
• Ordering of constraints involving fold expressions
• Pack indexing
• Structured bindings can introduce a pack
• Attributes for structured bindings
• Structured binding declaration as a condition
• Adds #embed directive (first introduced in C23) for binary resource inclusion and __has_embed allowing the availability of a resource to be checked by preprocessor directives
• Unevaluated strings
• Adding @, $, and ` to the basic character set. While currently unused, this would allow those characters to be given potential use in the future.
• Disabling special member functions with a specified reason (= delete("Deletion reason here");)
• Forbidding returning reference to a temporary variable in a function
• template for compile-time loops (a.k.a. expansion statements) to iterate over type/parameter packs, tuple-like objects and meta-objects.
• Allow attaching the entry point, main, to the global module. This allows the main() function to have extern "C++" linkage.

Library

• New standard library headers and namespaces:
  • <contracts>: Contracts support, and namespace std::contracts
  • <debugging>: Debugging support and language features to aid debugger programs
  • <hazard_pointer>: Hazard pointers for threading
  • <hive>: Hive data structure support which reuses erased elements' memory (similar to an object pool). It is based on plf::colony.
  • <inplace_vector>: In-place vector data structure support, which is a resizable, fixed capacity, inplace contiguous array
  • <linalg>: A free function linear algebra interface based on the BLAS, and namespace std::linalg
  • <meta>: Compile-time reflection support, and namespace std::meta
  • <rcu>: Support for safe reclamation read-copy-update mechanism
  • <simd>: Data-parallel access (Single instruction, multiple data or SIMD) support, and namespace std::simd
  • <text_encoding>: Support for accessing the IANA Character Sets registry
• Parallel scheduler (in <execution>) providing a standard asynchronous execution context that guarantees forward progress, with the "execution control library" for asynchronous operations and coroutines in namespace std::execution, including a "sender" abstraction and a designated std::execution::task<T, Env> class. It was proposed based on Meta's libunifex framework, and later Nvidia's stdexec framework.
• "Hardened" standard library, which includes bounds checking and turns instances of undefined behavior into contract violations
• std::copyable_function, general-purpose polymorphic function wrapper which may be copy-constructed and copy-assigned
• std::is_within_lifetime, determines if a pointer points to an object that is within its lifetime
• std::submdspan(), returns a view of a subset of an existing std::mdspan
• Native handles in file streams
• Support for std::optional<T&>, an optional storing a reference
• Specialization of std::formatter<> for std::filesystem::path (std::formatter<std::filesystem::path>)
• Interfacing string streams with std::string_view
• Interfacing std::bitset with std::string_view
• std::views::concat, a view for concatenation of other views
• Concatenation of strings and string views
• Printing blank lines with std::println() (already implemented in C++23 by most compiler vendors)
• std::ranges::generate_random, fills a range with random numbers from a uniform random bit generator
• Hashing support for std::chrono value classes
• Added tuple protocol to std::complex
• More constexpr for <cmath> and <complex>
• Adding the new 2022 SI prefixes on ratios: std::quecto, std::ronto, std::ronna, and std::quetta
• Saturation arithmetic: std::saturating_add, std::saturating_sub, std::saturating_mul, std::saturating_div and std::saturating_cast

Several people issued trip reports from the Sofia C++ Standards Committee meeting at which the draft became feature complete, and from the International C++ Conference, C++ On Sea, immediately afterward.

All highlighted the introduction of compile-time reflection in particular as a major change. In particular, Herb Sutter, chair of the ISO C++ Standards Committee and Hana Dusíková, assistant chair of the "Language Evolution" working group of the C++ Standards Committee, described the potential impacts for C++ reflection as a "whole new language." Sutter further described C++26 as the most 'compelling' release since C++11.

The contracts feature was criticised by some in the C++ committee, for varying reasons (such as questioning its safety, complexity, or implementation details).

The trivial relocatability feature, which proposed new specifiers trivially_relocatable_if_eligible and replaceable_if_eligible, was removed from C++26 due to implementation bugs and deferred to a later standard.