Top 15 C++26 Features
C++26 is the first release since C++11 that changes what the language can do, not just how conveniently you write it. The ISO committee finished technical work on C++26 at its March 2026 meeting in London Croydon. The draft then moves through the ISO approval ballot and final editorial work toward publication.
These are the 15 most important features, ordered by impact. The first three (reflection, contracts, std::execution) are the headline features. Items 4 and 5 are the big safety wins. The rest are the language and library additions you are most likely to use or be asked about.
A note on compiler support: implementations are still catching up, and some items below are only partially available. GCC 16 is reported to support most of the C++26 features, but check the cppreference C++26 compiler support table for the exact toolchain you ship on. The code below follows the final design, but small syntax details may differ from what your compiler accepts today.
The Headline Features
1. Static reflection
Reflection lets a program inspect its own types at compile time (members, enumerators, names, and so on) and generate code from what it finds. It replaces macros, code generators and a lot of template metaprogramming.
Two new operators do the heavy lifting:
^^xis the reflection operator. It turns a type, member or other entity into a compile-time value of typestd::meta::info.[: r :]is the splice. It turns a reflection value back into code.
Enum to string, with no macros and no tables to maintain
#include <meta>
template <typename E>
requires std::is_enum_v<E>
constexpr std::string_view enumToString(E value) {
template for (constexpr auto e :
std::define_static_array(std::meta::enumerators_of(^^E))) {
if (value == [:e:]) {
return std::meta::identifier_of(e);
}
}
return "<unnamed>";
}
enum class Color { Red, Green, Blue };
static_assert(enumToString(Color::Green) == "Green");
Walking the members of any struct
template <typename T>
void dump(const T& obj) {
template for (constexpr auto m : std::define_static_array(
std::meta::nonstatic_data_members_of(^^T,
std::meta::access_context::current()))) {
std::println("{} = {}", std::meta::identifier_of(m), obj.[:m:]);
}
}
Typical uses: serialization (JSON, binary wire formats), enum-to-string, ORM and database mappings, command-line parsers, scripting bindings, and automatic operator== or hashing for aggregates.
Caveats
- This is a first version, and more reflection capability is expected in later standards.
- Reflection runs at compile time, so heavy use can increase build times.
- Access control still applies, and reflection is subject to the access context you provide.
Interview takeaway:
^^reflects,[: :]splices, andstd::meta::infois the value that carries a reflected entity. Together withtemplate for(item 7) they make "iterate over the members of a type" a compile-time loop.
2. Contracts: pre, post, and contract_assert
Contracts add language support for preconditions, postconditions and assertions. They are meant as a first-class replacement for the assert macro and for ad-hoc documentation of "this function requires...".
double safeSqrt(double x)
pre(x >= 0.0)
post(r : r >= 0.0)
{
return std::sqrt(x);
}
int& at(std::vector<int>& v, std::size_t i)
pre(i < v.size())
{
return v[i];
}
void process(int n) {
contract_assert(n > 0); // an assertion statement inside the body
// ...
}
pre(expr)is checked on entry, andpost(r : expr)on return (herernames the result).contract_assert(expr)is an assertion in the body.- Each check can be run with a different evaluation semantic: ignore (check not evaluated), observe (evaluate and report a violation, then continue), enforce (evaluate, report, then terminate) or quick-enforce (terminate immediately). Which one you get is chosen at build time, typically with a compiler flag, and a violation handler is called when a check fails.
Why it matters: the same source can be built with full checking in testing and with checks ignored in release, with no macro tricks, and tools can see the contracts.
Cautions
- Contract predicates should be side-effect free, because a check may be evaluated more than once, or not at all.
- The feature was debated heavily and some committee experts still have technical concerns, but the committee chose to keep it in C++26.
- Contracts on virtual functions are not supported in C++26. Work to support them continues in the next standard.
3. std::execution (senders and receivers)
std::execution is C++'s standard asynchronous execution model. A sender describes a unit of work (lazily, nothing runs yet), a scheduler says where it runs, and a receiver gets the result. Senders compose with algorithms, so you build a pipeline first and start it later.
#include <execution>
namespace ex = std::execution;
auto sched = ex::get_parallel_scheduler();
auto work = ex::schedule(sched)
| ex::then([] { return 21; })
| ex::then([](int x) { return x * 2; });
auto [result] = std::this_thread::sync_wait(std::move(work)).value();
// result == 42
Combining independent work:
auto a = ex::schedule(sched) | ex::then([] { return fetchPrices(); });
auto b = ex::schedule(sched) | ex::then([] { return fetchOrders(); });
auto both = ex::when_all(std::move(a), std::move(b))
| ex::then([](auto prices, auto orders) { return match(prices, orders); });
Why it matters:
- A single, composable model for concurrency and parallelism instead of futures, callbacks and hand-rolled thread pools.
- Structured concurrency: work started by a pipeline is scoped and cancellable (it integrates with
std::stop_token). - Senders are lazy and generally avoid hidden allocation, which suits low-latency designs.
Caution: expect a learning curve. Many teams will want a few helper adapters or a library on top while they get used to it.
Safety Features
4. Erroneous behavior for uninitialized reads
Reading an uninitialized local variable used to be undefined behavior. In C++26 it becomes erroneous behavior: the program has a bug, but the behavior is well-defined, since the variable holds an implementation-defined "erroneous value" and the implementation is allowed (and encouraged) to diagnose it.
int count; // C++26: reading this is erroneous, not UB
std::println("{}", count); // bug, but no longer an optimizer-exploitable UB
This removes a whole class of security vulnerabilities just by recompiling as C++26.
If you really want an uninitialized buffer (for example a large scratch array you are about to overwrite), opt out explicitly:
[[indeterminate]] char buffer[4096]; // performance escape hatch
Interview takeaway: uninitialized read goes from "UB" to "erroneous behavior", and
[[indeterminate]]is the opt-out for performance-critical code.
5. Hardened standard library
C++26 standardizes a hardened implementation of the standard library: precondition violations in library calls (such as vector::operator[] out of range, span indexing, dereferencing an empty optional) are checked and treated as contract violations instead of silently being undefined behavior.
std::vector<int> v(3);
int x = v[10]; // hardened mode: reliably diagnosed and terminated, not memory corruption
Large production deployments have used hardened libraries at scale with a small measured cost, and C++26 makes this a standard feature. It is enabled through the implementation (build mode or flags), not by changing your code.
Related safety changes in the same release: trivial infinite loops are no longer UB, and memory_order::consume is deprecated.
Language Features
6. Pack indexing
You can index directly into a parameter pack (both value packs and type packs), with no recursion or std::tuple tricks.
template <typename... Ts>
auto first(Ts... args) {
return args...[0]; // first argument
}
template <typename... Ts>
using Last = Ts...[sizeof...(Ts) - 1]; // last type in the pack
static_assert(std::is_same_v<Last<int, double, char>, char>);
This replaces std::tuple_element_t, helper structs and recursive templates for the common "give me the Nth one" case.
7. Expansion statements: template for
A for loop that is unrolled at compile time over a pack, a tuple-like object, or a compile-time range. Each iteration can have a different type, which is exactly what reflection needs (as in item 1's examples).
std::tuple t{1, "hello", 3.14};
template for (const auto& element : t) {
std::println("{}", element); // int, const char*, double: each iteration its own type
}
Before this, iterating a heterogeneous tuple meant std::apply with fold expressions or recursive templates.
8. #embed: include binary files at compile time
Embed the contents of a file directly into your program as an array initializer, with no external tools like xxd -i, and fast to compile.
constexpr unsigned char icon[] = {
#embed "icon.png"
};
constexpr char shader[] = {
#embed "shader.glsl"
, '\0'
};
Useful for icons, shaders, certificates, default configuration and lookup tables baked into the binary.
9. More constexpr: exceptions, placement new, containers and smart pointers
C++26 continues to remove the limits on what can run at compile time.
constexprexceptions: exceptions can be thrown and caught during constant evaluation (and a throw that escapes makes the evaluation non-constant).constexprplacementnewand casts fromvoid*.constexprcontainers and adaptors, andconstexpr std::shared_ptrand friends.constexprstructured bindings and more of<cmath>and<complex>.constexprstable sorting, plusconstexpr std::atomicandatomic_ref.
constexpr int parsePositive(std::string_view s) {
int value = 0;
for (char c : s) {
if (c < '0' || c > '9') throw std::invalid_argument("not a digit");
value = value * 10 + (c - '0');
}
return value;
}
constexpr int port = parsePositive("8080"); // evaluated at compile time
Combined with reflection, this makes it practical to do real work (parsing, validation, table building) entirely at compile time.
10. Smaller language improvements worth knowing
Placeholder _: a name that can be declared repeatedly in the same scope, for values you intentionally ignore.
auto [x, _] = getPair(); // ignore the second element
std::lock_guard _(mutexA);
std::lock_guard _(mutexB); // no name clash
= delete("reason"): give a deleted function a message the compiler prints.
void process(int) = delete("use process(long) to avoid silent narrowing");
Structured bindings, extended: a binding can introduce a pack (auto [first, ...rest] = tuple;), be used as an if condition, and carry attributes.
static_assert with a computed message: the message can be any constant expression that provides size() and data(), such as one built with std::format.
Library Features
11. std::inplace_vector<T, N>
A resizable vector with fixed capacity N and inline storage, so it never touches the heap. It sits between std::array (fixed size) and std::vector (heap).
#include <inplace_vector>
std::inplace_vector<int, 8> v;
v.push_back(1); // throws std::bad_alloc if full
v.push_back(2);
if (auto* p = v.try_push_back(3)) { // non-throwing: returns nullptr when full
*p += 10;
}
v.unchecked_push_back(4); // no check: you guarantee there is room
Great for embedded, real-time and latency-sensitive code, and for small collections where a heap allocation would cost more than the work. It is also a constexpr-friendly type.
12. std::hive
A container optimized for frequent insertion and erasure of elements, with these guarantees:
- Pointers and iterators to other elements stay valid when you insert or erase.
- Erased slots are reused, and storage is allocated in blocks, so insertion is O(1) and doesn't shift elements.
- Iteration order is unspecified (it isn't insertion order).
#include <hive>
std::hive<Particle> particles;
auto it = particles.insert(Particle{}); // stable iterator and pointer
particles.erase(it); // slot is reused later
It suits game entities, particle systems and object pools, where you hold long-lived pointers to objects that are created and destroyed constantly. It is based on the established plf::colony.
13. std::simd (data-parallel types)
Portable SIMD in the standard library: types that represent a vector of values processed with one instruction.
#include <simd>
std::simd::vec<float, 8> a(1.0f);
std::simd::vec<float, 8> b(2.0f);
auto c = a * b + a; // 8 lanes at once
float total = std::simd::reduce(c);
It replaces platform-specific intrinsics (_mm256_*, NEON) with a portable, type-safe interface that the compiler maps to the best available instructions. It comes with <bit>-style functions and masks for conditional operations.
Note: the details of the loading and storing API are among the parts most likely to differ between current implementations, so check your library's documentation.
14. std::linalg, std::submdspan, and the numeric additions
std::linalg is a BLAS-style linear algebra interface that works on std::mdspan views.
#include <linalg>
#include <mdspan>
std::mdspan A(a_data, 3, 4), B(b_data, 4, 5), C(c_data, 3, 5);
std::linalg::matrix_product(A, B, C); // C = A * B
It dispatches to an optimized BLAS when the implementation provides one.
std::submdspan takes slices (rows, columns, ranges) of an mdspan, giving you sub-views with no copying.
Saturation arithmetic (std::add_sat, std::sub_sat, std::mul_sat, std::div_sat, std::saturate_cast) clamps on overflow instead of wrapping or invoking UB:
uint8_t a = 250;
uint8_t b = std::add_sat<uint8_t>(a, 10); // 255, not 4
15. Safe memory reclamation: std::hazard_pointer and std::rcu
Two standard tools for the hardest part of lock-free programming: knowing when it is safe to free a node that another thread might still be reading. These answer the "ABA and memory reclamation" problem.
Hazard pointers let a reader publish "I'm using this object, don't free it":
#include <hazard_pointer>
struct Node : std::hazard_pointer_obj_base<Node> {
int value;
Node* next;
};
std::atomic<Node*> head;
int readHead() {
std::hazard_pointer hp = std::make_hazard_pointer();
Node* n = hp.protect(head); // safe to dereference while protected
return n ? n->value : -1;
}
void removeNode(Node* n) {
n->retire(); // freed only when no reader protects it
}
RCU (read-copy-update) (<rcu>) suits read-mostly data: readers are essentially free, and writers publish a new version and wait for old readers to finish before reclaiming.
Together they let you write lock-free containers and read-mostly structures without inventing your own epoch scheme.
Honorable Mentions
| Feature | What it gives you |
|---|---|
std::copyable_function |
A std::function replacement that respects const, noexcept and ref-qualifiers. |
std::optional<T&> |
Optional references. |
std::is_within_lifetime |
Query (in constant evaluation) whether an object is within its lifetime. |
<text_encoding> |
Access to the IANA character set registry. |
<debugging> |
std::breakpoint() and std::is_debugger_present(). |
std::println() with no arguments |
Prints a blank line. |
std::ranges::generate_random |
Fill a range from a random number generator. |
std::ranges::cache_latest_view |
Cache the last computed element of a view, avoiding repeated work in pipelines. |
Hashing for std::chrono types |
std::hash support for time points and durations. |
std::atomic_ref address exposure |
Get the address of the referenced object. |
memory_order::consume deprecated |
Formally discouraged, since compilers already treat it as acquire. |
What Did Not Make It
Worth knowing so you don't expect these:
- Trivial relocatability was adopted into the draft but later removed because of implementation problems, and deferred to a future standard.
- Contracts on virtual functions are deferred (work is already underway for the next standard).
- Profiles (the broader memory-safety framework) and pattern matching are not part of C++26. Further safety work is aimed at C++29.
Summary Table
| # | Feature | One-line benefit |
|---|---|---|
| 1 | Static reflection (^^, [: :]) |
Inspect types at compile time and generate code from them |
| 2 | Contracts (pre, post, contract_assert) |
Language-level checks with build-time control, replacing assert |
| 3 | std::execution |
Composable, lazy, standard async and parallel execution |
| 4 | Erroneous behavior | Uninitialized reads are no longer UB |
| 5 | Hardened standard library | Library precondition violations are diagnosed, not exploitable |
| 6 | Pack indexing | args...[N] and Ts...[N] with no recursion |
| 7 | template for |
Compile-time loops over tuples, packs and reflection data |
| 8 | #embed |
Include binary files at compile time |
| 9 | More constexpr |
Exceptions, placement new, containers and shared_ptr at compile time |
| 10 | _, = delete("why"), binding packs |
Small everyday language improvements |
| 11 | std::inplace_vector |
Fixed-capacity vector with no heap allocation |
| 12 | std::hive |
Stable-pointer container for high-churn objects |
| 13 | std::simd |
Portable data-parallel types |
| 14 | std::linalg, submdspan, saturation |
BLAS-style math on mdspan, sub-views, overflow-safe arithmetic |
| 15 | std::hazard_pointer, std::rcu |
Standard safe memory reclamation for lock-free code |
Final thought: if you only have time to learn three things, learn reflection (with
template for), contracts, andstd::execution. They are the ones that change how large C++ systems are designed. For day-to-day safety, the quiet wins are erroneous behavior and the hardened library, which improve your code just by recompiling as C++26.
Comments
Post a Comment