std::meta::data_member_spec

consteval std::meta::info
    data_member_spec( std::meta::info type, std::meta::data_member_options options );

struct data_member_options
{
    std::optional</*name-type*/> name;
    std::optional<int> alignment;
    std::optional<int> bit_width;
    bool no_unique_address = false;
    std::vector<std::meta::info> annotations;
};

Eine Datenmemberbeschreibung wird üblicherweise als Sextupel (T, N, A, W, NUA, ANN) dargestellt, wobei:

• T der durch std::meta::dealias(type) dargestellte Typ ist.
• N entweder der durch options.name kodierte Bezeichner oder ein spezieller Wert (mit ⊥ bezeichnet) ist, falls options.name keinen Wert enthält.
• A der durch options.alignment gehaltene Ausrichtungswert oder ein spezieller Wert (mit ⊥ bezeichnet) ist, falls options.alignment keinen Wert enthält.
• W der durch options.bit_width gehaltene Wert oder ein spezieller Wert (mit ⊥ bezeichnet) ist, falls options.bit_width keinen Wert enthält.
• NUA der Wert von options.no_unique_address ist.
• ANN die Sequenz der Werte std::meta::constant_of(r) für jedes r in options.annotations ist.

Zwei Datenmemberbeschreibungen sind gleich, wenn jede ihrer jeweiligen Komponenten dieselben Entitäten, dieselben Bezeichner, gleiche Werte sind oder beide ⊥ sind. Zwei Reflexionen von Datenmemberbeschreibungen vergleichen sich als gleich, wenn die Beschreibungen, die sie darstellen, gleich sind.

Wenn die Kombination von Argumenten ungültig ist, wird std::meta::exception geworfen. Siehe den Abschnitt Ausnahmen unten für Details.

Der nur zur Darstellung verwendete Typ, der durch /*name-type*/ bezeichnet wird, ist ein Klassentyp mit den folgenden Konstruktoren:

template< class T >
    requires std::constructible_from<std::u8string, T>
consteval /*name-type*/( T&& value );

template< class T >
    requires std::constructible_from<std::string, T>
consteval /*name-type*/( T&& value );

Parameter

Rückgabewert

Eine Reflexion, die eine Datenmemberbeschreibung darstellt, konstruiert aus den Argumenten.

Ausnahmen

Wirft std::meta::exception, sofern nicht alle der folgenden Bedingungen erfüllt sind:

• std::meta::dealias(type) stellt einen Objekttyp oder einen Referenztyp dar.
• Wenn options.name einen Wert enthält:

• Wenn der Name aus einer UTF-8-Zeichenkette konstruiert wurde, ist die Zeichenkette die Schreibweise eines gültigen Tokens und das Token ist ein gültiger Bezeichner, wenn es mit UTF-8 interpretiert wird.
• Andernfalls (der Name wurde aus einer gewöhnlichen Zeichenkette konstruiert) ist die Zeichenkette die Schreibweise eines gültigen Tokens und das Token ist ein gültiger Bezeichner, wenn es mit der gewöhnlichen Literalkodierung interpretiert wird.

• Wenn options.name keinen Wert enthält, enthält options.bit_width einen Wert. (In diesem Fall beschreibt das Ergebnis ein unbenanntes Bitfeld.)
• Wenn options.bit_width einen Wert V enthält, dann:

• std::meta::is_integral(type) || std::meta::is_enum_type(type) ist wahr.
• options.alignment enthält einen Wert.
• options.no_unique_address ist falsch.
• V ist nicht negativ.
• Wenn V Null ist, enthält options.name keinen Wert.

• Wenn options.alignment einen Wert enthält, ist er ein gültiger Ausrichtungswert und nicht kleiner als std::meta::alignment_of(type).
• Für jedes Element r in options.annotations ist std::meta::type_of(r) gültig und stellt einen Nicht-Array-Objekttyp dar, und die Auswertung von std::meta::constant_of(r) wirft keine Ausnahme.

Beispiel

#include <format>
#include <meta>
#include <print>
#include <string>

// Defines struct A as if by “struct A { std::string x; };”
struct A;
consteval
{
    std::meta::define_aggregate(^^A,
        {
            std::meta::data_member_spec(^^std::string, {.name = "x"}),
        });
}

// Defines a simple tuple type
template<typename... Ts>
struct Tuple
{
    struct Storage;
    consteval
    {
        std::vector<std::meta::info> member_specs;
        template for (int i{}; auto type : {^^Ts...})
        {
            member_specs.push_back(data_member_spec(type, {.name = std::format("item{}", i)}));
            ++i;
        }

        define_aggregate(^^Storage, member_specs);
    }

    Storage data;

    Tuple(): data{} {}
    Tuple(const Ts& ...values): data{values...} {}
};

int main()
{
    A a;
    a.x = "Hello";

    Tuple<char, char, char, int> t('C', '+', '+', 26);

    std::println("{}, {}{}{}{}!", a.x, t.data.item0, t.data.item1, t.data.item2, t.data.item3);
}

Hello, C++26!

Siehe auch