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;
};

Une description de membre de données est généralement représentée comme un sextuplet (T, N, A, W, NUA, ANN), où :

• T est le type représenté par std::meta::dealias(type).
• N est soit l'identifiant encodé par options.name, soit une valeur spéciale (notée ⊥) si options.name ne contient pas de valeur.
• A est la valeur d'alignement détenue par options.alignment, ou une valeur spéciale (notée ⊥) si options.alignment ne contient pas de valeur.
• W est la valeur détenue par options.bit_width, ou une valeur spéciale (notée ⊥) si options.bit_width ne contient pas de valeur.
• NUA est la valeur de options.no_unique_address.
• ANN est la séquence de valeurs std::meta::constant_of(r) pour chaque r dans options.annotations.

Deux descriptions de membre de données sont égales si chacun de leurs composants respectifs sont les mêmes entités, sont les mêmes identifiants, ont des valeurs égales, ou sont tous deux ⊥. Deux réflexions de descriptions de membre de données se comparent égales si les descriptions qu'elles représentent sont égales.

Si la combinaison d'arguments est invalide, std::meta::exception est levé. Voir la section Exceptions ci-dessous pour les détails.

Le type d'exposition seulement désigné par /*name-type*/ est un type de classe avec les constructeurs suivants :

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 );

Paramètres

Valeur de retour

Une réflexion qui représente une description de membre de données, construite à partir des arguments.

Exceptions

Lève std::meta::exception à moins que toutes les conditions suivantes soient remplies :

• std::meta::dealias(type) représente un type objet ou un type référence.
• Si options.name contient une valeur :

• Si le nom a été construit à partir d'une chaîne UTF-8, la chaîne est l'orthographe d'un token valide, et le token est un identifiant valide, lorsqu'il est interprété avec UTF-8.
• Sinon (le nom a été construit à partir d'une chaîne ordinaire), la chaîne est l'orthographe d'un token valide, et le token est un identifiant valide, lorsqu'il est interprété avec l'encodage littéral ordinaire.

• Si options.name ne contient pas de valeur, options.bit_width contient une valeur. (Dans ce cas, le résultat décrit un champ de bits sans nom.)
• Si options.bit_width contient une valeur V, alors :

• std::meta::is_integral(type) || std::meta::is_enum_type(type) est vrai.
• options.alignment contient une valeur.
• options.no_unique_address est faux.
• V n'est pas négatif.
• Si V est zéro, options.name ne contient pas de valeur.

• Si options.alignment contient une valeur, c'est une valeur d'alignement valide et n'est pas inférieure à std::meta::alignment_of(type).
• Pour chaque élément r dans options.annotations, std::meta::type_of(r) est valide et représente un type objet non tableau, et l'évaluation de std::meta::constant_of(r) ne lève pas d'exception.

Exemple

#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!

Voir aussi