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>

このヘッダーは Reflection TS の一部です。

名前空間


           std::experimental::reflect

で定義

インライン名前空間で定義


           std::experimental::reflect::v1

namespace std::experimental::reflect {
inline namespace v1 {
// 21.12.3 メタオブジェクト型のためのコンセプト
template <class T>
concept Object = /* 詳細は説明を参照 */;
template <class T>
concept ObjectSequence = /* 説明を参照 */; // Objectを改良
template <class T>
concept TemplateParameterScope = /* 説明を参照 */; // Scope を洗練する
template <class T>
concept Named = /* 詳細は説明を参照 */;          // Object を改良
template <class T>
concept Alias = /* 詳細は説明を参照 */;          // Named と ScopeMember を精緻化する
template <class T>
concept RecordMember = /* 説明を参照 */;   // ScopeMemberを精緻化
template <class T>
concept Enumerator = /* 詳細は説明を参照 */;     // Constantを洗練する
template <class T>
concept Variable = /* 詳細は説明を参照 */;       // Typed と ScopeMember を精緻化
template <class T>
concept ScopeMember = /* 詳細は説明を参照 */;    // Named を洗練する
template <class T>
concept Typed = /* 説明を参照 */;          // Objectを改良
template <class T>
concept Namespace = /* 詳細は説明を参照 */;      // Named と Scope を精緻化
template <class T>
concept GlobalScope = /* 詳細は説明を参照 */;    // 名前空間を洗練する
template <class T>
concept Class = /* 説明を参照 */;          // Record を改良
template <class T>
concept Enum = /* 説明を参照 */;           // Type、Scope、および ScopeMember を精緻化
template <class T>
concept Record = /* 説明を参照 */;         // Type、Scope、および ScopeMember を精緻化
template <class T>
concept Scope = /* 説明を参照 */;          // Objectを精緻化
template <class T>
concept Type = /* 詳細は説明を参照 */;           // Named を洗練
template <class T>
concept Constant = /* 説明を参照 */;       // Typed と ScopeMember を改良
template <class T>
concept Base = /* 説明を参照 */;           // Objectを精緻化
template <class T>
concept FunctionParameter = /* 詳細は説明を参照 */; // Typed と ScopeMember を精緻化
template <class T>
concept Callable = /* 詳細は説明を参照 */;       // Scope と ScopeMember を精緻化
template <class T>
concept Expression = /* 説明を参照 */;     // Object を改良
template <class T>
concept ParenthesizedExpression = /* 説明を参照 */; // Expressionを精緻化
template <class T>
concept FunctionCallExpression = /* 説明を参照 */; // Expression を精緻化
template <class T>
concept FunctionalTypeConversion = /* 詳細は説明を参照 */; // Expression を洗練する
template <class T>
concept Function = /* 説明を参照 */;       // Typed と Callable を洗練する
template <class T>
concept MemberFunction = /* 詳細は説明を参照 */; // RecordMember と Function を改良
template <class T>
concept SpecialMemberFunction = /* 説明を参照 */; // RecordMemberを洗練する
template <class T>
concept Constructor = /* 詳細は説明を参照 */;    // Callable と RecordMember を洗練させる
template <class T>
concept Destructor = /* 説明を参照 */;     // Callable と SpecialMemberFunction を洗練する
template <class T>
concept Operator = /* 説明を参照 */;       // Function を洗練する
template <class T>
concept ConversionOperator = /* 詳細は説明を参照 */; // MemberFunction と Operator を改良
template <class T>
concept Lambda = /* 説明を参照 */;         // Type と Scope を洗練する
template <class T>
concept LambdaCapture = /* 説明を参照 */;  // Variable を洗練する
// 21.12.4 メタオブジェクト操作
// マルチコンセプト操作
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 オブジェクト操作
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 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 名前付き操作
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 エイリアス操作
template <Alias T> struct get_aliased;
template <Alias T>
  using get_aliased_t = typename get_aliased<T>::type;
// 21.12.4.5 型操作
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 メンバー操作
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 レコード操作
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 列挙型操作
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 値操作
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 基本操作
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 名前空間操作
template <Namespace T> struct is_inline<T>;
// 21.12.4.12 FunctionParameter 操作
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 Callable operations
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 括弧で囲まれた式の操作
template <ParenthesizedExpression T> struct get_subexpression;
template <ParenthesizedExpression T>
  using get_subexpression_t = typename get_subexpression<T>::type;
// 21.12.4.15 FunctionCallExpression 操作
template <FunctionCallExpression T> struct get_callable;
template <FunctionCallExpression T>
  using get_callable_t = typename get_callable<T>::type;
// 21.12.4.16 FunctionalTypeConversion 操作
template <FunctionalTypeConversion T> struct get_constructor;
template <FunctionalTypeConversion T>
  using get_constructor_t = typename get_constructor<T>::type;
// 21.12.4.17 関数操作
template <Function T> struct get_pointer<T>;
// 21.12.4.18 メンバー関数操作
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 特殊メンバ関数の操作
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 コンストラクタ操作
template <Constructor T> struct is_explicit<T>;
// 21.12.4.21 デストラクタ操作
template <Destructor T> struct is_virtual<T>;
template <Destructor T> struct is_pure_virtual<T>;
// 21.12.4.22 ConversionOperator 操作
template <ConversionOperator T> struct is_explicit<T>;
// 21.12.4.23 ラムダ演算
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 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>::value;
template <LambdaCapture T>
  constexpr auto is_init_capture_v = is_init_capture<T>::value;
} // 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>

目次

コンセプト

クラス

`Object` 操作

`ObjectSequence` 操作

`Named` 操作

`Alias` 操作

`Type` 操作

`ScopeMember` 操作

`Base` operations

`RecordMember` および `Base` 操作

`Record` 操作

`Enum` 操作

`Variable` 操作

`FunctionParameter` 操作

`Callable` 操作

`Variable` および `Callable` 操作

`Namespace` および `Callable` 操作

`ParenthesizedExpression` 操作

`FunctionCallExpression` 操作

`FunctionalTypeConversion` 操作

`Variable` および `Function` 操作

`MemberFunction` 操作

`Record` および `MemberFunction` 操作

`Variable` および `MemberFunction` 操作

`SpecialMemberFunction` 操作

`Constructor` および `ConversionOperator` 操作

`MemberFunction` および `Destructor` 操作

`Lambda` 操作

`LambdaCapture` 操作

概要

cppreference.net

Namespaces

Variants

Experimental library header <experimental/reflect>

目次

コンセプト

クラス

Object 操作

ObjectSequence 操作

Named 操作

Alias 操作

Type 操作

ScopeMember 操作

Base operations

RecordMember および Base 操作

Record 操作

Enum 操作

Variable 操作

FunctionParameter 操作

Callable 操作

Variable および Callable 操作

Namespace および Callable 操作

ParenthesizedExpression 操作

FunctionCallExpression 操作

FunctionalTypeConversion 操作

Variable および Function 操作

MemberFunction 操作

Record および MemberFunction 操作

Variable および MemberFunction 操作

SpecialMemberFunction 操作

Constructor および ConversionOperator 操作

MemberFunction および Destructor 操作

Lambda 操作

LambdaCapture 操作

概要

`Object` 操作

`ObjectSequence` 操作

`Named` 操作

`Alias` 操作

`Type` 操作

`ScopeMember` 操作

`Base` operations

`RecordMember` および `Base` 操作

`Record` 操作

`Enum` 操作

`Variable` 操作

`FunctionParameter` 操作

`Callable` 操作

`Variable` および `Callable` 操作

`Namespace` および `Callable` 操作

`ParenthesizedExpression` 操作

`FunctionCallExpression` 操作

`FunctionalTypeConversion` 操作

`Variable` および `Function` 操作

`MemberFunction` 操作

`Record` および `MemberFunction` 操作

`Variable` および `MemberFunction` 操作

`SpecialMemberFunction` 操作

`Constructor` および `ConversionOperator` 操作

`MemberFunction` および `Destructor` 操作

`Lambda` 操作

`LambdaCapture` 操作