Extensions for reflection
Las Extensiones de C++ para Reflexión, ISO/IEC TS 23619:2021, especifica modificaciones al lenguaje central y define nuevos componentes para la biblioteca estándar de C++ listados en esta página.
El TS de Reflexión se basa en el estándar C++20 (excepto que la definición de conceptos se especifica en el estilo del TS de Conceptos ).
Cambios en el lenguaje central
Especificador reflexpr
Un
reflexpr-specifier
tiene la forma
reflexpr
(
reflexpr-operand
)
, y especifica un tipo meta-objeto (ver más abajo).
reflexpr-operand puede ser uno de los siguientes:
::
|
(1) | ||||||||
| type-id | (2) | ||||||||
| nested-name-specifier (opcional) namespace-name | (3) | ||||||||
| id-expression | (4) | ||||||||
(
expression
)
|
(5) | ||||||||
| function-call-expression | (6) | ||||||||
| functional-type-conv-expression | (7) | ||||||||
donde function-call-expression es
expresión-postfija
(
lista-de-expresiones
(opcional)
)
|
|||||||||
y functional-type-conv-expression son los siguientes tipos de expresiones que realizan explicit cast :
especificador-de-tipo-simple
(
lista-de-expresiones
(opcional)
)
|
(1) | ||||||||
especificador-de-nombre-de-tipo
(
lista-de-expresiones
(opcional)
)
|
(2) | ||||||||
| especificador-de-tipo-simple lista-de-inicialización-entre-llaves | (3) | ||||||||
| especificador-de-nombre-de-tipo lista-de-inicialización-entre-llaves | (4) | ||||||||
El operando del reflexpr-specifier debe ser un tipo , namespace , enumerador , variable, miembro de datos , parámetro de función , entidad capturada , function-call-expression o functional-type-conv-expression , y expresión entre paréntesis. reflexpr ( :: ) refleja el namespace global.
Para un
reflexpr-operando
de la forma
(
expresión
)
, la
expresión
deberá ser una (posiblemente entre múltiples paréntesis)
expresión-de-llamada-a-función
o
expresión-de-conversión-de-tipo-funcional
.
Si un operando sin paréntesis puede tratarse como un
type-id
o como una
functional-type-conv-expression
, entonces se trata como un
type-id
. Los paréntesis pueden utilizarse para eliminar la ambigüedad entre una conversión de estilo función y un
type-id
. Por ejemplo, dado un tipo de clase
X
con constructor predeterminado,
reflexpr
(
X
(
)
)
refleja el tipo de función
X
(
)
, y
reflexpr
(
(
X
(
)
)
)
refleja la expresión
X
(
)
.
Si el operando designa tanto un alias como un nombre de clase, el tipo representado por el especificador reflexpr refleja el alias y satisface
reflect::Alias
.
Si el operando designa un nombre cuya declaración está encerrada en un ámbito de bloque y la entidad nombrada no es capturada ni es un parámetro de función, el programa está mal formado.
Tipos de meta-objetos
Un
tipo de meta-objeto
es un tipo de clase no nombrado e incompleto en el ámbito del espacio de nombres. Un tipo satisface el concepto
reflect::Object
si y solo si es un tipo de meta-objeto. Los tipos de meta-objeto pueden satisfacer otros conceptos, dependiendo del operando de
reflexpr
.
No está especificado si aplicar repetidamente
reflexpr
al mismo operando produce el mismo tipo o un tipo diferente. Si un tipo meta-objeto refleja un tipo de clase incompleto, ciertas transformaciones de tipo no pueden aplicarse.
Un tipo meta-objeto permite la inspección de algunas propiedades del operando de
reflexpr
mediante type traits o transformaciones de tipos sobre él.
Resolución de sobrecarga
Si la expresión postfija de la expresión de llamada a función es de tipo clase, es decir, e en la expresión de llamada a función e ( args ) es de tipo clase, entonces la función de conversión definida por el usuario del tipo de la expresión postfija ( e ) no debe utilizarse.
Si postfix-expression no es de tipo clase, deberá nombrar una función que sea el resultado único de la resolución de sobrecarga.
struct Functor { void operator()(int) const; using fptr_t = void(*)(std::nullptr_t); operator fptr_t() const; }; using Meta0 = reflexpr(Functor{}(0)); // CORRECTO // using Meta1 = reflexpr(Functor{}(nullptr)); // error: función de conversión utilizada
Un alias es un nombre introducido por una typedef , una alias-declaration , o una using-declaration .
Una entidad o alias
B
está
relacionado con la reflexión
de una entidad o alias
A
si
-
AyBson la misma entidad o alias, -
Aes una variable o enumerador yBes el tipo deA, -
Aes una enumeración yBes el tipo subyacente deA, -
Aes una clase yBes un miembro o clase base deA, -
Aes un alias no plantilla que designa la entidadB, -
Ano es el espacio de nombres global yBes una clase o espacio de nombres contenedor deA, -
Aes la expresión entre paréntesis (B), -
Aes una captura lambda del tipo de clausuraB, -
Aes el tipo de clausura de la captura lambdaB, -
Bes el tipo especificado por la expresión-de-conversión-de-tipo-funcionalA, -
Bes la función seleccionada por resolución de sobrecarga para una expresión-de-llamada-a-funciónA, -
Bes el tipo de retorno, un tipo de parámetro o tipo de función de la funciónA, o -
Bestá relacionado por reflexión con una entidad o aliasXyXestá relacionado por reflexión conA.
La relación de reflexión-relación es reflexiva y transitiva, pero no simétrica.
Informalmente hablando, el caso en que
B
está relacionado por reflexión con
A
significa que
B
participa en la declaración o definición de
A
.
Cero o más aplicaciones sucesivas de transformaciones de tipos que produzcan tipos meta-objeto al tipo denotado por un reflexpr-specifier permiten la inspección de entidades y alias que están relacionados con reflexión al operando; se dice que tal tipo meta-objeto refleja la respectiva entidad o alias relacionado con reflexión.
struct X; struct B { using X = ::X; typedef X Y; }; struct D : B { using B::Y; }; // ::X, pero no B::X o B::Y están relacionados con reflexión a D::Y
Misceláneos
- Una expresión utilizada como reflexpr-operando es una expresión no evaluada y potencialmente evaluada como constante .
-
Para determinar las variables
capturadas en una expresión lambda
por una captura por defecto, un operando
reflexprno se considera un operando no evaluado. -
Una función o variable con
duración de almacenamiento estático
reflejada por el tipo meta-objeto
Tes odr-utilizada por la especialización std :: experimental :: reflect :: get_pointer < T > , como si se tomara la dirección de una expresión de id que nombra la función o variable. - Puede haber más de una definición de un tipo meta-objeto, siempre que todas las operaciones sobre este tipo produzcan los mismos resultados de expresión constante.
-
Un tipo es
dependiente
si está denotado por un especificador reflexpr, y el operando
- es una expresión dependiente de tipo o una expresión de conversión de tipo funcional (posiblemente entre paréntesis) con al menos una subexpresión inmediata dependiente de tipo, o
- designa un tipo dependiente o un miembro de una especialización desconocida o una expresión constante dependiente de valor .
Palabras clave
Macros predefinidos para pruebas de características
|
__cpp_reflection
(reflection TS)
|
un valor de al menos
201902
indica que el Reflection TS es compatible
(constante de macro) |
Soporte de biblioteca
Conceptos
|
Definido en el encabezado
<experimental/reflect>
|
|
|
Definido en el espacio de nombres
std::experimental::reflect
|
|
|
Definido en el espacio de nombres en línea
std::experimental::reflect::v1
|
|
|
(reflection TS)
|
especifica que un tipo es un tipo meta-objeto
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto es un tipo de secuencia de meta-objetos
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja un ámbito de parámetro de plantilla
(concepto) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja una entidad o alias con un nombre asociado (posiblemente vacío)
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja un alias de tipo, alias de namespace, o un alias introducido por una using-declaration
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja una
member-declaration
de una clase
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja un enumerador
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja una variable o miembro de datos
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto satisface
RecordMember
,
Enumerator
, o
Variable
, o refleja un espacio de nombres distinto del espacio de nombres global
(concepto) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja una entidad con un tipo
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja un namespace
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja el espacio de nombres global
(concepto) |
|
(reflection TS)
|
especifica que un tipo meta-objeto refleja un tipo de clase no-union
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja un tipo de enumeración
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja un tipo de clase
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja un namespace, class, enumeration, function, closure type, un template parameter scope
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja un tipo
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja un enumerador o una variable constexpr
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja una clase base directa obtenida de
get_base_classes
(concepto) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja un parámetro de función
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja una función (incluyendo constructores y destructores)
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja una expresión
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja una expresión entre paréntesis
(concepto) |
|
(reflection TS)
|
especifica que un tipo meta-objeto refleja una
function-call-expression
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja una
functional-type-conv-expression
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja una función (excluyendo constructores y destructores)
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja una función miembro (excluyendo constructores y destructores)
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja una función miembro especial
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja un constructor
(concepto) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja un destructor
(concept) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja una función de operador o una función de conversión
(concepto) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja una función de conversión
(concept) |
|
(reflection TS)
|
especifica que un tipo meta-objeto refleja el tipo de cierre de un lambda no genérico
(concepto) |
|
(reflection TS)
|
especifica que un tipo de meta-objeto refleja una captura lambda
(concepto) |
Operaciones de meta-objeto
|
Definido en el encabezado
<experimental/reflect>
|
|
|
Definido en el espacio de nombres
std::experimental::reflect
|
|
|
Definido en el espacio de nombres en línea
std::experimental::reflect::v1
|
|
|
|
|
(reflection TS)
|
verifica si dos tipos de meta-objeto reflejan la misma entidad o alias
(plantilla de clase) |
|
(reflection TS)
|
obtiene el número de línea presunto de la declaración de la entidad reflejada o alias
(class template) |
|
(reflection TS)
|
obtiene el número de columna definido por la implementación de la declaración de la entidad reflejada o alias
(plantilla de clase) |
|
(reflection TS)
|
obtiene el nombre de archivo presunto de la declaración de la entidad reflejada o alias
(plantilla de clase) |
|
|
|
(reflection TS)
|
obtiene el tamaño de una secuencia de meta-objetos
(plantilla de clase) |
|
(reflection TS)
|
obtiene el tipo de meta-objeto con el índice especificado en una secuencia
(plantilla de clase) |
|
(reflection TS)
|
aplica una plantilla a la secuencia de meta-objetos
(plantilla de clase) |
|
|
|
(reflection TS)
|
verifica si la entidad reflejada o alias no tiene nombre
(class template) |
|
(reflection TS)
|
obtiene el nombre no calificado de la entidad reflejada o alias
(plantilla de clase) |
|
(reflection TS)
|
obtiene el nombre de visualización definido por la implementación de la entidad reflejada o alias
(plantilla de clase) |
|
|
|
(reflection TS)
|
obtiene el tipo de meta-objeto que refleja la entidad asociada del alias reflejado
(plantilla de clase) |
|
|
|
(reflection TS)
|
obtiene el tipo de meta-objeto que refleja el tipo de la entidad reflejada o alias
(plantilla de clase) |
|
(reflection TS)
|
obtiene el tipo de la entidad reflejada o alias
(plantilla de clase) |
|
(reflection TS)
|
verifica si el tipo de meta-objeto refleja un tipo de enumeración
(plantilla de clase) |
|
(reflection TS)
|
comprueba si el tipo de meta-objeto refleja un tipo unión
(plantilla de clase) |
|
(reflection TS)
|
verifica si el tipo de meta-objeto refleja un tipo de clase no-union cuya declaración utiliza
class
o
struct
respectivamente
(plantilla de clase) |
|
|
|
(reflection TS)
|
obtiene el tipo de meta-objeto que refleja el ámbito de la entidad reflejada o alias
(plantilla de clase) |
|
|
|
(reflection TS)
|
obtiene el tipo de meta-objeto que refleja la clase base en la relación de clase base dada
(plantilla de clase) |
|
|
|
(reflection TS)
|
verifica si el miembro reflejado o la clase base es público
(plantilla de clase) |
|
(reflection TS)
|
verifica si el miembro reflejado o clase base está protegido
(plantilla de clase) |
|
(reflection TS)
|
verifica si el miembro reflejado o clase base es privado
(plantilla de clase) |
|
|
|
obtiene un tipo de secuencia meta-objeto cuyos elementos reflejan los miembros de datos públicos, accesibles o todos los miembros de datos de la clase reflejada
(plantilla de clase) |
|
|
obtiene un tipo de secuencia de meta-objetos cuyos elementos reflejan las funciones miembro públicas, accesibles o todas las funciones miembro de la clase reflejada
(plantilla de clase) |
|
|
(reflection TS)
|
obtiene un tipo de secuencia de meta-objetos cuyos elementos reflejan todos los constructores de la clase reflejada
(plantilla de clase) |
|
(reflection TS)
|
obtiene un tipo de secuencia de meta-objetos cuyos elementos reflejan todas las funciones de operador y funciones de conversión declaradas en la clase reflejada
(plantilla de clase) |
|
(reflection TS)
|
obtiene el tipo de meta-objeto que refleja el destructor de la clase reflejada
(plantilla de clase) |
|
obtiene un tipo de secuencia de meta-objetos cuyos elementos reflejan los tipos anidados públicos, accesibles o todos los typedefs de miembros de la clase reflejada
(plantilla de clase) |
|
|
obtiene un tipo de secuencia de meta-objetos cuyos elementos reflejan las clases base públicas, accesibles o todas las clases base de la clase reflejada
(plantilla de clase) |
|
|
|
|
(reflection TS)
|
verifica si la enumeración reflejada es de ámbito delimitado
(plantilla de clase) |
|
(reflection TS)
|
obtiene un tipo de secuencia de meta-objetos cuyos elementos reflejan los enumeradores de la enumeración reflejada
(plantilla de clase) |
|
(reflection TS)
|
obtiene el tipo de meta-objeto que refleja el tipo subyacente de la enumeración reflejada
(plantilla de clase) |
|
|
|
(reflection TS)
|
obtiene el valor de la variable reflejada que es una expresión constante
(plantilla de clase) |
|
(reflection TS)
|
verifica si la variable está declarada con
thread_local
(plantilla de clase) |
|
|
|
(reflection TS)
|
verifica si el parámetro reflejado tiene un argumento por defecto
(plantilla de clase) |
|
|
|
(reflection TS)
|
obtiene un tipo de secuencia de meta-objetos cuyos elementos reflejan los parámetros de la función reflejada
(plantilla de clase) |
|
(reflection TS)
|
verifica si la lista de parámetros de la función reflejada contiene un parámetro de elipsis
(plantilla de clase) |
|
(reflection TS)
|
verifica si la función reflejada es no lanzadora de excepciones
(plantilla de clase) |
|
(reflection TS)
|
verifica si la función reflejada está eliminada
(plantilla de clase) |
|
|
|
(reflection TS)
|
verifica si la variable o función reflejada es constexpr
(plantilla de clase) |
|
|
|
(reflection TS)
|
verifica si el espacio de nombres o función reflejado es inline
(plantilla de clase) |
|
|
|
(reflection TS)
|
obtiene el tipo de meta-objeto que refleja la expresión sin paréntesis de la expresión parentizada reflejada
(plantilla de clase) |
|
|
|
(reflection TS)
|
obtiene el tipo de meta-objeto que refleja la función en la
function-call-expression
reflejada
(plantilla de clase) |
|
|
|
(reflection TS)
|
obtiene el tipo de meta-objeto que refleja el constructor en la expresión
functional-type-conv-expression
reflejada
(plantilla de clase) |
|
|
|
(reflection TS)
|
obtiene la dirección de la variable o función reflejada, o el valor de puntero-a-miembro para el miembro no estático reflejado
(plantilla de clase) |
|
|
|
verifica si la función miembro reflejada está declarada con
const
,
volatile
,
&
, o
&&
calificador respectivamente
(plantilla de clase) |
|
|
(reflection TS)
|
verifica si la función miembro reflejada sobreescribe una función miembro de la clase base
(plantilla de clase) |
|
|
|
(reflection TS)
|
verifica si la clase reflejada o función miembro está marcada con
final
(plantilla de clase) |
|
|
|
(reflection TS)
|
verifica si la variable reflejada tiene duración de almacenamiento estático, o si la función miembro reflejada es estática
(plantilla de clase) |
|
|
|
(reflection TS)
|
verifica si la función miembro especial reflejada está declarada implícitamente
(plantilla de clase) |
|
(reflection TS)
|
verifica si la función miembro especial reflejada está predeterminada en su primera declaración
(plantilla de clase) |
|
|
|
(reflection TS)
|
verifica si el constructor reflejado o la función de conversión está declarado con
explicit
(plantilla de clase) |
|
|
|
(reflection TS)
|
verifica si la función miembro reflejada es virtual
(plantilla de clase) |
|
(reflection TS)
|
verifica si la función miembro reflejada es puramente virtual
(plantilla de clase) |
|
|
|
(reflection TS)
|
obtiene un tipo de secuencia de meta-objetos cuyos elementos reflejan las capturas del tipo de clausura reflejado
(plantilla de clase) |
|
(reflection TS)
|
verifica si la captura por defecto de la expresión lambda del tipo de clausura reflejada es
=
o
&
respectivamente
(plantilla de clase) |
|
(reflection TS)
|
verifica si el
operator()
del tipo de clausura reflejado está declarado con
const
(plantilla de clase) |
|
|
|
(reflection TS)
|
verifica si la captura de lambda reflejada está explícitamente capturada
(plantilla de clase) |
|
(reflection TS)
|
verifica si la captura de lambda reflejada es una init-capture
(plantilla de clase) |
Macros de prueba de características de la biblioteca
|
Definido en el encabezado
<experimental/reflect>
|
|
|
__cpp_lib_reflection
(reflection TS)
|
un valor de al menos
201902
indica que la biblioteca de soporte del Reflection TS está soportada
(constante macro) |
Satisfacción de conceptos
La siguiente tabla indica si un tipo de meta-objeto que refleja un operando satisface los conceptos introducidos por el Reflection TS.
| Categoría |
reflexpr
operandos
|
Conceptos satisfechos |
|---|---|---|
| Tipo | class-name que designa una union |
reflect::Union
|
| class-name que designa un closure type |
reflect::Lambda
|
|
| class-name que designa una clase no-union |
reflect::Record
|
|
| enum-name |
reflect::Enum
|
|
| template type-parameter |
reflect::Type
,
reflect::Alias
|
|
| decltype-specifier |
reflect::Type
,
reflect::Alias
|
|
| type-name introducido por una using-declaration |
reflect::Type
,
reflect::Alias
,
reflect::ScopedMember
|
|
| cualquier otro typedef-name |
reflect::Type
,
reflect::Alias
|
|
| cualquier otro type-id |
reflect::Type
|
|
| Espacio de nombres | namespace-alias |
reflect::Namespace
,
reflect::Alias
|
| el espacio de nombres global |
reflect::GlobalScope
|
|
| cualquier otro namespace |
reflect::Namespace
|
|
| Expresión | el nombre de un miembro de datos |
reflect::Variable
|
| el nombre de una variable |
reflect::Variable
|
|
| el nombre de un enumerador |
reflect::Enumerator
|
|
| el nombre de un parámetro de función |
reflect::FunctionParameter
|
|
| el nombre de una captured entity |
reflect::LambdaCapture
|
|
| expresión entre paréntesis |
reflect::ParenthesizedExpression
|
|
| function-call-expression |
reflect::FunctionCallExpression
|
|
| functional-type-conv-expression |
reflect::FunctionalTypeConversion
|
Si el operando de la forma expresión-id es una expresión constante, el tipo especificado por el especificador reflexpr también satisface
reflect::Constant
.
Si el operando de reflexpr designa un miembro de clase, el tipo representado por el especificador reflexpr también satisface
reflect::RecordMember
.
Véase también
|
contiene información de algún tipo, la clase devuelta por el operador typeid
(clase) |
|
|
(C++11)
|
Utilidades de información de tipos en tiempo de compilación |