Draft:C++29

C++29 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++26, planned for release in 2029.

The first meeting took place in June 2026 in Brno, Czech Republic.

Features

Language

• A new offset parameter for the #embed directive
• Support for contracts on virtual functions
• Pack indexing for variadic templates
• Designated initializers for constructing a base struct

import std;

using std::vector;

struct Base {
    int x;
};

struct Derived : public Base {
    int y;
};

vector<Derived> v = {
    Derived {.x = 1, .y = 2},
    Derived {{.x = 1}, .y = 2},
    Derived {.x{1}, .y{2}},
};

• Deallocation functions with a throwing specification (i.e. void operator delete(void* p) noexcept(false); are ill-formed
• Conditional noexcept specifiers in concept compound requirements
• Support for = default; assignments for postfix increment/decrement operators (i.e. T operator++(T&, int) = default;
• Additional restrictions on defaulted assignment operator functions
• consteval-only values:
  • A value is consteval-only if it is either a reflection value or a pointer or pointer-to-member that points to either an immediate object or an immediate function.
  • An object is immediate if its complete object has either a constituent value that is consteval-only, or a constituent reference that refers to either an immediate object or an immediate function.
  • A variable is immediate if the object it declares is an immediate object.
• Additional named universal character escapes
• Coroutine promise return functions (return_void(), return_value()) are no longer mutually exclusive; this allows coroutines to return in different execution paths co_return; and co_return x;.
• Adopt the recommendations of Section 3.1 of Unicode Technical Standard #55, Unicode Source Handling, allowing identifiers to be composed from additional Unicode characters
• Specify captures of a lambda to be declared in the order of appearance
• Allow language linkage for templates; these may not necessarily work due to implementation-specific language linking rules, but the standard now allows it.

extern "C" {
    template <typename T>
    void f(T t);
    
    template <typename T>
    void g(void (*f)(T));
}

// extern "Java" is implementation-dependent
// could, for example, be used to implement Java generics
extern "Java" {
    template <typename T, typename U>
    void foo(T x, U y);
}

• Clarification of floating-point overflow
• Nondeterministic pointer provenance
• Atomic operations and operations on volatile pointers are defined to yield and store prospective pointer values
• Defined load and store operations for invalid pointers

Library

• Adding a lookup() method to map types std::map<K, V>, std::unordered_map<K, V> and std::flat_map<K, V> which returns a std::optional<V&>
• A pointer tagging class std::pointer_tag_pair<Ptr, Tag, N> with constexpr support
• name_hint<T> and stack_size_hint for std::thread and std::jthread, which allows setting a thread stack size and a thread name
• make_hazard_pointer_batch(span<hazard_pointer> batch) and clear_hazard_pointer_batch(span<hazard_pointer> batch) for handling creation/destruction of hazard pointer batches
• Bit permutation functions, SIMD bit permutation, and bit shifting
• copy() and fill() algorithms for std::mdspan
• A std::simd::iota type
• has_error() method for std::expected<T, E>
• at() accessor for std::ranges::view_interface<D>
• std::formatter<> specialization for std::error_code
• Change default floating-point representation in std::format() to be in standard form
• intptr_t and uintptr_t are now required to be implemented
• Signed character types are deprecated from use in iostreams
• Revert string support in std::constant_wrapper<T>

Anticipated/discussed additions

Among some of the discussed features include Herb Sutter's "metaclasses" proposal, which propose adoptable vocabulary for class boilerplate generation; to facilitate this, code injection for reflection would add token sequence injection into source code.

Of particular interest were adding a more robust way of addressing undefined behavior. A proposal which enumerated all cases of undefined behavior specified in the C++ standard further proposed implicit contract assertions against undefined behavior, as well as unconstrained behavior (which takes the old definition of undefined behavior), as well as "profiles", which allow opt-in disabling unsafe behavior.

See also

• C29 (C standard revision)

External links

• Compiler support for C++29 features