This article has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these messages)
|
| C++ language revisions |
|---|
C++26 is the informal name for the open standard revision of the International Organization for Standardization (ISO) and International Electrotechnical Commission (IEC) 14882 standard for the C++ programming language that follows C++23, officially shipped by WG21 on 28 March 2026. The final draft of C++26 was N5050.
Papers proposed and adopted into the standard by the C++ Standards Committee and minutes of the standardization meeting held at Sofia, Bulgaria and online in June 2025 are publicly available. The draft wording is feature complete, and is being sent out for international comment ballot. After resolving some ballot comments at the November 2025 standardization meeting in Kona, Hawaii, the C++ Standards Committee finished expected resolving ballot comments, technically finalized the draft, and send the draft out for final approval ballot at the following standardization meeting in London, United Kingdom from 23 to 28 of March 2026.
Experimental and standard compilers implementing some of the upcoming features can be tried on short code snippets through the Compiler Explorer. Some of the compiler variants are distinguished only by the short identifiers of papers proposing the new features they implement, such as "P3372" for constexpr containers and adaptors.
No compiler fully supports C++26 yet, or defaults to it. As of 30 April 2026, GCC supports most of the C++26 features beginning with GCC 16.1.
As of 2026, C++26 is the next revision of the C++ programming language standard. ISO/IEC JTC 1/SC 22/WG21 is responsible for the standardization process. N5046 was the May 2026 working draft (replacing N5032); the Draft International Standard was not completed for ISO ballot at that time.
The compiler implementations started supporting C++26 experimentally even before the standard was finalised. GCC has implemented some C++26 features with the flag -std=c++26, but is still experimental as the ISO C++26 standard was finalizing its standardization.
Changes that have been accepted into C++26 include:
^^ (colloquially called the "cat-ears operator") which creates a mirror primitive std::meta::info (rather than the Reflection TS keyword reflexpr), which can be spliced back into source code using the [: :] splice specifiers.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.)static_assert messages, which support constexpr messages rather than just unevaluated strings[[indeterminate]] attribute, which indicates that a variable or function parameter has an indeterminate value if not initializedstd::memory_order::consume and std::kill_dependency(), due to complicating the memory model[further explanation needed] and low compiler adoption[[carries_dependency]] attribute, due to the deprecation of std::memory_order::consumeconstexpr structured bindings and references to constexpr variablesconstexpr placement newconstexpr cast from void*constexpr containers and adaptors constexpr virtual inheritanceconstexpr exceptions, allowing exception throwing in constant-evaluationfriend Friends...;)void f(int a...); is incompatible with C, detrimental to C++,[further explanation needed] and easily replaceable with void f(int a, ...);.int _ = player.getScore(); variables using _ as the identifier are implicitly given the [[maybe_unused]] attribute. The _ identifier may be reused and re-declared in the same scope, and may be used multiple times in structured bindings (such as auto [_, username, _] = getUserData();).#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@, $, and ` to the basic character set. While currently unused, this would allow those characters to be given potential use in the future.= delete("Deletion reason here");)template for compile-time loops (a.k.a. expansion statements) to iterate over type/parameter packs, tuple-like objects and meta-objects.main, to the global module. This allows the main() function to have extern "C++" linkage.<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<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.std::copyable_function, general-purpose polymorphic function wrapper which may be copy-constructed and copy-assignedstd::is_within_lifetime, determines if a pointer points to an object that is within its lifetimestd::submdspan(), returns a view of a subset of an existing std::mdspanstd::optional<T&>, an optional storing a referencestd::formatter<> for std::filesystem::path (std::formatter<std::filesystem::path>)std::string_viewstd::bitset with std::string_viewstd::views::concat, a view for concatenation of other viewsstd::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 generatorstd::chrono value classesstd::complexconstexpr for <cmath> and <complex>std::quecto, std::ronto, std::ronna, and std::quettastd::saturating_add, std::saturating_sub, std::saturating_mul, std::saturating_div and std::saturating_castSeveral 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); this has been such a point of contention that the October 2026 final publication was disapproved, apparently over the inclusion of contracts for C++26.
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.
{{cite web}}: CS1 maint: multiple names: authors list (link){{cite web}}: CS1 maint: multiple names: authors list (link){{cite web}}: CS1 maint: multiple names: authors list (link){{cite web}}: CS1 maint: multiple names: authors list (link){{cite web}}: CS1 maint: multiple names: authors list (link)