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::실험적::reflect {
inline namespace v1 {
// 21.12.3 메타 객체 타입을 위한 Concepts
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 호출 가능 연산
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 ParenthesizedExpression 연산
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` operations

`ObjectSequence` 연산

`Named` 연산

`Alias` operations

`Type` 타입 연산

`ScopeMember` operations

`Base` operations

`RecordMember` 및 `Base` 연산

`Record` 연산

`Enum` 연산

`Variable` 변수 연산

`FunctionParameter` 연산

`Callable` operations

`Variable` 및 `Callable` 연산

`Namespace` 및 `Callable` 연산

`ParenthesizedExpression` 연산

`FunctionCallExpression` 연산

`FunctionalTypeConversion` 연산

`Variable` and `Function` operations

`MemberFunction` 연산

`Record` 및 `MemberFunction` 연산

`Variable` 와 `MemberFunction` 연산

`SpecialMemberFunction` 연산

`Constructor` 및 `ConversionOperator` 연산

`MemberFunction` 및 `Destructor` 연산

`Lambda` operations

`LambdaCapture` 연산

시놉시스

cppreference.net

Namespaces

Variants

Experimental library header <experimental/reflect>

목차

개념

클래스

Object operations

ObjectSequence 연산

Named 연산

Alias operations

Type 타입 연산

ScopeMember operations

Base operations

RecordMember 및 Base 연산

Record 연산

Enum 연산

Variable 변수 연산

FunctionParameter 연산

Callable operations

Variable 및 Callable 연산

Namespace 및 Callable 연산

ParenthesizedExpression 연산

FunctionCallExpression 연산

FunctionalTypeConversion 연산

Variable and Function operations

MemberFunction 연산

Record 및 MemberFunction 연산

Variable 와 MemberFunction 연산

SpecialMemberFunction 연산

Constructor 및 ConversionOperator 연산

MemberFunction 및 Destructor 연산

Lambda operations

LambdaCapture 연산

시놉시스

`Object` operations

`ObjectSequence` 연산

`Named` 연산

`Alias` operations

`Type` 타입 연산

`ScopeMember` operations

`Base` operations

`RecordMember` 및 `Base` 연산

`Record` 연산

`Enum` 연산

`Variable` 변수 연산

`FunctionParameter` 연산

`Callable` operations

`Variable` 및 `Callable` 연산

`Namespace` 및 `Callable` 연산

`ParenthesizedExpression` 연산

`FunctionCallExpression` 연산

`FunctionalTypeConversion` 연산

`Variable` and `Function` operations

`MemberFunction` 연산

`Record` 및 `MemberFunction` 연산

`Variable` 와 `MemberFunction` 연산

`SpecialMemberFunction` 연산

`Constructor` 및 `ConversionOperator` 연산

`MemberFunction` 및 `Destructor` 연산

`Lambda` operations

`LambdaCapture` 연산