Experimental library header <experimental/reflect>

From cppreference.net

<experimental/execution>

Filesystem TS

<experimental/filesystem>

Parallelism TS (v1, v2)

`experimental/algorithm`
`experimental/execution_policy`
`experimental/exception_list`

`experimental/numeric`
`<experimental/simd>`
`experimental/task_block`

Library Fundamentals TS (v1, v2, v3)

`experimental/algorithm`
`<experimental/any>`
`experimental/array`
`experimental/chrono`
`experimental/deque`
`experimental/forward_list`
`<experimental/functional>`
`experimental/future`
`experimental/iterator`
`experimental/list`
`experimental/map`
`experimental/memory`
`<experimental/memory_resource>`
`experimental/numeric`
`<experimental/optional>`
`experimental/propagate_const`

`experimental/random`
`experimental/ratio`
`experimental/regex`
`experimental/scope`
`experimental/set`
`experimental/source_location`
`experimental/string`
`<experimental/string_view>`
`experimental/system_error`
`experimental/tuple`
`experimental/type_traits`
`experimental/unordered_map`
`experimental/unordered_set`
`experimental/utility`
`experimental/vector`

Concurrency TS

`experimental/atomic`
`experimental/barrier`

`experimental/future`
`experimental/latch`

Ranges TS

`<experimental/ranges/algorithm>`
`<experimental/ranges/concepts>`
`<experimental/ranges/functional>`
`<experimental/ranges/iterator>`

`<experimental/ranges/random>`
`<experimental/ranges/tuple>`
`<experimental/ranges/type_traits>`
`<experimental/ranges/utility>`

Coroutines TS


               experimental/coroutine

Networking TS

`experimental/buffer`
`experimental/executor`
`experimental/internet`
`experimental/io_context`

`<experimental/net>`
`experimental/netfwd`
`experimental/socket`
`experimental/timer`

Reflection TS

<experimental/reflect>

Este encabezado es parte del Reflection TS .

Definido en el espacio de nombres


           std::experimental::reflect

Definido en el espacio de nombres en línea


           std::experimental::reflect::v1

Contenidos

Conceptos

Object

(reflection TS)

especifica que un tipo es un tipo meta-objeto
(concept)

ObjectSequence

(reflection TS)

especifica que un tipo de meta-objeto es un tipo de secuencia de meta-objetos
(concepto)

TemplateParameterScope

(reflection TS)

especifica que un tipo de meta-objeto refleja un ámbito de parámetro de plantilla
(concepto)

Named

(reflection TS)

especifica que un tipo de meta-objeto refleja una entidad o alias con un nombre asociado (posiblemente vacío)
(concept)

Alias

(reflection TS)

especifica que un tipo de meta-objeto refleja un alias de tipo, alias de espacio de nombres, o un alias introducido por una declaración using
(concepto)

RecordMember

(reflection TS)

especifica que un tipo de meta-objeto refleja una member-declaration de una clase
(concept)

Enumerator

(reflection TS)

especifica que un tipo de meta-objeto refleja un enumerador
(concept)

Variable

(reflection TS)

especifica que un tipo de meta-objeto refleja una variable o miembro de datos
(concept)

ScopeMember

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

Typed

(reflection TS)

especifica que un tipo de meta-objeto refleja una entidad con un tipo
(concept)

Namespace

(reflection TS)

especifica que un tipo de meta-objeto refleja un namespace
(concept)

GlobalScope

(reflection TS)

especifica que un tipo de meta-objeto refleja el espacio de nombres global
(concept)

Class

(reflection TS)

especifica que un tipo de meta-objeto refleja un tipo de clase no-union
(concepto)

Enum

(reflection TS)

especifica que un tipo de meta-objeto refleja un tipo de enumeración
(concept)

Record

(reflection TS)

especifica que un tipo de meta-objeto refleja un tipo de clase
(concept)

Scope

(reflection TS)

especifica que un tipo de meta-objeto refleja un espacio de nombres, clase, enumeración, función, tipo de clausura, o un ámbito de parámetro de plantilla
(concepto)

Type

(reflection TS)

especifica que un tipo de meta-objeto refleja un tipo
(concept)

Constant

(reflection TS)

especifica que un tipo de meta-objeto refleja un enumerador o una variable constexpr
(concept)

Base

(reflection TS)

especifica que un tipo de meta-objeto refleja una clase base directa obtenida de


          get_base_classes

(concept)

FunctionParameter

(reflection TS)

especifica que un tipo de meta-objeto refleja un parámetro de función
(concepto)

Callable

(reflection TS)

especifica que un tipo de meta-objeto refleja una función (incluyendo constructores y destructores)
(concept)

Expression

(reflection TS)

especifica que un tipo de meta-objeto refleja una expresión
(concept)

ParenthesizedExpression

(reflection TS)

especifica que un tipo de meta-objeto refleja una expresión entre paréntesis
(concepto)

FunctionCallExpression

(reflection TS)

especifica que un tipo de meta-objeto refleja una function-call-expression
(concepto)

FunctionalTypeConversion

(reflection TS)

especifica que un tipo de meta-objeto refleja una functional-type-conv-expression
(concepto)

Function

(reflection TS)

especifica que un tipo de meta-objeto refleja una función (excluyendo constructores y destructores)
(concept)

MemberFunction

(reflection TS)

especifica que un tipo de meta-objeto refleja una función miembro (excluyendo constructores y destructores)
(concept)

SpecialMemberFunction

(reflection TS)

especifica que un tipo de meta-objeto refleja una función miembro especial
(concepto)

Constructor

(reflection TS)

especifica que un tipo de meta-objeto refleja un constructor
(concept)

Destructor

(reflection TS)

especifica que un tipo de meta-objeto refleja un destructor
(concept)

Operator

(reflection TS)

especifica que un tipo de meta-objeto refleja una función de operador o una función de conversión
(concepto)

ConversionOperator

(reflection TS)

especifica que un tipo de meta-objeto refleja una función de conversión
(concept)

Lambda

(reflection TS)

especifica que un tipo meta-objeto refleja el tipo de cierre de un lambda no genérico
(concepto)

LambdaCapture

(reflection TS)

especifica que un tipo de meta-objeto refleja una captura lambda
(concepto)

Clases

`Object` operaciones

reflects_same

(reflection TS)

verifica si dos tipos de meta-objeto reflejan la misma entidad o alias
(plantilla de clase)

get_source_line

(reflection TS)

obtiene el número de línea presunto de la declaración de la entidad reflejada o alias
(plantilla de clase)

get_source_column

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

get_source_file_name

(reflection TS)

obtiene el nombre de archivo presunto de la declaración de la entidad reflejada o alias
(class template)

`ObjectSequence` operaciones

get_size

(reflection TS)

obtiene el tamaño de una secuencia de meta-objetos
(plantilla de clase)

get_element

(reflection TS)

obtiene el tipo de meta-objeto con el índice especificado en una secuencia
(plantilla de clase)

unpack_sequence

(reflection TS)

aplica una plantilla a la secuencia de meta-objetos
(plantilla de clase)

`Named` operaciones

is_unnamed

(reflection TS)

verifica si la entidad reflejada o alias tiene nombre
(class template)

get_name

(reflection TS)

obtiene el nombre no calificado de la entidad reflejada o alias
(plantilla de clase)

get_display_name

(reflection TS)

obtiene el nombre de visualización definido por la implementación de la entidad reflejada o alias
(plantilla de clase)

`Alias` operaciones

get_alias

(reflection TS)

obtiene el tipo de meta-objeto que refleja la entidad asociada del alias reflejado
(plantilla de clase)

`Type` operaciones

get_type

(reflection TS)

obtiene el tipo de meta-objeto que refleja el tipo de la entidad reflejada o alias
(plantilla de clase)

get_reflected_type

(reflection TS)

obtiene el tipo de la entidad reflejada o alias
(plantilla de clase)

is_enum

(reflection TS)

verifica si el tipo de meta-objeto refleja un tipo de enumeración
(plantilla de clase)

is_union

(reflection TS)

verifica si el tipo de meta-objeto refleja un tipo unión
(plantilla de clase)

uses_class_key uses_struct_key

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

`ScopeMember` operaciones

get_scope

(reflection TS)

obtiene el tipo de meta-objeto que refleja el ámbito de la entidad reflejada o alias
(plantilla de clase)

`Base` operaciones

get_class

(reflection TS)

obtiene el tipo de meta-objeto que refleja la clase base en la relación de clase base dada
(plantilla de clase)

`RecordMember` y `Base` operaciones

is_public

(reflection TS)

verifica si el miembro reflejado o clase base es público
(plantilla de clase)

is_protected

(reflection TS)

verifica si el miembro reflejado o clase base está protegido
(class template)

is_private

(reflection TS)

verifica si el miembro reflejado o clase base es privado
(plantilla de clase)

`Record` operaciones

get_public_data_members get_accessible_data_members get_data_members

(reflection TS)

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)

get_public_member_functions get_accessible_member_functions get_member_functions

(reflection TS)

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)

get_constructors

(reflection TS)

obtiene un tipo de secuencia de meta-objetos cuyos elementos reflejan todos los constructores de la clase reflejada
(plantilla de clase)

get_operators

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

get_destructor

(reflection TS)

obtiene el tipo de meta-objeto que refleja el destructor de la clase reflejada
(plantilla de clase)

get_public_member_types get_accessible_member_types get_member_types

(reflection TS)

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)

get_public_base_classes get_accessible_base_classes get_base_classes

(reflection TS)

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)

`Enum` operaciones

is_scoped_enum

(reflection TS)

verifica si la enumeración reflejada es de ámbito delimitado
(plantilla de clase)

get_enumerators

(reflection TS)

obtiene un tipo de secuencia de meta-objetos cuyos elementos reflejan los enumeradores de la enumeración reflejada
(plantilla de clase)

get_underlying_type

(reflection TS)

obtiene el tipo de meta-objeto que refleja el tipo subyacente de la enumeración reflejada
(plantilla de clase)

`Variable` operaciones

get_constant

(reflection TS)

obtiene el valor de la variable reflejada que es una expresión constante
(plantilla de clase)

is_thread_local

(reflection TS)

comprueba si la variable está declarada con thread_local
(plantilla de clase)

`FunctionParameter` operaciones

has_default_argument

(reflection TS)

verifica si el parámetro reflejado tiene un argumento por defecto
(plantilla de clase)

`Callable` operaciones

get_parameters

(reflection TS)

obtiene un tipo de secuencia de meta-objetos cuyos elementos reflejan los parámetros de la función reflejada
(plantilla de clase)

is_vararg

(reflection TS)

verifica si la lista de parámetros de la función reflejada contiene un parámetro de elipsis
(plantilla de clase)

is_noexcept

(reflection TS)

verifica si la función reflejada es no-lanzadora
(plantilla de clase)

is_deleted

(reflection TS)

verifica si la función reflejada está eliminada
(plantilla de clase)

`Variable` y `Callable` operaciones

is_constexpr

(reflection TS)

verifica si la variable o función reflejada es constexpr
(plantilla de clase)

`Namespace` y operaciones `Callable`

is_inline

(reflection TS)

verifica si el espacio de nombres o función reflejado es inline
(plantilla de clase)

`ParenthesizedExpression` operaciones

get_subexpression

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

`FunctionCallExpression` operaciones

get_callable

(reflection TS)

obtiene el tipo de meta-objeto que refleja la función en la function-call-expression reflejada
(plantilla de clase)

`FunctionalTypeConversion` operaciones

get_constructor

(reflection TS)

obtiene el tipo de meta-objeto que refleja el constructor en la expresión functional-type-conv-expression reflejada
(plantilla de clase)

`Variable` y `Function` operaciones

get_pointer

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

`MemberFunction` operaciones

is_const is_volatile has_lvalueref_qualifier has_rvalueref_qualifier

(reflection TS)

verifica si la función miembro reflejada está declarada con const , volatile , & , o && calificador respectivamente
(plantilla de clase)

is_override

(reflection TS)

verifica si la función miembro reflejada anula una función miembro de la clase base
(plantilla de clase)

`Record` y `MemberFunction` operaciones

is_final

(reflection TS)

verifica si la clase reflejada o función miembro está marcada con final
(plantilla de clase)

`Variable` y `MemberFunction` operaciones

is_static

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

`SpecialMemberFunction` operaciones

is_implicitly_declared

(reflection TS)

verifica si la función miembro especial reflejada está declarada implícitamente
(plantilla de clase)

is_defaulted

(reflection TS)

verifica si la función miembro especial reflejada está predeterminada en su primera declaración
(plantilla de clase)

`Constructor` y `ConversionOperator` operaciones

is_explicit

(reflection TS)

verifica si el constructor reflejado o la función de conversión está declarado con explicit
(plantilla de clase)

`MemberFunction` y `Destructor` operaciones

is_virtual

(reflection TS)

verifica si la función miembro reflejada es virtual
(plantilla de clase)

is_pure_virtual

(reflection TS)

verifica si la función miembro reflejada es virtual pura
(plantilla de clase)

`Lambda` operaciones

get_captures

(reflection TS)

obtiene un tipo de secuencia de meta-objetos cuyos elementos reflejan las capturas del tipo de clausura reflejado
(plantilla de clase)

uses_default_copy_capture uses_default_reference_capture

(reflection TS)

verifica si la captura por defecto de la expresión lambda del tipo de clausura reflejada es

respectivamente
(plantilla de clase)

is_call_operator_const

(reflection TS)

verifica si el


          operator()

del tipo de clausura reflejado está declarado con const
(plantilla de clase)

`LambdaCapture` operaciones

is_explictly_captured

(reflection TS)

verifica si la captura de lambda reflejada está explícitamente capturada
(plantilla de clase)

is_init_capture

(reflection TS)

verifica si la captura de lambda reflejada es una init-capture
(plantilla de clase)

Sinopsis

namespace std::experimental::reflect {
inline namespace v1 {
// 21.12.3 Conceptos para tipos de meta-objetos
template <class T>
concept Object = /* ver descripción */;
template <class T>
concept ObjectSequence = /* ver descripción */; // refina Object
template <class T>
concept TemplateParameterScope = /* ver descripción */; // refina Scope
template <class T>
concept Named = /* ver descripción */;          // refina Object
template <class T>
concept Alias = /* ver descripción */;          // refina Named y ScopeMember
template <class T>
concept RecordMember = /* ver descripción */;   // refina ScopeMember
template <class T>
concept Enumerator = /* ver descripción */;     // refina Constant
template <class T>
concept Variable = /* ver descripción */;       // refina Typed y ScopeMember
template <class T>
concept ScopeMember = /* ver descripción */;    // refina Named
template <class T>
concept Typed = /* ver descripción */;          // refina Object
template <class T>
concept Namespace = /* ver descripción */;      // refina Named y Scope
template <class T>
concept GlobalScope = /* ver descripción */;    // refines Namespace
template <class T>
concept Class = /* ver descripción */;          // refina Record
template <class T>
concept Enum = /* ver descripción */;           // refina Type, Scope, y ScopeMember
template <class T>
concept Record = /* ver descripción */;         // refina Type, Scope, y ScopeMember
template <class T>
concept Scope = /* ver descripción */;          // refina Object
template <class T>
concept Type = /* ver descripción */;           // refina Named
template <class T>
concept Constant = /* ver descripción */;       // refina Typed y ScopeMember
template <class T>
concept Base = /* ver descripción */;           // refina Object
template <class T>
concept FunctionParameter = /* ver descripción */; // refina Typed y ScopeMember
template <class T>
concept Callable = /* ver descripción */;       // refina Scope y ScopeMember
template <class T>
concept Expression = /* ver descripción */;     // refina Object
template <class T>
concept ParenthesizedExpression = /* ver descripción */; // refina Expression
template <class T>
concept FunctionCallExpression = /* ver descripción */; // refina Expression
template <class T>
concept FunctionalTypeConversion = /* ver descripción */; // refina Expression
template <class T>
concept Function = /* ver descripción */;       // refina Typed y Callable
template <class T>
concept MemberFunction = /* ver descripción */; // refina RecordMember y Function
template <class T>
concept SpecialMemberFunction = /* ver descripción */; // refines RecordMember
template <class T>
concept Constructor = /* ver descripción */;    // refina Callable y RecordMember
template <class T>
concept Destructor = /* ver descripción */;     // refina Callable y SpecialMemberFunction
template <class T>
concept Operator = /* ver descripción */;       // refines Function
template <class T>
concept ConversionOperator = /* ver descripción */; // refines MemberFunction and Operator
template <class T>
concept Lambda = /* ver descripción */;         // refina Type y Scope
template <class T>
concept LambdaCapture = /* ver descripción */;  // refina Variable
// 21.12.4 Meta-object operations
// Operaciones multi-concepto
template <Object T> struct is_public;
template <Object T> struct is_protected;
template <Object T> struct is_private;
template <Object T> struct is_constexpr;
template <Object T> struct is_static;
template <Object T> struct is_final;
template <Object T> struct is_explicit;
template <Object T> struct is_inline;
template <Object T> struct is_virtual;
template <Object T> struct is_pure_virtual;
template <Object T> struct get_pointer;
template <class T>
requires RecordMember<T> || Base<T>
  constexpr auto is_public_v = is_public<T>::valor;
template <class T>
requires RecordMember<T> || Base<T>
  constexpr auto is_protected_v = is_protected<T>::valor;
template <class T>
requires RecordMember<T> || Base<T>
  constexpr auto is_private_v = is_private<T>::valor;
template <class T>
requires Variable<T> || Callable<T>
  constexpr auto is_constexpr_v = is_constexpr<T>::valor;
template <class T>
requires Variable<T> || MemberFunction<T>
  constexpr auto is_static_v = is_static<T>::valor;
template <class T>
requires Class<T> || MemberFunction<T>
  constexpr auto is_final_v = is_final<T>::valor;
template <class T>
requires Constructor<T> || ConversionOperator<T>
  constexpr auto is_explicit_v = is_explicit<T>::valor;
template <class T>
requires Namespace<T> || Callable<T>
  constexpr auto is_inline_v = is_inline<T>::valor;
template <class T>
requires Base<T> || MemberFunction<T> || Destructor<T>
  constexpr auto is_virtual_v = is_virtual<T>::valor;
template <class T>
requires MemberFunction<T> || Destructor<T>
  constexpr auto is_pure_virtual_v = is_pure_virtual<T>::valor;
template <class T>
requires Variable<T> || Function<T>
  constexpr auto get_pointer_v = get_pointer<T>::valor;
// 21.12.4.1 Operaciones con objetos
template <Object T1, Object T2> struct reflects_same;
template <Object T> struct get_source_line;
template <Object T> struct get_source_column;
template <Object T> struct get_source_file_name;
template <Object T1, Object T2>
  constexpr auto reflects_same_v = reflects_same<T1, T2>::valor;
template <class T>
  constexpr auto get_source_line_v = get_source_line<T>::valor;
template <class T>
  constexpr auto get_source_column_v = get_source_column<T>::valor;
template <class T>
  constexpr auto get_source_file_name_v = get_source_file_name<T>::valor;
// 21.12.4.2 Operaciones de ObjectSequence
template <ObjectSequence T> struct get_size;
template <size_t I, ObjectSequence T> struct get_element;
template <template <class...> class Tpl, ObjectSequence T>
  struct unpack_sequence;
template <ObjectSequence T>
  constexpr auto get_size_v = get_size<T>::valor;
template <size_t I, ObjectSequence T>
  using get_element_t = typename get_element<I, T>::type;
template <template <class...> class Tpl, ObjectSequence T>
  using unpack_sequence_t = typename unpack_sequence<Tpl, T>::type;
// 21.12.4.3 Operaciones con nombre
template <Named T> struct is_unnamed;
template <Named T> struct get_name;
template <Named T> struct get_display_name;
template <Named T>
  constexpr auto is_unnamed_v = is_unnamed<T>::valor;
template <Named T>
  constexpr auto get_name_v = get_name<T>::valor;
template <Named T>
  constexpr auto get_display_name_v = get_display_name<T>::valor;
// 21.12.4.4 Operaciones de alias
template <Alias T> struct get_aliased;
template <Alias T>
  using get_aliased_t = typename get_aliased<T>::type;
// 21.12.4.5 Operaciones de tipo
template <Typed T> struct get_type;
template <Type T> struct get_reflected_type;
template <Type T> struct is_enum;
template <Class T> struct uses_class_key;
template <Class T> struct uses_struct_key;
template <Type T> struct is_union;
template <Typed T>
  using get_type_t = typename get_type<T>::type;
template <Type T>
  using get_reflected_type_t = typename get_reflected_type<T>::type;
template <Type T>
  constexpr auto is_enum_v = is_enum<T>::valor;
template <Class T>
  constexpr auto uses_class_key_v = uses_class_key<T>::valor;
template <Class T>
  constexpr auto uses_struct_key_v = uses_struct_key<T>::valor;
template <Type T>
  constexpr auto is_union_v = is_union<T>::valor;
// 21.12.4.6 Operaciones de miembros
template <ScopeMember T> struct get_scope;
template <RecordMember T> struct is_public<T>;
template <RecordMember T> struct is_protected<T>;
template <RecordMember T> struct is_private<T>;
template <ScopeMember T>
  using get_scope_t = typename get_scope<T>::type;
// 21.12.4.7 Operaciones de registro
template <Record T> struct get_public_data_members;
template <Record T> struct get_accessible_data_members;
template <Record T> struct get_data_members;
template <Record T> struct get_public_member_functions;
template <Record T> struct get_accessible_member_functions;
template <Record T> struct get_member_functions;
template <Record T> struct get_public_member_types;
template <Record T> struct get_accessible_member_types;
template <Record T> struct get_member_types;
template <Record T> struct get_constructors;
template <Record T> struct get_destructor;
template <Record T> struct get_operators;
template <Class T> struct get_public_base_classes;
template <Class T> struct get_accessible_base_classes;
template <Class T> struct get_base_classes;
template <Class T> struct is_final<T>;
template <Record T>
  using get_public_data_members_t = typename get_public_data_members<T>::type;
template <Record T>
  using get_accessible_data_members_t = typename get_accessible_data_members<T>::type;
template <Record T>
  using get_data_members_t = typename get_data_members<T>::type;
template <Record T>
  using get_public_member_functions_t = typename get_public_member_functions<T>::type;
template <Record T>
  using get_accessible_member_functions_t = typename get_accessible_member_functions<T>::type;
template <Record T>
  using get_member_functions_t = typename get_member_functions<T>::type;
template <Record T>
  using get_public_member_types_t = typename get_public_member_types<T>::type;
template <Record T>
  using get_accessible_member_types_t = typename get_accessible_member_types<T>::type;
template <Record T>
  using get_member_types_t = typename get_member_types<T>::type;
template <Record T>
  using get_constructors_t = typename get_constructors<T>::type;
template <Record T>
  using get_destructor_t = typename get_destructor<T>::type;
template <Record T>
  using get_operators_t = typename get_operators<T>::type;
template <Class T>
  using get_public_base_classes_t = typename get_public_base_classes<T>::type;
template <Class T>
  using get_accessible_base_classes_t = typename get_accessible_base_classes<T>::type;
template <Class T>
  using get_base_classes_t = typename get_base_classes<T>::type;
// 21.12.4.8 Operaciones de enumeración
template <Enum T> struct is_scoped_enum;
template <Enum T> struct get_enumerators;
template <Enum T> struct get_underlying_type;
template <Enum T>
  constexpr auto is_scoped_enum_v = is_scoped_enum<T>::valor;
template <Enum T>
  using get_enumerators_t = typename get_enumerators<T>::type;
template <Enum T>
  using get_underlying_type_t = typename get_underlying_type<T>::type;
// 21.12.4.9 Operaciones de valor
template <Constant T> struct get_constant;
template <Variable T> struct is_constexpr<T>;
template <Variable T> struct is_static<T>;
template <Variable T> struct is_thread_local;
template <Variable T> struct get_pointer<T>;
template <Constant T>
  constexpr auto get_constant_v = get_constant<T>::valor;
template <Variable T>
  constexpr auto is_thread_local_v = is_thread_local<T>::valor;
// 21.12.4.10 Operaciones base
template <Base T> struct get_class;
template <Base T> struct is_virtual<T>;
template <Base T> struct is_public<T>;
template <Base T> struct is_protected<T>;
template <Base T> struct is_private<T>;
template <Base T>
  using get_class_t = typename get_class<T>::type;
// 21.12.4.11 Operaciones de namespace
template <Namespace T> struct is_inline<T>;
// 21.12.4.12 Operaciones de FunctionParameter
template <FunctionParameter T> struct has_default_argument;
template <FunctionParameter T>
  constexpr auto has_default_argument_v = has_default_argument<T>::valor;
// 21.12.4.13 Operaciones invocables
template <Callable T> struct get_parameters;
template <Callable T> struct is_vararg;
template <Callable T> struct is_constexpr<T>;
template <Callable T> struct is_noexcept;
template <Callable T> struct is_inline<T>;
template <Callable T> struct is_deleted;
template <Callable T>
  using get_parameters_t = typename get_parameters<T>::type;
template <Callable T>
  constexpr auto is_vararg_v = is_vararg<T>::valor;
template <Callable T>
  constexpr auto is_deleted_v = is_deleted<T>::valor;
// 21.12.4.14 Operaciones de ParenthesizedExpression
template <ParenthesizedExpression T> struct get_subexpression;
template <ParenthesizedExpression T>
  using get_subexpression_t = typename get_subexpression<T>::type;
// 21.12.4.15 Operaciones de FunctionCallExpression
template <FunctionCallExpression T> struct get_callable;
template <FunctionCallExpression T>
  using get_callable_t = typename get_callable<T>::type;
// 21.12.4.16 Operaciones FunctionalTypeConversion
template <FunctionalTypeConversion T> struct get_constructor;
template <FunctionalTypeConversion T>
  using get_constructor_t = typename get_constructor<T>::type;
// 21.12.4.17 Operaciones de función
template <Function T> struct get_pointer<T>;
// 21.12.4.18 Operaciones de MemberFunction
template <MemberFunction T> struct is_static<T>;
template <MemberFunction T> struct is_const;
template <MemberFunction T> struct is_volatile;
template <MemberFunction T> struct has_lvalueref_qualifier;
template <MemberFunction T> struct has_rvalueref_qualifier;
template <MemberFunction T> struct is_virtual<T>;
template <MemberFunction T> struct is_pure_virtual<T>;
template <MemberFunction T> struct is_override;
template <MemberFunction T> struct is_final<T>;
template <MemberFunction T>
  constexpr auto is_const_v = is_const<T>::valor;
template <MemberFunction T>
  constexpr auto is_volatile_v = is_volatile<T>::valor;
template <MemberFunction T>
  constexpr auto has_lvalueref_qualifier_v = has_lvalueref_qualifier<T>::valor;
template <MemberFunction T>
  constexpr auto has_rvalueref_qualifier_v = has_rvalueref_qualifier<T>::valor;
template <MemberFunction T>
  constexpr auto is_override_v = is_override<T>::valor;
// 21.12.4.19 Operaciones de SpecialMemberFunction
template <SpecialMemberFunction T> struct is_implicitly_declared;
template <SpecialMemberFunction T> struct is_defaulted;
template <SpecialMemberFunction T>
  constexpr auto is_implicitly_declared_v = is_implicitly_declared<T>::valor;
template <SpecialMemberFunction T>
  constexpr auto is_defaulted_v = is_defaulted<T>::valor;
// 21.12.4.20 Operaciones del constructor
template <Constructor T> struct is_explicit<T>;
// 21.12.4.21 Operaciones del destructor
template <Destructor T> struct is_virtual<T>;
template <Destructor T> struct is_pure_virtual<T>;
// 21.12.4.22 Operaciones ConversionOperator
template <ConversionOperator T> struct is_explicit<T>;
// 21.12.4.23 Operaciones lambda
template <Lambda T> struct get_captures;
template <Lambda T> struct uses_default_copy_capture;
template <Lambda T> struct uses_default_reference_capture;
template <Lambda T> struct is_call_operator_const;
template <Lambda T>
  using get_captures_t = typename get_captures<T>::type;
template <Lambda T>
  constexpr auto uses_default_copy_capture_v = uses_default_copy_capture<T>::valor;
template <Lambda T>
  constexpr auto uses_default_reference_capture_v = uses_default_reference_capture<T>::valor;
template <Lambda T>
  constexpr auto is_call_operator_const_v = is_call_operator_const<T>::valor;
// 21.12.4.24 Operaciones de LambdaCapture
template <LambdaCapture T> struct is_explicitly_captured;
template <LambdaCapture T> struct is_init_capture;
template <LambdaCapture T>
  constexpr auto is_explicitly_captured_v = is_explicitly_captured<T>::valor;
template <LambdaCapture T>
  constexpr auto is_init_capture_v = is_init_capture<T>::valor;
} // inline namespace v1
} // namespace std::experimental::reflect

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants

Experimental library header <experimental/reflect>

Contenidos

Conceptos

Clases

`Object` operaciones

`ObjectSequence` operaciones

`Named` operaciones

`Alias` operaciones

`Type` operaciones

`ScopeMember` operaciones

`Base` operaciones

`RecordMember` y `Base` operaciones

`Record` operaciones

`Enum` operaciones

`Variable` operaciones

`FunctionParameter` operaciones

`Callable` operaciones

`Variable` y `Callable` operaciones

`Namespace` y operaciones `Callable`

`ParenthesizedExpression` operaciones

`FunctionCallExpression` operaciones

`FunctionalTypeConversion` operaciones

`Variable` y `Function` operaciones

`MemberFunction` operaciones

`Record` y `MemberFunction` operaciones

`Variable` y `MemberFunction` operaciones

`SpecialMemberFunction` operaciones

`Constructor` y `ConversionOperator` operaciones

`MemberFunction` y `Destructor` operaciones

`Lambda` operaciones

`LambdaCapture` operaciones

Sinopsis

cppreference.net

Namespaces

Variants

Experimental library header <experimental/reflect>

Contenidos

Conceptos

Clases

Object operaciones

ObjectSequence operaciones

Named operaciones

Alias operaciones

Type operaciones

ScopeMember operaciones

Base operaciones

RecordMember y Base operaciones

Record operaciones

Enum operaciones

Variable operaciones

FunctionParameter operaciones

Callable operaciones

Variable y Callable operaciones

Namespace y operaciones Callable

ParenthesizedExpression operaciones

FunctionCallExpression operaciones

FunctionalTypeConversion operaciones

Variable y Function operaciones

MemberFunction operaciones

Record y MemberFunction operaciones

Variable y MemberFunction operaciones

SpecialMemberFunction operaciones

Constructor y ConversionOperator operaciones

MemberFunction y Destructor operaciones

Lambda operaciones

LambdaCapture operaciones

Sinopsis

`Object` operaciones

`ObjectSequence` operaciones

`Named` operaciones

`Alias` operaciones

`Type` operaciones

`ScopeMember` operaciones

`Base` operaciones

`RecordMember` y `Base` operaciones

`Record` operaciones

`Enum` operaciones

`Variable` operaciones

`FunctionParameter` operaciones

`Callable` operaciones

`Variable` y `Callable` operaciones

`Namespace` y operaciones `Callable`

`ParenthesizedExpression` operaciones

`FunctionCallExpression` operaciones

`FunctionalTypeConversion` operaciones

`Variable` y `Function` operaciones

`MemberFunction` operaciones

`Record` y `MemberFunction` operaciones

`Variable` y `MemberFunction` operaciones

`SpecialMemberFunction` operaciones

`Constructor` y `ConversionOperator` operaciones

`MemberFunction` y `Destructor` operaciones

`Lambda` operaciones

`LambdaCapture` operaciones