Static Reflection

Static reflection (P2996) вводит новую сущность языка — std::meta::info, непрозрачное значение, представляющее что угодно в программе: тип, переменную, функцию, поле класса, перечислитель, шаблон. Оператор ^^expr (reflection operator) превращает сущность языка в значение std::meta::info, которое можно передавать, хранить в constexpr-переменных и обрабатывать обычным compile-time кодом. Оператор [: r :] (splice) делает обратное — превращает значение std::meta::info обратно в код: тип, выражение или имя.Static reflection (P2996) introduces a new language entity — std::meta::info, an opaque value representing anything in the program: a type, a variable, a function, a class member, an enumerator, a template. The ^^expr operator (the reflection operator) turns a language entity into a std::meta::info value, which can be passed around, stored in constexpr variables, and processed by ordinary compile-time code. The [: r :] operator (splice) does the reverse — it turns a std::meta::info value back into code: a type, an expression, or a name.

// сериализация полей — вручную перечислить каждое поле,// serializing fields — manually list every field,
// либо городить макрос-генератор (BOOST_FUSION_ADAPT_STRUCT и т.п.)// or set up a macro-based generator (BOOST_FUSION_ADAPT_STRUCT etc.)
struct Point { int x, y; };

std::string to_json(const Point& p) {
    return std::format(R"({{"x":{},"y":{}}})", p.x, p.y);  // имена полей вбиты руками// field names hardcoded by hand
}

template<typename T>
std::string to_json(const T& obj) {
    std::string out = "{";
    constexpr auto members = std::meta::nonstatic_data_members_of(^^T);
    // цикл по members развёртывается на этапе компиляции// the loop over members unrolls at compile time
    [:expand(members):] >> [&]<auto M>() {
        out += std::format(R"("{}":{},)", std::meta::identifier_of(M), obj.[:M:]);
    };
    out += "}"; return out;
}

Рефлексия закрывает нишу, которую десятилетиями латали внешними инструментами и хаками:Reflection fills a gap that had been patched for decades with external tools and hacks:

Ядро API — пространство имён std::meta с функциями, принимающими и возвращающими std::meta::info: members_of(^^T) (все члены), nonstatic_data_members_of(^^T) (только поля-данные), identifier_of(r) (имя как строка), type_of(r), template_of(r). Все эти функции — обычные consteval-функции: вызываются исключительно на этапе компиляции, а их результат — тоже compile-time значение.The core of the API is the std::meta namespace with functions that take and return std::meta::info: members_of(^^T) (all members), nonstatic_data_members_of(^^T) (data members only), identifier_of(r) (the name as a string), type_of(r), template_of(r). All of these are ordinary consteval functions: called exclusively at compile time, with a compile-time result.

struct Point { int x; int y; std::string label; };

constexpr auto refl = ^^Point;                       // reflection самого типа Point// a reflection of the Point type itself
constexpr auto members = std::meta::nonstatic_data_members_of(refl);
static_assert(members.size() == 3);

// splice: превратить reflection обратно в код — здесь в имя типа// splice: turn a reflection back into code — here, into a type name
[:refl:] p{1, 2, "origin"};   // [:refl:] эквивалентно написанию "Point" вручную// [:refl:] is equivalent to writing "Point" by hand

// доступ к полю по reflection через obj.[:member:]// accessing a field by reflection via obj.[:member:]
constexpr auto x_member = members[0];
int value = p.[:x_member:];   // эквивалентно p.x, но имя поля выбрано динамически на этапе компиляции// equivalent to p.x, but the field name was chosen dynamically at compile time

Циклы по спискам reflection-значений выполняются функцией expand() в паре с шаблонной лямбдой — конструкция [:expand(range):] >> template_lambda вызывает лямбду по одному разу на каждый элемент, полностью развёртывая цикл на этапе компиляции (аналог for constexpr, которого в языке нет напрямую).Loops over lists of reflection values are performed via the expand() function paired with a template lambda — the [:expand(range):] >> template_lambda construct invokes the lambda once per element, fully unrolling the loop at compile time (the closest thing to a for constexpr, which the language doesn't have directly).

// перечислить имена и типы всех полей структуры во время компиляции// enumerate the names and types of all fields of a struct at compile time
template<typename T>
consteval void print_layout() {
    [:std::meta::expand(std::meta::nonstatic_data_members_of(^^T)):]
        >> [] <auto M>() {
            std::cout << std::meta::identifier_of(M) << ": "
                      << std::meta::display_string_of(std::meta::type_of(M)) << "\n";
        };
}

• WG21 P2996 — Reflection for C++26
• cppreference — Reflection