C++ Features

Aburi currently targets C++20 and C++17, although C++17 mode currently accepts certain C++20 constructs (in other words, --std=C++17 may allow c++20 code to pass through)

What works

Classes and the object model

  • class, struct, and union with enforced public / private / protected access control

  • methods, static member functions, static data members, and inline static data members

  • const, volatile, and reference-qualified (&, &&) member functions

  • constructors: default, copy, move, delegating, converting, and explicit (including C++20 conditional explicit(…​))

  • destructors, including virtual destructors

  • implicitly generated and = default / = delete special members, with the standard generation and deletion rules

  • in-class member initializers and member-initializer lists in the correct order

  • bit-fields, anonymous structs and unions, and nested types

  • compiler-evaluated type traits (trivial, standard-layout, POD, and many more)

Inheritance, polymorphism, and RTTI

  • single, multiple, and virtual (diamond) inheritance

  • virtual methods with vtable-based dispatch; pure-virtual and abstract classes

  • override and final checking, and covariant return types

  • vtables, VTT, secondary and construction tables, and this-adjusting thunks

  • pointers to data members and member functions (.* and →*)

  • typeid, and dynamic_cast for down-casts, cross-casts, and void*

  • static_cast, const_cast, and reinterpret_cast

Templates

  • function, class, variable, and alias templates

  • full and partial specialization, and template template parameters

  • a wide range of non-type template parameters, including C++20 structural class-type parameters

  • variadic templates, parameter packs, sizeof…​, and C++17 fold expressions

  • two-phase lookup, dependent-name resolution, and SFINAE

  • class template argument deduction with explicit deduction guides

  • C++20 concepts: concept definitions, requires clauses and expressions, constraint-gated instantiation, and abbreviated function templates

Expressions and modern features

  • lambdas, including captures, init-captures, generic lambdas, mutable, constexpr/consteval lambdas, and C++20 templated lambdas

  • captureless lambda to function-pointer conversion

  • auto, decltype, decltype(auto), and trailing return types

  • range-based for (including the C++20 init-statement form)

  • if with an initializer, and if constexpr

  • operator overloading for arithmetic, comparison, subscript, call, arrow, conversion operators, and C++20 spaceship/operator<⇒ (including = default)

  • overload resolution with standard and user-defined conversion sequences, argument-dependent lookup, and default arguments

  • lvalue/rvalue reference binding, reference collapsing, and forwarding references

Compile-time evaluation

  • constexpr variables and functions, and C++20 consteval

  • a constant-evaluation engine that interprets function bodies, loops, recursion, and class objects

  • static_assert (with and without a message)

Exceptions

  • try, catch, catch(…​), typed handlers, throw, and rethrow

  • noexcept specifiers and the noexcept operator, with terminate-on-escape

  • Itanium-style stack unwinding with destructor cleanups

  • fully correct for scalar and pointer exception types

Namespaces, enums, and more

  • namespaces, nested and inline namespaces, and namespace aliases

  • using-directives and using-declarations

  • unscoped and scoped enums (enum class / enum struct), fixed underlying types, and opaque declarations

  • extern "C" / extern "C++", inline variables, and thread-local storage

  • friend functions, classes, and templates

  • [[noreturn]], alignas / alignof, and standard attribute syntax

Standard library

Aburi does not ship its own C++ standard library. In C++ mode it uses the host toolchain’s headers (libc or libstdc). Today this is enough to compile and run programs that use smart pointers (<memory>) and <atomic>; <utility>, <type_traits>, <tuple>, and <variant> parse as well.

The mainstream container, string, and I/O headers — <vector>, <string>, <iostream>, <algorithm>, <map>, and similar — do not compile yet. Broad STL support is an active work item.

Not yet supported

Notable gaps in the current C++ surface include:

  • the broader standard library (containers, strings, iostreams, algorithms)

  • structured bindings and switch with an initializer

  • constinit, char8_t, raw and user-defined string literals, and digit separators

  • coroutines (co_await / co_yield / co_return) and modules (module / import / export)

  • inheriting constructors (using Base::Base;) and using enum

  • implicit class template argument deduction guides

  • the Microsoft C++ ABI (Itanium only)

  • C++26 features (reflection)