C++26 Reflection on GCC 16.1:
What Actually Compiles Today

Amadeus Ferro's print_fields(), plus a second job for the same feature, built and run on the shipping compiler. The six things that stop the snippet compiling on the first try, where the rest of the toolchain still lags, and one consequence for teams under a coding standard.

Daniel Liezrowice, ESL Engineering Software Lab · eswlab.com/contact-us

The post shows one function. We ran it, extended it, and broke it on purpose.

"Just shipped" means GCC. Only GCC.

Everything in this deck was compiled and executed on GCC 16.1 through Compiler Explorer (compiler id g161). Links on the code slides.

pre_cpp26/fault_telemetry.cpp: three jobs, three workarounds

#define FAULT_LIST(X)   \                                    // job 1: X-macro so the enum and its names stay in sync
    X(None) X(OverTemp) X(UnderVoltage) X(SensorTimeout)

enum class Fault : std::uint8_t {
#define AS_ENUM(name) name,
    FAULT_LIST(AS_ENUM)
#undef AS_ENUM
};

constexpr const char* to_string(Fault f) {
    switch (f) {
#define AS_CASE(name) case Fault::name: return #name;         // stringize with #
        FAULT_LIST(AS_CASE)
#undef AS_CASE
    }
    return "<unknown>";
}

struct TelemetryFrame {
    std::uint32_t timestamp_ms;  float temp_c;  std::uint16_t voltage_mv;
    std::uint8_t  fault;         std::uint8_t crc8;
};
static_assert(offsetof(TelemetryFrame, timestamp_ms) == 0);      // job 2: wire layout, one line per field,
static_assert(offsetof(TelemetryFrame, temp_c)       == 4);      //        edited by hand when the struct changes
static_assert(offsetof(TelemetryFrame, voltage_mv)   == 8);
static_assert(offsetof(TelemetryFrame, fault)        == 10);
static_assert(offsetof(TelemetryFrame, crc8)         == 11);

void print_frame(const TelemetryFrame& f) {              // job 3: the struct, listed again by hand
    std::printf("timestamp_ms = %u\n", f.timestamp_ms);
    std::printf("temp_c       = %g\n", static_cast<double>(f.temp_c));
    std::printf("voltage_mv   = %u\n", f.voltage_mv);
    std::printf("fault        = %s\n", to_string(static_cast<Fault>(f.fault)));
    std::printf("crc8         = %u\n", f.crc8);
    // Add a field to TelemetryFrame and forget this function: still compiles.
}

cpp26/fault_telemetry.cpp: same three jobs, one definition of everything

#include <meta>
enum class Fault : std::uint8_t { None, OverTemp, UnderVoltage, SensorTimeout };

template <typename E> requires std::is_enum_v<E>
constexpr std::string_view enum_name(E value) {                   // job 1: names come from the compiler
    template for (constexpr auto e : std::define_static_array(std::meta::enumerators_of(^^E))) {
        if (value == [:e:]) return std::meta::identifier_of(e);
    }
    return "<unknown>";
}

struct TelemetryFrame {
    std::uint32_t timestamp_ms;  float temp_c;  std::uint16_t voltage_mv;
    Fault fault;                 std::uint8_t crc8;
};

template <typename T>
consteval bool is_padding_free() {                                 // job 2: one loop replaces 5 x offsetof
    std::size_t expected = 0;
    for (auto m : std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::current())) {
        if (static_cast<std::size_t>(std::meta::offset_of(m).bytes) != expected) return false;
        expected += std::meta::size_of(m);
    }
    return expected == sizeof(T);
}
static_assert(is_padding_free<TelemetryFrame>(), "TelemetryFrame has padding: wire format broken");

template <typename T>
void print_fields(const T& obj) {                                  // job 3: the function from the post
    template for (constexpr auto m : std::define_static_array(
                      std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::current()))) {
        if constexpr (std::is_enum_v<typename[:std::meta::type_of(m):]>)
            std::println("{:<12} = {}", std::meta::identifier_of(m), enum_name(obj.[:m:]));
        else
            std::println("{:<12} = {}", std::meta::identifier_of(m), obj.[:m:]);
    }
}

Same output. Then two edits the old code could not catch.

What it took to make it compile

None of these are in the post's snippet, which is written against the paper rather than the compiler. All six were reproduced through the Compiler Explorer API on 29 September 2026; the script and raw output are in the reproduction folder linked on the last slide.

GCC parses this. Check whether your other tools do.

For teams under MISRA C++:2023, the boilerplate reflection removes is the boilerplate the standard forbids

Recommendations by where you stand

Modern C++ migration, static analysis and safety evidence for embedded C and C++

We run this kind of before/after measurement on client codebases: which modernisation steps pay off, which ones only move the problem, and where the toolchain is not ready yet.

Contact Ushttps://eswlab.com/contact-us/