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

Una descripción de miembro de datos se representa usualmente como una sextupla (T, N, A, W, NUA, ANN), donde:

• T es el tipo representado por std::meta::dealias(type).
• N es el identificador codificado por options.name, o un valor especial (denotado por ⊥) si options.name no contiene un valor.
• A es el valor de alineación mantenido por options.alignment, o un valor especial (denotado por ⊥) si options.alignment no contiene un valor.
• W es el valor mantenido por options.bit_width, o un valor especial (denotado por ⊥) si options.bit_width no contiene un valor.
• NUA es el valor de options.no_unique_address.
• ANN es la secuencia de valores std::meta::constant_of(r) para cada r en options.annotations.

Dos descripciones de miembro de datos son iguales si cada uno de sus respectivos componentes son las mismas entidades, son los mismos identificadores, tienen valores iguales, o ambos son ⊥. Dos reflexiones de descripciones de miembro de datos se comparan igual si las descripciones que representan son iguales.

Si la combinación de argumentos no es válida, se lanza std::meta::exception. Vea la sección Excepciones a continuación para más detalles.

El tipo de solo exposición designado por /*name-type*/ es un tipo de clase con los siguientes constructores:

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

Parámetros

Valor de retorno

Una reflexión que representa una descripción de miembro de datos, construida a partir de los argumentos.

Excepciones

Lanza std::meta::exception a menos que se cumplan todas las siguientes condiciones:

• std::meta::dealias(type) representa un tipo objeto o un tipo referencia.
• Si options.name contiene un valor:

• Si el nombre fue construido a partir de una cadena UTF-8, la cadena es la escritura de un token válido, y el token es un identificador válido, cuando se interpreta con UTF-8.
• De lo contrario (el nombre fue construido a partir de una cadena ordinaria), la cadena es la escritura de un token válido, y el token es un identificador válido, cuando se interpreta con la codificación literal ordinaria.

• Si options.name no contiene un valor, options.bit_width contiene un valor. (En este caso, el resultado describe un campo de bits sin nombre.)
• Si options.bit_width contiene un valor V, entonces:

• std::meta::is_integral(type) || std::meta::is_enum_type(type) es verdadero.
• options.alignment contiene un valor.
• options.no_unique_address es falso.
• V no es negativo.
• Si V es cero, options.name no contiene un valor.

• Si options.alignment contiene un valor, es un valor de alineación válido y no es menor que std::meta::alignment_of(type).
• Para cada elemento r en options.annotations, std::meta::type_of(r) es válido y representa un tipo objeto no arreglo, y la evaluación de std::meta::constant_of(r) no lanza una excepción.

Ejemplo

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

Véase también