#constexpr
8 posts tagged #constexpr.
Parsing your config file before the program exists
#embed puts a file into the translation unit and reflection enumerates a struct's fields. Together they turn a configuration file into a compile-time constant, with the keys derived from the struct rather than written twice, and a missing entry becoming a build error rather than a failed startup.
C++26 lets you throw and catch at compile time
Until now a throw inside a constant expression was an immediate compile error, which forced constexpr code to report failure some other way. C++26 allows exceptions during constant evaluation: a throw that gets caught in the same evaluation is fine, and only an uncaught one fails the build. GCC 16.1 runs it today.
std::array became compile-time in pieces, and the algorithms went last
std::array's own members have been constexpr since C++17, but sorting one at compile time only became possible in C++20, when the algorithms caught up. That two-standard gap is why older lookup-table code hand-rolls its sorting. Here is a table built, squared and sorted entirely during compilation.
Validating a string before the program exists
CTRE matches run inside constant expressions, so a regex can check and parse a string literal while the compiler is still working. A malformed version string then stops the build rather than surviving into production, and the parsed result is available as a constant.
A C++26 structured binding that GCC and Clang disagree about
C++26 lets a structured binding declaration be the condition of an if. GCC 16.1 and Clang 22.1 both implement it and both agree on ordinary structs. Put a tuple-protocol type in the condition and evaluate it at compile time, and GCC rejects the program while Clang accepts it. The reproducer is twenty lines and needs no library.
std::constant_wrapper carries a compile-time value as an argument
A template parameter is a compile-time value you cannot pass as an argument. A function argument is a runtime value you cannot use as a template parameter. C++26's std::constant_wrapper is an empty object that carries a compile-time value, so it crosses that line: arithmetic on it stays constant, and the result still works as an array extent. GCC 16.1 ships it.
{fmt} can do the whole format at compile time
FMT_COMPILE parses the format string during compilation and emits straight-line formatting code, so a format call can be a constant expression with no parsing at runtime. The 12.2 release adds a type-safe C API, a proper C++20 module target, and turns the full Dragonbox cache on by default for faster float formatting.
Is std::vector consteval or constexpr? A reader's question, answered
A colleague asked: 'Is std::vector consteval and not constexpr?' Short answer: no, but the intuition is right. Long answer: the constexpr/consteval/constinit trio, the transient-allocation rule, and why std::define_static_array exists.