Experimental library header <experimental/reflect>
From cppreference.com
< cpp | header | experimental
C++
Feature test macros (C++20)
Concepts library (C++20)
Metaprogramming library (C++11)
Ranges library (C++20)
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Standard library headers
<compare> (C++20)
<contracts> (C++26)
<coroutine> (C++20)
<cstdint> (C++11)
<source_location> (C++20)
<stdfloat> (C++23)
<version> (C++20)
<concepts> (C++20)
<debugging> (C++26)
<stacktrace> (C++23)
<system_error> (C++11)
<memory_resource> (C++17)
<scoped_allocator> (C++11)
<type_traits> (C++11)
<ratio> (C++11)
<any> (C++17)
<bit> (C++20)
<charconv> (C++17)
<expected> (C++23)
<format> (C++20)
<optional> (C++17)
<stdbit.h> (C++26)
<tuple> (C++11)
<typeindex> (C++11)
<variant> (C++17)
<array> (C++11)
<flat_map> (C++23)
<flat_set> (C++23)
<forward_list> (C++11)
<hive> (C++26)
<mdspan> (C++23)
<span> (C++20)
<unordered_map> (C++11)
<unordered_set> (C++11)
<generator> (C++23)
<ranges> (C++20)
<cuchar> (C++11)
<string_view> (C++17)
<codecvt> (C++11/17/26*)
<regex> (C++11)
<cfenv> (C++11)
<linalg> (C++26)
<numbers> (C++20)
<random> (C++11)
<simd> (C++26)
<stdckdint.h> (C++26)
<chrono> (C++11)
<ccomplex> (C++11/17/20*)
<ciso646> (until C++20)
<cstdalign> (C++11/17/20*)
<cstdbool> (C++11/17/20*)
<ctgmath> (C++11/17/20*)
<cinttypes> (C++11)
<filesystem> (C++17)
<print> (C++23)
<spanstream> (C++23)
<strstream> (C++98/26*)
<syncstream> (C++20)
<atomic> (C++11)
<barrier> (C++20)
<condition_variable> (C++11)
<future> (C++11)
<hazard_pointer> (C++26)
<latch> (C++20)
<mutex> (C++11)
<rcu> (C++26)
<semaphore> (C++20)
<shared_mutex> (C++14)
<stdatomic.h> (C++23)
<stop_token> (C++20)
<thread> (C++11)
<execution> (C++17)
Experimental library headers
Execution P2300
Filesystem TS
Parallelism TS (v1, v2)
experimental/algorithm
experimental/execution_policy
experimental/exception_list
Library Fundamentals TS (v1, v2, v3)
experimental/algorithm
experimental/array
experimental/chrono
experimental/deque
experimental/forward_list
experimental/future
experimental/iterator
experimental/list
experimental/map
experimental/memory
experimental/numeric
experimental/propagate_const
experimental/random
experimental/ratio
experimental/regex
experimental/scope
experimental/set
experimental/source_location
experimental/string
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
Coroutines TS
experimental/coroutine
Networking TS
experimental/buffer
experimental/executor
experimental/internet
experimental/io_context
Reflection TS
<experimental/reflect>
This header is part of the Reflection TS.
Defined in namespace
std::experimental::reflect
Defined in inline namespace
std::experimental::reflect::v1
Contents
- 1 Concepts
- 2 Classes
- 2.1 Object operations
- 2.2 ObjectSequence operations
- 2.3 Named operations
- 2.4 Alias operations
- 2.5 Type operations
- 2.6 ScopeMember operations
- 2.7 Base operations
- 2.8 RecordMember and Base operations
- 2.9 Record operations
- 2.10 Enum operations
- 2.11 Variable operations
- 2.12 FunctionParameter operations
- 2.13 Callable operations
- 2.14 Variable and Callable operations
- 2.15 Namespace and Callable operations
- 2.16 ParenthesizedExpression operations
- 2.17 FunctionCallExpression operations
- 2.18 FunctionalTypeConversion operations
- 2.19 Variable and Function operations
- 2.20 MemberFunction operations
- 2.21 Record and MemberFunction operations
- 2.22 Variable and MemberFunction operations
- 2.23 SpecialMemberFunction operations
- 2.24 Constructor and ConversionOperator operations
- 2.25 MemberFunction and Destructor operations
- 2.26 Lambda operations
- 2.27 LambdaCapture operations
- 3 Synopsis
Concepts
(reflection TS)
(concept)
(reflection TS)
(concept)
(reflection TS)
(concept)
(reflection TS)
(concept)
(reflection TS)
(concept)
(reflection TS)
(concept)
(reflection TS)
RecordMember
, Enumerator
, or Variable
, or reflects a namespace other than the global namespace (concept)
(reflection TS)
(concept)
(reflection TS)
(concept)
(reflection TS)
(concept)
(reflection TS)
get_base_classes
(concept)
(reflection TS)
(concept)
(reflection TS)
(concept)
(reflection TS)
(concept)
(reflection TS)
(concept)
(reflection TS)
(concept)
(reflection TS)
(concept)
(reflection TS)
(concept)
(reflection TS)
(concept)
(reflection TS)
(concept)
(reflection TS)
(concept)
(reflection TS)
(concept)
Classes
Object
operations
(reflection TS)
(class template)
(reflection TS)
(class template)
(reflection TS)
(class template)
(reflection TS)
(class template)
ObjectSequence
operations
(reflection TS)
(class template)
Named
operations
(reflection TS)
(class template)
(reflection TS)
(class template)
Alias
operations
(reflection TS)
(class template)
Type
operations
(reflection TS)
(class template)
(reflection TS)
(class template)
(reflection TS)
(class template)
(reflection TS)
(class template)
ScopeMember
operations
(reflection TS)
(class template)
Base
operations
(reflection TS)
(class template)
RecordMember
and Base
operations
(reflection TS)
(class template)
Record
operations
obtains a meta-object sequence type whose elements reflect public, accessible, or all data members of the reflected class
(class template)
(class template)
obtains a meta-object sequence type whose elements reflect public, accessible, or all member functions of the reflected class
(class template)
(class template)
(reflection TS)
(class template)
(reflection TS)
(class template)
(reflection TS)
(class template)
obtains a meta-object sequence type whose elements reflect public, accessible, or all nested type or member typedefs of the reflected class
(class template)
(class template)
obtains a meta-object sequence type whose elements reflect public, accessible, or all base classes of the reflected class
(class template)
(class template)
Enum
operations
(reflection TS)
(class template)
(reflection TS)
(class template)
Variable
operations
(reflection TS)
(class template)
(reflection TS)
(class template)
FunctionParameter
operations
(reflection TS)
(class template)
Callable
operations
(reflection TS)
(class template)
(reflection TS)
(class template)
Variable
and Callable
operations
(reflection TS)
(class template)
Namespace
and Callable
operations
(reflection TS)
(class template)
ParenthesizedExpression
operations
(reflection TS)
(class template)
FunctionCallExpression
operations
(reflection TS)
(class template)
FunctionalTypeConversion
operations
(reflection TS)
(class template)
Variable
and Function
operations
(reflection TS)
(class template)
MemberFunction
operations
checks if the reflected member function is declared with const, volatile, &, or && qualifier respectively
(class template)
(class template)
(reflection TS)
(class template)
Record
and MemberFunction
operations
(reflection TS)
(class template)
Variable
and MemberFunction
operations
(reflection TS)
(class template)
SpecialMemberFunction
operations
(reflection TS)
(class template)
(reflection TS)
(class template)
Constructor
and ConversionOperator
operations
(reflection TS)
(class template)
MemberFunction
and Destructor
operations
(reflection TS)
(class template)
Lambda
operations
(reflection TS)
(class template)
(reflection TS)
=
or &
respectively (class template)
(reflection TS)
operator()
of the reflected closure type is declared with const (class template)
LambdaCapture
operations
(reflection TS)
(class template)
(reflection TS)
(class template)
[edit] Synopsis
namespace std::experimental::reflect { inline namespace v1 { // 21.12.3 Concepts for meta-object types template <class T> concept Object = /* see description */; template <class T> concept ObjectSequence = /* see description */; // refines Object template <class T> concept TemplateParameterScope = /* see description */; // refines Scope template <class T> concept Named = /* see description */; // refines Object template <class T> concept Alias = /* see description */; // refines Named and ScopeMember template <class T> concept RecordMember = /* see description */; // refines ScopeMember template <class T> concept Enumerator = /* see description */; // refines Constant template <class T> concept Variable = /* see description */; // refines Typed and ScopeMember template <class T> concept ScopeMember = /* see description */; // refines Named template <class T> concept Typed = /* see description */; // refines Object template <class T> concept Namespace = /* see description */; // refines Named and Scope template <class T> concept GlobalScope = /* see description */; // refines Namespace template <class T> concept Class = /* see description */; // refines Record template <class T> concept Enum = /* see description */; // refines Type, Scope, and ScopeMember template <class T> concept Record = /* see description */; // refines Type, Scope, and ScopeMember template <class T> concept Scope = /* see description */; // refines Object template <class T> concept Type = /* see description */; // refines Named template <class T> concept Constant = /* see description */; // refines Typed and ScopeMember template <class T> concept Base = /* see description */; // refines Object template <class T> concept FunctionParameter = /* see description */; // refines Typed and ScopeMember template <class T> concept Callable = /* see description */; // refines Scope and ScopeMember template <class T> concept Expression = /* see description */; // refines Object template <class T> concept ParenthesizedExpression = /* see description */; // refines Expression template <class T> concept FunctionCallExpression = /* see description */; // refines Expression template <class T> concept FunctionalTypeConversion = /* see description */; // refines Expression template <class T> concept Function = /* see description */; // refines Typed and Callable template <class T> concept MemberFunction = /* see description */; // refines RecordMember and Function template <class T> concept SpecialMemberFunction = /* see description */; // refines RecordMember template <class T> concept Constructor = /* see description */; // refines Callable and RecordMember template <class T> concept Destructor = /* see description */; // refines Callable and SpecialMemberFunction template <class T> concept Operator = /* see description */; // refines Function template <class T> concept ConversionOperator = /* see description */; // refines MemberFunction and Operator template <class T> concept Lambda = /* see description */; // refines Type and Scope template <class T> concept LambdaCapture = /* see description */; // refines Variable // 21.12.4 Meta-object operations // Multi-concept operations 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 Object operations 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 operations 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 Named operations 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 Alias operations template <Alias T> struct get_aliased; template <Alias T> using get_aliased_t = typename get_aliased<T>::type; // 21.12.4.5 Type operations 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 Member operations 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 Record operations 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 Enum operations 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 Value operations 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 Base operations 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 Namespace operations template <Namespace T> struct is_inline<T>; // 21.12.4.12 FunctionParameter operations 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 ParenthesizedExpression operations template <ParenthesizedExpression T> struct get_subexpression; template <ParenthesizedExpression T> using get_subexpression_t = typename get_subexpression<T>::type; // 21.12.4.15 FunctionCallExpression operations template <FunctionCallExpression T> struct get_callable; template <FunctionCallExpression T> using get_callable_t = typename get_callable<T>::type; // 21.12.4.16 FunctionalTypeConversion operations template <FunctionalTypeConversion T> struct get_constructor; template <FunctionalTypeConversion T> using get_constructor_t = typename get_constructor<T>::type; // 21.12.4.17 Function operations template <Function T> struct get_pointer<T>; // 21.12.4.18 MemberFunction operations 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 SpecialMemberFunction operations 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 Constructor operations template <Constructor T> struct is_explicit<T>; // 21.12.4.21 Destructor operations template <Destructor T> struct is_virtual<T>; template <Destructor T> struct is_pure_virtual<T>; // 21.12.4.22 ConversionOperator operations template <ConversionOperator T> struct is_explicit<T>; // 21.12.4.23 Lambda operations 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 operations 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