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>

Cet en-tête fait partie du Reflection TS .

Défini dans l'espace de noms


           std::experimental::reflect

Défini dans l'espace de noms en ligne


           std::experimental::reflect::v1

Table des matières

Concepts

Object

(reflection TS)

spécifie qu'un type est un type méta-objet
(concept)

ObjectSequence

(reflection TS)

spécifie qu'un type méta-objet est un type de séquence méta-objet
(concept)

TemplateParameterScope

(reflection TS)

spécifie qu'un type méta-objet reflète une portée de paramètre de modèle
(concept)

Named

(reflection TS)

spécifie qu'un type méta-objet reflète une entité ou un alias avec un nom associé (éventuellement vide)
(concept)

Alias

(reflection TS)

spécifie qu'un type méta-objet reflète un alias de type, un alias d'espace de noms, ou un alias introduit par une déclaration using
(concept)

RecordMember

(reflection TS)

spécifie qu'un type de méta-objet reflète une member-declaration d'une classe
(concept)

Enumerator

(reflection TS)

spécifie qu'un type méta-objet reflète un énumérateur
(concept)

Variable

(reflection TS)

spécifie qu'un type méta-objet reflète une variable ou un membre de données
(concept)

ScopeMember

(reflection TS)

spécifie qu'un type méta-objet satisfait


          RecordMember


          Enumerator

, ou


          Variable

, ou reflète un espace de noms autre que l'espace de noms global
(concept)

Typed

(reflection TS)

spécifie qu'un type méta-objet reflète une entité ayant un type
(concept)

Namespace

(reflection TS)

spécifie qu'un type méta-objet reflète un namespace
(concept)

GlobalScope

(reflection TS)

spécifie qu'un type méta-objet reflète l'espace de noms global
(concept)

Class

(reflection TS)

spécifie qu'un type méta-objet reflète un type classe non-union
(concept)

Enum

(reflection TS)

spécifie qu'un type méta-objet reflète un type énumération
(concept)

Record

(reflection TS)

spécifie qu'un type méta-objet reflète un type classe
(concept)

Scope

(reflection TS)

spécifie qu'un type méta-objet reflète un espace de noms, une classe, une énumération, une fonction, un type de fermeture, ou une portée de paramètre de modèle
(concept)

Type

(reflection TS)

spécifie qu'un type méta-objet reflète un type
(concept)

Constant

(reflection TS)

spécifie qu'un type méta-objet reflète un énumérateur ou une variable constexpr
(concept)

Base

(reflection TS)

spécifie qu'un type méta-objet reflète une classe de base directe obtenue à partir de


          get_base_classes

(concept)

FunctionParameter

(reflection TS)

spécifie qu'un type méta-objet reflète un paramètre de fonction
(concept)

Callable

(reflection TS)

spécifie qu'un type méta-objet reflète une fonction (y compris les constructeurs et destructeurs)
(concept)

Expression

(reflection TS)

spécifie qu'un type méta-objet reflète une expression
(concept)

ParenthesizedExpression

(reflection TS)

spécifie qu'un type méta-objet reflète une expression entre parenthèses
(concept)

FunctionCallExpression

(reflection TS)

spécifie qu'un type méta-objet reflète une function-call-expression
(concept)

FunctionalTypeConversion

(reflection TS)

spécifie qu'un type méta-objet reflète une functional-type-conv-expression
(concept)

Function

(reflection TS)

spécifie qu'un type méta-objet reflète une fonction (à l'exclusion des constructeurs et destructeurs)
(concept)

MemberFunction

(reflection TS)

spécifie qu'un type méta-objet reflète une fonction membre (à l'exclusion des constructeurs et destructeurs)
(concept)

SpecialMemberFunction

(reflection TS)

spécifie qu'un type de méta-objet reflète une fonction membre spéciale
(concept)

Constructor

(reflection TS)

spécifie qu'un type méta-objet reflète un constructeur
(concept)

Destructor

(reflection TS)

spécifie qu'un type méta-objet reflète un destructeur
(concept)

Operator

(reflection TS)

spécifie qu'un type méta-objet reflète une fonction opérateur ou une fonction de conversion
(concept)

ConversionOperator

(reflection TS)

spécifie qu'un type méta-objet reflète une fonction de conversion
(concept)

Lambda

(reflection TS)

spécifie qu'un type méta-objet reflète le type de fermeture d'un lambda non générique
(concept)

LambdaCapture

(reflection TS)

spécifie qu'un type méta-objet reflète une capture lambda
(concept)

Classes

`Object` opérations

reflects_same

(reflection TS)

vérifie si deux types de méta-objets reflètent la même entité ou alias
(modèle de classe)

get_source_line

(reflection TS)

obtient le numéro de ligne présumé de la déclaration de l'entité réfléchie ou de l'alias
(modèle de classe)

get_source_column

(reflection TS)

obtient le numéro de colonne défini par l'implémentation de la déclaration de l'entité réfléchie ou de l'alias
(modèle de classe)

get_source_file_name

(reflection TS)

obtient le nom présumé du fichier de la déclaration de l'entité réfléchie ou de l'alias
(modèle de classe)

`ObjectSequence` opérations

get_size

(reflection TS)

obtient la taille d'une séquence de méta-objets
(modèle de classe)

get_element

(reflection TS)

obtient le type méta-objet avec l'index spécifié dans une séquence
(modèle de classe)

unpack_sequence

(reflection TS)

applique un modèle à la séquence de méta-objets
(modèle de classe)

`Named` opérations

is_unnamed

(reflection TS)

vérifie si l'entité réfléchie ou l'alias est nommé
(modèle de classe)

get_name

(reflection TS)

obtient le nom non qualifié de l'entité réfléchie ou de l'alias
(modèle de classe)

get_display_name

(reflection TS)

obtient le nom d'affichage défini par l'implémentation de l'entité réfléchie ou de l'alias
(modèle de classe)

`Alias` opérations

get_alias

(reflection TS)

obtient le type méta-objet reflétant l'entité associée de l'alias réfléchi
(modèle de classe)

`Type` opérations

get_type

(reflection TS)

obtient le type méta-objet reflétant le type de l'entité ou alias réfléchi
(modèle de classe)

get_reflected_type

(reflection TS)

obtient le type de l'entité réfléchie ou de l'alias
(modèle de classe)

is_enum

(reflection TS)

vérifie si le type méta-objet reflète un type énumération
(modèle de classe)

is_union

(reflection TS)

vérifie si le type méta-objet reflète un type union
(modèle de classe)

uses_class_key uses_struct_key

(reflection TS)

vérifie si le type méta-objet reflète un type classe non-union dont la déclaration utilise class ou struct respectivement
(modèle de classe)

`ScopeMember` opérations

get_scope

(reflection TS)

obtient le type de méta-objet reflétant la portée de l'entité ou alias réfléchi
(modèle de classe)

`Base` opérations

get_class

(reflection TS)

obtient le type de méta-objet reflétant la classe de base dans la relation de classe de base donnée
(modèle de classe)

`RecordMember` et `Base` opérations

is_public

(reflection TS)

vérifie si le membre réfléchi ou la classe de base est public
(modèle de classe)

is_protected

(reflection TS)

vérifie si le membre réfléchi ou la classe de base est protégé
(modèle de classe)

is_private

(reflection TS)

vérifie si le membre réfléchi ou la classe de base est privé
(modèle de classe)

`Record` opérations

get_public_data_members get_accessible_data_members get_data_members

(reflection TS)

obtient un type de séquence de méta-objets dont les éléments reflètent les membres de données publics, accessibles ou tous les membres de données de la classe reflétée
(modèle de classe)

get_public_member_functions get_accessible_member_functions get_member_functions

(reflection TS)

obtient un type de séquence de méta-objets dont les éléments reflètent les fonctions membres publiques, accessibles ou toutes les fonctions membres de la classe reflétée
(modèle de classe)

get_constructors

(reflection TS)

obtient un type de séquence de méta-objets dont les éléments reflètent tous les constructeurs de la classe réfléchie
(modèle de classe)

get_operators

(reflection TS)

obtient un type de séquence de méta-objets dont les éléments reflètent toutes les fonctions opérateur et fonctions de conversion déclarées dans la classe reflétée
(modèle de classe)

get_destructor

(reflection TS)

obtient le type méta-objet reflétant le destructeur de la classe réfléchie
(modèle de classe)

get_public_member_types get_accessible_member_types get_member_types

(reflection TS)

obtient un type de séquence de méta-objets dont les éléments reflètent les types imbriqués publics, accessibles ou tous les typedefs membres de la classe réfléchie
(modèle de classe)

get_public_base_classes get_accessible_base_classes get_base_classes

(reflection TS)

obtient un type de séquence de méta-objets dont les éléments reflètent les classes de base publiques, accessibles ou toutes les classes de base de la classe reflétée
(modèle de classe)

`Enum` opérations

is_scoped_enum

(reflection TS)

vérifie si l'énumération réfléchie est délimitée
(modèle de classe)

get_enumerators

(reflection TS)

obtient un type de séquence de méta-objets dont les éléments reflètent les énumérateurs de l'énumération réfléchie
(modèle de classe)

get_underlying_type

(reflection TS)

obtient le type méta-objet reflétant le type sous-jacent de l'énumération réfléchie
(modèle de classe)

`Variable` opérations

get_constant

(reflection TS)

obtient la valeur de la variable réfléchie qui est une expression constante
(modèle de classe)

is_thread_local

(reflection TS)

vérifie si la variable est déclarée avec thread_local
(modèle de classe)

`FunctionParameter` opérations

has_default_argument

(reflection TS)

vérifie si le paramètre réfléchi possède un argument par défaut
(modèle de classe)

`Callable` opérations

get_parameters

(reflection TS)

obtient un type de séquence de méta-objets dont les éléments reflètent les paramètres de la fonction réfléchie
(modèle de classe)

is_vararg

(reflection TS)

vérifie si la liste de paramètres de la fonction réfléchie contient un paramètre ellipsis
(modèle de classe)

is_noexcept

(reflection TS)

vérifie si la fonction réfléchie est non-lancante
(modèle de classe)

is_deleted

(reflection TS)

vérifie si la fonction réfléchie est supprimée
(modèle de classe)

`Variable` et `Callable` opérations

is_constexpr

(reflection TS)

vérifie si la variable ou fonction réfléchie est constexpr
(modèle de classe)

`Namespace` et opérations `Callable`

is_inline

(reflection TS)

vérifie si l'espace de noms ou la fonction reflété(e) est inline
(modèle de classe)

`ParenthesizedExpression` opérations

get_subexpression

(reflection TS)

obtient le type méta-objet reflétant l'expression non parenthésée de l'expression parenthésée réfléchie
(modèle de classe)

`FunctionCallExpression` opérations

get_callable

(reflection TS)

obtient le type de méta-objet reflétant la fonction dans l'expression function-call-expression réfléchie
(modèle de classe)

`FunctionalTypeConversion` opérations

get_constructor

(reflection TS)

obtient le type de méta-objet reflétant le constructeur dans l'expression functional-type-conv-expression
(modèle de classe)

`Variable` et `Function` opérations

get_pointer

(reflection TS)

obtient l'adresse de la variable ou fonction réfléchie, ou la valeur pointeur-vers-membre vers le membre non statique réfléchi
(modèle de classe)

`MemberFunction` opérations

is_const is_volatile has_lvalueref_qualifier has_rvalueref_qualifier

(reflection TS)

vérifie si la fonction membre réfléchie est déclarée avec const , volatile , & , ou && qualificateur respectivement
(modèle de classe)

is_override

(reflection TS)

vérifie si la fonction membre réfléchie surcharge une fonction membre de la classe de base
(modèle de classe)

`Record` et `MemberFunction` opérations

is_final

(reflection TS)

vérifie si la classe réfléchie ou la fonction membre est marquée avec final
(modèle de classe)

`Variable` et `MemberFunction` opérations

is_static

(reflection TS)

vérifie si la variable réfléchie a une durée de stockage statique, ou si la fonction membre réfléchie est statique
(modèle de classe)

`SpecialMemberFunction` opérations

is_implicitly_declared

(reflection TS)

vérifie si la fonction membre spéciale réfléchie est implicitement déclarée
(modèle de classe)

is_defaulted

(reflection TS)

vérifie si la fonction membre spéciale réfléchie est définie par défaut dans sa première déclaration
(modèle de classe)

`Constructor` et `ConversionOperator` opérations

is_explicit

(reflection TS)

vérifie si le constructeur ou la fonction de conversion réfléchi est déclaré avec explicit
(modèle de classe)

`MemberFunction` et `Destructor` opérations

is_virtual

(reflection TS)

vérifie si la fonction membre réfléchie est virtuelle
(modèle de classe)

is_pure_virtual

(reflection TS)

vérifie si la fonction membre réfléchie est purement virtuelle
(modèle de classe)

`Lambda` opérations

get_captures

(reflection TS)

obtient un type de séquence de méta-objets dont les éléments reflètent les captures du type de fermeture réfléchi
(modèle de classe)

uses_default_copy_capture uses_default_reference_capture

(reflection TS)

vérifie si la capture par défaut de l'expression lambda du type de clôture reflété est

respectivement
(modèle de classe)

is_call_operator_const

(reflection TS)

vérifie si l'


          operator()

du type de fermeture réfléchi est déclaré avec const
(modèle de classe)

`LambdaCapture` opérations

is_explictly_captured

(reflection TS)

vérifie si la capture de lambda réfléchie est explicitement capturée
(modèle de classe)

is_init_capture

(reflection TS)

vérifie si la capture de lambda réfléchie est une init-capture
(modèle de classe)

Synopsis

namespace std::expérimental::reflect {
inline namespace v1 {
// 21.12.3 Concepts pour les types méta-objets
template <class T>
concept Object = /* voir description */;
template <class T>
concept ObjectSequence = /* voir description */; // affine Object
template <class T>
concept TemplateParameterScope = /* voir description */; // affine Portée
template <class T>
concept Named = /* voir description */;          // affine Object
template <class T>
concept Alias = /* voir description */;          // affine Named et ScopeMember
template <class T>
concept RecordMember = /* voir description */;   // affine ScopeMember
template <class T>
concept Enumerator = /* voir description */;     // affine Constant
template <class T>
concept Variable = /* voir description */;       // affine Typed et ScopeMember
template <class T>
concept ScopeMember = /* voir description */;    // affine Named
template <class T>
concept Typed = /* voir description */;          // affine Object
template <class T>
concept Namespace = /* voir description */;      // affine Named et Scope
template <class T>
concept GlobalScope = /* voir description */;    // affine l'Espace de noms
template <class T>
concept Class = /* voir description */;          // affine Record
template <class T>
concept Enum = /* voir description */;           // affine Type, Scope, et ScopeMember
template <class T>
concept Record = /* voir description */;         // affine Type, Scope, et ScopeMember
template <class T>
concept Scope = /* voir description */;          // affine Object
template <class T>
concept Type = /* voir description */;           // affine Named
template <class T>
concept Constant = /* voir description */;       // affine Typed et ScopeMember
template <class T>
concept Base = /* voir description */;           // affine Object
template <class T>
concept FunctionParameter = /* voir description */; // affine Typed et ScopeMember
template <class T>
concept Callable = /* voir description */;       // affine Scope et ScopeMember
template <class T>
concept Expression = /* voir description */;     // affine Object
template <class T>
concept ParenthesizedExpression = /* voir description */; // affine Expression
template <class T>
concept FunctionCallExpression = /* voir description */; // affine Expression
template <class T>
concept FunctionalTypeConversion = /* voir description */; // affine Expression
template <class T>
concept Function = /* voir description */;       // affine Typed et Callable
template <class T>
concept MemberFunction = /* voir description */; // affine RecordMember et Function
template <class T>
concept SpecialMemberFunction = /* voir description */; // affine RecordMember
template <class T>
concept Constructor = /* voir description */;    // affine Callable et RecordMember
template <class T>
concept Destructor = /* voir description */;     // affine Callable et SpecialMemberFunction
template <class T>
concept Operator = /* voir description */;       // affine Function
template <class T>
concept ConversionOperator = /* voir description */; // affine MemberFunction et Operator
template <class T>
concept Lambda = /* voir description */;         // affine Type et Scope
template <class T>
concept LambdaCapture = /* voir description */;  // affine Variable
// 21.12.4 Opérations de méta-objet
// Opérations multi-concepts
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>::value;
template <class T>
requires RecordMember<T> || Base<T>
  constexpr auto is_protected_v = is_protected<T>::value;
template <class T>
requires RecordMember<T> || Base<T>
  constexpr auto is_private_v = is_private<T>::value;
template <class T>
requires Variable<T> || Callable<T>
  constexpr auto is_constexpr_v = is_constexpr<T>::value;
template <class T>
requires Variable<T> || MemberFunction<T>
  constexpr auto is_static_v = is_static<T>::value;
template <class T>
requires Class<T> || MemberFunction<T>
  constexpr auto is_final_v = is_final<T>::value;
template <class T>
requires Constructor<T> || ConversionOperator<T>
  constexpr auto is_explicit_v = is_explicit<T>::value;
template <class T>
requires Namespace<T> || Callable<T>
  constexpr auto is_inline_v = is_inline<T>::value;
template <class T>
requires Base<T> || MemberFunction<T> || Destructor<T>
  constexpr auto is_virtual_v = is_virtual<T>::value;
template <class T>
requires MemberFunction<T> || Destructor<T>
  constexpr auto is_pure_virtual_v = is_pure_virtual<T>::value;
template <class T>
requires Variable<T> || Function<T>
  constexpr auto get_pointer_v = get_pointer<T>::value;
// 21.12.4.1 Opérations sur les objets
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>::value;
template <class T>
  constexpr auto get_source_line_v = get_source_line<T>::value;
template <class T>
  constexpr auto get_source_column_v = get_source_column<T>::value;
template <class T>
  constexpr auto get_source_file_name_v = get_source_file_name<T>::value;
// 21.12.4.2 Opérations 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>::value;
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 Opérations nommées
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>::value;
template <Named T>
  constexpr auto get_name_v = get_name<T>::value;
template <Named T>
  constexpr auto get_display_name_v = get_display_name<T>::value;
// 21.12.4.4 Opérations d'alias
template <Alias T> struct get_aliased;
template <Alias T>
  using get_aliased_t = typename get_aliased<T>::type;
// 21.12.4.5 Opérations sur les types
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>::value;
template <Class T>
  constexpr auto uses_class_key_v = uses_class_key<T>::value;
template <Class T>
  constexpr auto uses_struct_key_v = uses_struct_key<T>::value;
template <Type T>
  constexpr auto is_union_v = is_union<T>::value;
// 21.12.4.6 Opérations des membres
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 Opérations d'enregistrement
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 Opérations d'énumération
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>::value;
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 Opérations sur les valeurs
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>::value;
template <Variable T>
  constexpr auto is_thread_local_v = is_thread_local<T>::value;
// 21.12.4.10 Opérations de 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 Opérations sur les espaces de noms
template <Namespace T> struct is_inline<T>;
// 21.12.4.12 Opérations sur les paramètres de fonction
template <FunctionParameter T> struct has_default_argument;
template <FunctionParameter T>
  constexpr auto has_default_argument_v = has_default_argument<T>::value;
// 21.12.4.13 Opérations appelables
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>::value;
template <Callable T>
  constexpr auto is_deleted_v = is_deleted<T>::value;
// 21.12.4.14 Opérations ParenthesizedExpression
template <ParenthesizedExpression T> struct get_subexpression;
template <ParenthesizedExpression T>
  using get_subexpression_t = typename get_subexpression<T>::type;
// 21.12.4.15 Opérations FunctionCallExpression
template <FunctionCallExpression T> struct get_callable;
template <FunctionCallExpression T>
  using get_callable_t = typename get_callable<T>::type;
// 21.12.4.16 Opérations de conversion de type fonctionnel
template <FunctionalTypeConversion T> struct get_constructor;
template <FunctionalTypeConversion T>
  using get_constructor_t = typename get_constructor<T>::type;
// 21.12.4.17 Opérations de fonction
template <Function T> struct get_pointer<T>;
// 21.12.4.18 Opérations des fonctions membres
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>::value;
template <MemberFunction T>
  constexpr auto is_volatile_v = is_volatile<T>::value;
template <MemberFunction T>
  constexpr auto has_lvalueref_qualifier_v = has_lvalueref_qualifier<T>::value;
template <MemberFunction T>
  constexpr auto has_rvalueref_qualifier_v = has_rvalueref_qualifier<T>::value;
template <MemberFunction T>
  constexpr auto is_override_v = is_override<T>::value;
// 21.12.4.19 Opérations des fonctions membres spéciales
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>::value;
template <SpecialMemberFunction T>
  constexpr auto is_defaulted_v = is_defaulted<T>::value;
// 21.12.4.20 Opérations de constructeur
template <Constructor T> struct is_explicit<T>;
// 21.12.4.21 Opérations du destructeur
template <Destructor T> struct is_virtual<T>;
template <Destructor T> struct is_pure_virtual<T>;
// 21.12.4.22 Opérations ConversionOperator
template <ConversionOperator T> struct is_explicit<T>;
// 21.12.4.23 Opérations 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>::value;
template <Lambda T>
  constexpr auto uses_default_reference_capture_v = uses_default_reference_capture<T>::value;
template <Lambda T>
  constexpr auto is_call_operator_const_v = is_call_operator_const<T>::value;
// 21.12.4.24 Opérations de capture lambda
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>::value;
template <LambdaCapture T>
  constexpr auto is_init_capture_v = is_init_capture<T>::value;
} // espace de noms inline 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>

Table des matières

Concepts

Classes

`Object` opérations

`ObjectSequence` opérations

`Named` opérations

`Alias` opérations

`Type` opérations

`ScopeMember` opérations

`Base` opérations

`RecordMember` et `Base` opérations

`Record` opérations

`Enum` opérations

`Variable` opérations

`FunctionParameter` opérations

`Callable` opérations

`Variable` et `Callable` opérations

`Namespace` et opérations `Callable`

`ParenthesizedExpression` opérations

`FunctionCallExpression` opérations

`FunctionalTypeConversion` opérations

`Variable` et `Function` opérations

`MemberFunction` opérations

`Record` et `MemberFunction` opérations

`Variable` et `MemberFunction` opérations

`SpecialMemberFunction` opérations

`Constructor` et `ConversionOperator` opérations

`MemberFunction` et `Destructor` opérations

`Lambda` opérations

`LambdaCapture` opérations

Synopsis

cppreference.net

Namespaces

Variants

Experimental library header <experimental/reflect>

Table des matières

Concepts

Classes

Object opérations

ObjectSequence opérations

Named opérations

Alias opérations

Type opérations

ScopeMember opérations

Base opérations

RecordMember et Base opérations

Record opérations

Enum opérations

Variable opérations

FunctionParameter opérations

Callable opérations

Variable et Callable opérations

Namespace et opérations Callable

ParenthesizedExpression opérations

FunctionCallExpression opérations

FunctionalTypeConversion opérations

Variable et Function opérations

MemberFunction opérations

Record et MemberFunction opérations

Variable et MemberFunction opérations

SpecialMemberFunction opérations

Constructor et ConversionOperator opérations

MemberFunction et Destructor opérations

Lambda opérations

LambdaCapture opérations

Synopsis

`Object` opérations

`ObjectSequence` opérations

`Named` opérations

`Alias` opérations

`Type` opérations

`ScopeMember` opérations

`Base` opérations

`RecordMember` et `Base` opérations

`Record` opérations

`Enum` opérations

`Variable` opérations

`FunctionParameter` opérations

`Callable` opérations

`Variable` et `Callable` opérations

`Namespace` et opérations `Callable`

`ParenthesizedExpression` opérations

`FunctionCallExpression` opérations

`FunctionalTypeConversion` opérations

`Variable` et `Function` opérations

`MemberFunction` opérations

`Record` et `MemberFunction` opérations

`Variable` et `MemberFunction` opérations

`SpecialMemberFunction` opérations

`Constructor` et `ConversionOperator` opérations

`MemberFunction` et `Destructor` opérations

`Lambda` opérations

`LambdaCapture` opérations