Reflection library (since C++26)

 

C++

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

 

Metaprogramming library

Type traits

Compile-time rational arithmetic

Compile-time integer sequences

integer_sequence (C++14)

Compile-time reflection (C++26)

 

Reflection library

Checking string literals is_string_literal Helper types info tuple_size tuple_element is_applicable_type is_nothrow_applicable_type      apply_result variant_size variant_alternative type_order exception Promoting to static storage reflect_constant_string reflect_constant_array define_static_string define_static_array define_static_object Operator representations operators operator_of symbol_of u8symbol_of Names and locations has_identifier identifier_of u8identifier_of display_string_of u8display_string_of source_location_of Reflection queries ➜ Access control context access_context

Member accessibility queries is_accessible has_inaccessible_nonstatic_   data_members has_inaccessible_bases has_inaccessible_subobjects      Scope identification current_function current_class current_namespace Reflection member queries members_of bases_of static_data_members_of nonstatic_data_members_of subobjects_of enumerators_of Annotation reflection annotations_of annotations_of_with_type Value extraction extract Reflection substitution reflection_range can_substitute substitute Expression result reflection reflect_constant reflect_object reflect_function Class definition generation data_member_options data_member_spec is_data_member_spec define_aggregate

Primary type categories is_void_type is_null_pointer_type is_integral_type is_floating_point_type is_array_type is_pointer_type is_lvalue_reference_type is_rvalue_reference_type is_member_object_pointer_type is_member_function_pointer_type      is_enum_type is_union_type is_class_type is_function_type is_reflection_type Composite type categories is_reference_type is_arithmetic_type is_fundamental_type is_object_type is_scalar_type is_compound_type is_member_pointer_type Type properties ➜ Type relations is_same_type is_base_of_type is_virtual_base_of_type is_convertible_type is_nothrow_convertible_type is_layout_compatible_type is_pointer_interconvertible_   base_of_type is_invocable_type is_invocable_r_type is_nothrow_invocable_type is_nothrow_invocable_r_type

Const-volatile modifications remove_const remove_volatile remove_cv add_const add_volatile add_cv Reference modifications remove_reference add_lvalue_reference add_rvalue_reference Sign modifications make_signed make_unsigned Array modifications remove_extent remove_all_extents Pointer modifications remove_pointer add_pointer Other transformations remove_cvref decay common_type common_reference underlying_type invoke_result unwrap_reference unwrap_ref_decay

 

Reflection types and queries

Reflection queries type_of object_of constant_of is_public is_protected is_private is_virtual is_pure_virtual is_override is_final is_deleted is_defaulted is_user_provided is_user_declared is_explicit is_noexcept is_bit_field is_enumerator is_annotation is_const is_volatile is_mutable_member is_lvalue_reference_qualified is_rvalue_reference_qualified has_static_storage_duration has_thread_storage_duration has_automatic_storage_duration      has_internal_linkage has_module_linkage has_external_linkage has_c_language_linkage has_linkage is_complete_type is_enumerable_type is_variable is_type is_namespace is_type_alias is_namespace_alias is_function is_conversion_function is_operator_function is_literal_operator is_special_member_function is_constructor is_default_constructor is_copy_constructor

is_move_constructor is_assignment is_copy_assignment is_move_assignment is_destructor is_function_parameter is_explicit_object_parameter has_default_argument is_vararg_function is_template is_function_template is_variable_template is_class_template is_alias_template is_conversion_function_template      is_operator_function_template is_literal_operator_template is_constructor_template is_concept is_value is_object is_structured_binding is_class_member is_namespace_member is_nonstatic_data_member is_static_member is_base has_default_member_initializer has_parent parent_of dealias has_template_arguments template_of template_arguments_of parameters_of variable_of return_type_of Reflection layout queries member_offset offset_of size_of alignment_of bit_size_of Type properties is_const_type is_volatile_type is_trivially_copyable_type

is_standard_layout_type is_empty_type is_polymorphic_type is_abstract_type is_final_type is_aggregate_type is_structural_type is_signed_type is_unsigned_type is_bounded_array_type is_unbounded_array_type is_scoped_enum_type is_constructible_type is_default_constructible_type is_copy_constructible_type is_move_constructible_type is_assignable_type is_copy_assignable_type is_move_assignable_type is_swappable_with_type is_swappable_type is_destructible_type is_trivially_constructible_type is_trivially_default_constructible_type is_trivially_copy_constructible_type is_trivially_move_constructible_type is_trivially_assignable_type is_trivially_copy_assignable_type is_trivially_move_assignable_type is_trivially_destructible_type is_nothrow_constructible_type is_nothrow_default_constructible_type is_nothrow_copy_constructible_type is_nothrow_move_constructible_type is_nothrow_assignable_type is_nothrow_copy_assignable_type is_nothrow_move_assignable_type is_nothrow_swappable_with_type is_nothrow_swappable_type is_nothrow_destructible_type is_implicit_lifetime_type has_virtual_destructor has_unique_object_representations reference_constructs_from_temporary reference_converts_from_temporary Type property queries rank extent

 

The facilities defined in this section support reflective programming, allowing C++ programs to both observe the structure of the program itself and to generate code that depends on those observations.

Core language

The reflection library works in conjunction with two core language features:

• the reflection operator ^^
• the splice specifiers [: ... :]

Reflection library

Types
Defined in header <meta>
info (C++26)	the type of reflection values (typedef)
meta::exception (C++26)	exception thrown by reflection functions (class)
access_context (C++26)	a context for access checking (class)
data_member_options (C++26)	data member options including name, alignment, and bit width (class)
member_offset (C++26)	the offset of a member or base class relative to its enclosing class (class)
operators (C++26)	constants that identify overloadable operators (enum)
Concepts
Defined in header <meta>
reflection_range (C++26)	specifies a range of reflection values (concept)

Functions
Defined in header <meta>
Promoting compile-time storage into static storage
reflect_constant_string (C++26)	promotes a compile-time string to static storage, returning a reflection representing the static string (function template)
reflect_constant_array (C++26)	promotes compile-time array into static storage, returning a reflection representing the static array (function template)
define_static_string (C++26)	promotes compile-time string to static storage, returning a pointer to the first character of the static string (function template)
define_static_array (C++26)	promotes compile-time array into static storage, returning a span of the static array (function template)
define_static_object (C++26)	promotes compile-time value into static storage, returning a pointer to the static object (function template)
Operator representations
operators (C++26)	constants that identify overloadable operators (enum)
operator_of (C++26)	identifies the operator represented by the reflection (function)
symbol_ofu8symbol_of (C++26)	converts a meta::operators enumerator to its symbolic name (function)
Reflection names and locations
has_identifier (C++26)	checks if reflection represents an entity that has an identifier (function)
identifier_ofu8identifier_of (C++26)	if the reflected entity has an identifier, obtains its name (function)
display_string_ofu8display_string_of (C++26)	obtains a string suitable for identifying the reflected entity (function)
source_location_of (C++26)	obtains the source location of the reflected entity (function)
Reflection queries
type_of (C++26)	determines the type of the reflected entity (function)
object_of (C++26)	obtains a reflection of the object of the reflected variable (function)
constant_of (C++26)	obtains a reflection of the constant value of the reflected entity (function)
is_publicis_protectedis_private (C++26)	checks if reflection represents a public, protected, or private member or base class (function)
is_virtual (C++26)	checks if reflection represents a virtual member function or virtual base class (function)
is_pure_virtual (C++26)	checks if reflection represents a pure virtual member function (function)
is_override (C++26)	checks if reflection represents a member function that overrides another member function (function)
is_final (C++26)	checks if reflection represents a final class or final member function (function)
is_deleted (C++26)	checks if reflection represents a deleted function (function)
is_defaulted (C++26)	checks if reflection represents a defaulted function (function)
is_user_provided (C++26)	checks if reflection represents a user-provided function (function)
is_user_declared (C++26)	checks if reflection represents a user-declared function (function)
is_explicit (C++26)	checks if reflection represents a member function that is declared explicit (function)
is_noexcept (C++26)	checks if reflection represents a noexcept function or function type (function)
is_bit_field (C++26)	checks if reflection represents a bit-field or a data member description of bit-field (function)
is_enumerator (C++26)	checks if reflection represents an enumerator (function)
is_annotation (C++26)	checks if reflection represents an annotation (function)
is_const (C++26)	checks if reflection represents a const type or a function type with const qualifier (function)
is_volatile (C++26)	checks if reflection represents a volatile type or a function type with volatile qualifier (function)
is_mutable_member (C++26)	checks if reflection represents a mutable non-static data member (function)
is_lvalue_reference_qualifiedis_rvalue_reference_qualified (C++26)	checks if the reflected entity is a ref qualified member function (function)
has_static_storage_durationhas_thread_storage_durationhas_automatic_storage_duration (C++26)	checks if the reflected entity has a storage duration (function)
has_internal_linkagehas_module_linkagehas_external_linkagehas_linkage (C++26)	checks if the reflected entity has a linkage (function)
has_c_language_linkage (C++26)	checks if the reflected entity has "C" language linkage (extern "C") (function)
is_complete_type (C++26)	checks if reflection represents a complete type (function)
is_enumerable_type (C++26)	checks if the reflected type has its list of members completely defined (function)
is_variable (C++26)	checks if reflection represents a variable (function)
is_type (C++26)	checks if reflection represents a type (function)
is_namespace (C++26)	checks if reflection represents a namespace (function)
is_type_alias (C++26)	checks if reflection represents a type alias (function)
is_namespace_alias (C++26)	checks if reflection represents a namespace alias (function)
is_function (C++26)	checks if reflection represents a function (function)
is_conversion_function (C++26)	checks if reflection represents a conversion function (function)
is_operator_function (C++26)	checks if reflection represents an operator overload (function)
is_literal_operator (C++26)	checks if reflection represents a user-defined literal operator (function)
is_special_member_function (C++26)	checks if reflection represents a special member function (function)
is_constructoris_default_constructoris_copy_constructoris_move_constructor (C++26)	checks if the reflected entity is a constructor of this kind (function)
is_assignmentis_copy_assignmentis_move_assignment (C++26)	checks if the reflected entity is an assignment operator of this kind (function)
is_destructor (C++26)	checks if the reflected entity is a destructor (function)
is_function_parameter (C++26)	checks if reflection represents a function parameter (function)
is_explicit_object_parameter (C++26)	checks if reflection represents an explicit object parameter (function)
has_default_argument (C++26)	checks if reflected function parameter has a default argument (function)
is_vararg_function (C++26)	checks if reflection represents a function or function type with an ellipsis parameter (function)
is_template (C++26)	checks if reflected entity is a template (function)
is_function_template (C++26)	checks if reflected entity is a function template (function)
is_variable_template (C++26)	checks if reflected entity is a variable template (function)
is_class_template (C++26)	checks if reflected entity is a class template (function)
is_alias_template (C++26)	checks if reflected entity is a alias template (function)
is_conversion_function_template (C++26)	checks if reflected entity is a conversion function template (function)
is_operator_function_template (C++26)	checks if reflected entity is an operator function template (function)
is_literal_operator_template (C++26)	checks if reflected entity is a literal operator template (function)
is_constructor_template (C++26)	checks if reflected entity is a constructor template (function)
is_concept (C++26)	checks if reflection represents a concept (function)
is_value (C++26)	checks if reflection represents a (scalar) value (function)
is_object (C++26)	checks if reflection represents a static object (function)
is_structured_binding (C++26)	checks if reflection represents a structured binding (function)
is_class_member (C++26)	checks if reflection represents a class member (function)
is_namespace_member (C++26)	checks if reflection represents a namespace member (function)
is_nonstatic_data_member (C++26)	checks if reflection represents a non-static data member (function)
is_static_member (C++26)	checks if reflection represents a static class member (function)
is_base (C++26)	checks if reflection represents a direct base class relationship (function)
has_default_member_initializer (C++26)	checks if reflected non-static data member has a default member initializer (function)
has_parent (C++26)	checks if the reflected entity is contained in a scope (function)
parent_of (C++26)	obtains the scope that contains the reflected entity (function)
dealias (C++26)	determines the underlying entity of the reflected type/namespace alias (function)
has_template_arguments (C++26)	checks if reflected entity is produced by substituting template arguments into a template (function)
template_of (C++26)	determines the template used to instantiate the reflected entity (function)
template_arguments_of (C++26)	obtains the template arguments of the reflected entity (function)
parameters_of (C++26)	obtains the parameters of the reflected function (function)
variable_of (C++26)	obtains the variable of the reflected function parameter in the function definition (function)
return_type_of (C++26)	obtains the return type of the reflected function (function)
Accessibility queries
is_accessible (C++26)	checks if a member is accessible in a given context (function)
has_inaccessible_nonstatic_data_members (C++26)	checks if the reflected class has any inaccessible non-static data members (function)
has_inaccessible_bases (C++26)	checks if the reflected class has any inaccessible direct base classes (function)
has_inaccessible_subobjects (C++26)	checks if the reflected class has any inaccessible non-static data members or direct base classes (function)
Scope identification
current_function (C++26)	returns a reflection of the enclosing function (function)
current_class (C++26)	returns a reflection of the enclosing class (function)
current_namespace (C++26)	returns a reflection of the enclosing namespace (function)
Reflection member queries
members_of (C++26)	obtains the accessible direct members of the reflected class or namespace (function)
bases_of (C++26)	obtains the accessible direct bases of the reflected class (function)
static_data_members_of (C++26)	obtains the accessible static data members of the reflected class (function)
nonstatic_data_members_of (C++26)	obtains the accessible non-static data members of the reflected class (function)
subobjects_of (C++26)	obtains the accessible base class subobjects and non-static data members of the reflected class (function)
enumerators_of (C++26)	obtains the enumerators of the reflected enum type (function)
Reflection layout queries
offset_of (C++26)	returns the offset of a (member or base) subobject relative to its enclosing class (function)
size_of (C++26)	returns the size in bytes of the reflected object or type (function)
alignment_of (C++26)	returns the alignment of the reflected object or type (function)
bit_size_of (C++26)	returns the size in bits of the reflected object or type (function)
Annotation reflection
annotations_of (C++26)	obtains the annotations applying to the reflected entity (function)
annotations_of_with_type (C++26)	obtains the annotations that apply to the reflected entity and have the specified type (function)
Value extraction
extract (C++26)	extracts the value of the reflected entity (function template)
Reflection substitution
can_substitute (C++26)	checks whether the reflected arguments can be substituted in the reflected template (function template)
substitute (C++26)	substitutes reflected arguments in the reflected template (function template)
Expression result reflection
reflect_constant (C++26)	returns a reflection representing a value or template parameter object, suitable for use as a constant template argument (function template)
reflect_object (C++26)	returns a reflection representing an object, suitable for use as a constant template argument (function template)
reflect_function (C++26)	returns a reflection representing a function, suitable for use as a constant template argument (function template)
Class definition generation
data_member_spec (C++26)	creates a data member description for use with injected declarations (function)
is_data_member_spec (C++26)	checks if reflection represents a data member description (function)
define_aggregate (C++26)	defines an aggregate type from a sequence of data member descriptions (function template)
Primary type categories
is_void_type (C++26)	checks if reflected type is void (function)
is_null_pointer_type (C++26)	checks if reflected type is std::nullptr_t (function)
is_integral_type (C++26)	checks if reflected type is an integral type (function)
is_floating_point_type (C++26)	checks if reflected type is a floating-point type (function)
is_array_type (C++26)	checks if reflected type is an array type (function)
is_pointer_type (C++26)	checks if reflected type is a pointer type (function)
is_lvalue_reference_type (C++26)	checks if reflection represents an lvalue reference (function)
is_rvalue_reference_type (C++26)	checks if reflection represents an rvalue reference (function)
is_member_object_pointer_type (C++26)	checks if reflection represents a member object pointer type (function)
is_member_function_pointer_type (C++26)	checks if reflection represents a member function pointer type (function)
is_enum_type (C++26)	checks if reflected type is an enumeration type (function)
is_union_type (C++26)	checks if reflected type is a union type (function)
is_class_type (C++26)	checks if reflected type is a non-union class type (function)
is_function_type (C++26)	checks if reflected type is a function type (function)
is_reflection_type (C++26)	checks if reflected type is std::meta::info (function)
Composite type categories
is_reference_type (C++26)	checks if reflection represents either an lvalue reference or rvalue reference (function)
is_arithmetic_type (C++26)	checks if reflection represents an arithmetic type (function)
is_fundamental_type (C++26)	checks if reflection represents a fundamental type (function)
is_object_type (C++26)	checks if reflected type is an object type (function)
is_scalar_type (C++26)	checks if reflected type is a scalar type (function)
is_compound_type (C++26)	checks if reflected type is a compound type (function)
is_member_pointer_type (C++26)	checks if reflection represents a member pointer type (function)
Type properties
is_const_type (C++26)	checks if reflection represents a const-qualified type (function)
is_volatile_type (C++26)	checks if reflection represents a volatile-qualified type (function)
is_trivially_copyable_type (C++26)	checks if reflection represents a trivially copyable type (function)
is_standard_layout_type (C++26)	checks if reflected type is a standard-layout type (function)
is_empty_type (C++26)	checks if reflected type is a class (but not union) type and has no non-static data members (function)
is_polymorphic_type (C++26)	checks if reflected type is a polymorphic class type (function)
is_abstract_type (C++26)	checks if reflected type is an abstract class type (function)
is_final_type (C++26)	checks if reflected type is a final class type (function)
is_aggregate_type (C++26)	checks if reflected type is an aggregate type (function)
is_structural_type (C++26)	checks if reflected type is a structural type (function)
is_signed_type (C++26)	checks if reflection represents a signed arithmetic type (function)
is_unsigned_type (C++26)	checks if reflection represents an unsigned arithmetic type (function)
is_bounded_array_type (C++26)	checks if reflection represents an array type of known bound (function)
is_unbounded_array_type (C++26)	checks if reflection represents an array type of unknown bound (function)
is_scoped_enum_type (C++26)	checks if reflection represents a scoped enumeration type (function)
is_constructible_typeis_trivially_constructible_typeis_nothrow_constructible_type (C++26)	checks if reflected type has a constructor for specific arguments (function template)
is_default_constructible_typeis_trivially_default_constructible_typeis_nothrow_default_constructible_type (C++26)	checks if reflected type has a default constructor (function)
is_copy_constructible_typeis_trivially_copy_constructible_typeis_nothrow_copy_constructible_type (C++26)	checks if reflected type has a copy constructor (function)
is_move_constructible_typeis_trivially_move_constructible_typeis_nothrow_move_constructible_type (C++26)	checks if reflected type can be constructed from an rvalue reference (function)
is_assignable_typeis_trivially_assignable_typeis_nothrow_assignable_type (C++26)	checks if reflected type has an assignment operator for a specific argument (function)
is_copy_assignable_typeis_trivially_copy_assignable_typeis_nothrow_copy_assignable_type (C++26)	checks if reflected type has a copy assignment operator (function)
is_move_assignable_typeis_trivially_move_assignable_typeis_nothrow_move_assignable_type (C++26)	checks if reflected type has a move assignment operator (function)
is_swappable_with_typeis_swappable_typeis_nothrow_swappable_with_typeis_nothrow_swappable_type (C++26)	checks if objects of one reflected type can be swapped with objects of same or different other reflected type (function)
is_destructible_typeis_trivially_destructible_typeis_nothrow_destructible_type (C++26)	checks if reflected type has a non-deleted destructor (function)
is_implicit_lifetime_type (C++26)	checks if reflected type is an implicit-lifetime type (function)
has_virtual_destructor (C++26)	checks if reflected type has a virtual destructor (function)
has_unique_object_representations (C++26)	checks if every bit in reflected type's object representation contributes to its value (function)
reference_constructs_from_temporary (C++26)	checks if a reference is bound to a temporary in direct-initialization (function)
reference_converts_from_temporary (C++26)	checks if a reference is bound to a temporary in copy-initialization (function)
Type property queries
rank (C++26)	obtains the number of dimensions of reflected array type (function)
extent (C++26)	obtains the size of reflected array type along a specified dimension (function)
Type relations
is_same_type (C++26)	checks if two reflections represent the same types (function)
is_base_of_type (C++26)	checks if two reflections represent types such that one type is a base of the other type (function)
is_virtual_base_of_type (C++26)	checks if two reflections represent types such that one type is a virtual base of the other type (function)
is_convertible_typeis_nothrow_convertible_type (C++26)	checks if reflected type can be converted to the other type (function)
is_layout_compatible_type (C++26)	checks if two reflections represent layout-compatible types (function)
is_pointer_interconvertible_base_of_type (C++26)	checks if reflected type is a pointer-interconvertible base of another type (function)
is_invocable_typeis_invocable_r_typeis_nothrow_invocable_typeis_nothrow_invocable_r_type (C++26)	checks if the reflected type can be invoked (as if by std::invoke) with the given argument types (function template)
Const-volatile modifications
remove_cvremove_constremove_volatile (C++26)	removes const and/or volatile specifiers from reflected type (function)
add_cvadd_constadd_volatile (C++26)	adds const and/or volatile specifiers to reflected type (function)
Reference modifications
remove_reference (C++26)	removes a reference from reflected type (function)
add_lvalue_referenceadd_rvalue_reference (C++26)	adds an lvalue or rvalue reference to reflected type (function)
Sign modifications
make_signed (C++26)	obtains the corresponding signed type for reflected integral type (function)
make_unsigned (C++26)	obtains the corresponding unsigned type for reflected integral type (function)
Array modifications
remove_extent (C++26)	removes one extent from reflected array type (function)
remove_all_extents (C++26)	removes all extents from reflected array type (function)
Pointer modifications
remove_pointer (C++26)	removes a pointer from reflected type (function)
add_pointer (C++26)	adds a pointer to reflected type (function)
Other transformations
remove_cvref (C++26)	combines meta::remove_cv and meta::remove_reference (function)
decay (C++26)	applies type transformations as when passing a function argument by value (function)
common_type (C++26)	determines the common type of a sequence of reflected types (function template)
common_reference (C++26)	determines the common reference type of a sequence of reflected types (function template)
underlying_type (C++26)	obtains the underlying integer type for reflected enumeration type (function)
invoke_result (C++26)	deduces the result type of invoking a callable object with a set of arguments (function template)
unwrap_referenceunwrap_ref_decay (C++26)	get the reference type wrapped in std::reference_wrapper (function)
tuple_size (C++26)	obtains the size of reflected tuple (function)
tuple_element (C++26)	obtains the type of the specified element of reflected tuple (function)
is_applicable_typeis_nothrow_applicable_type (C++26)	checks if the callable object can be invoked (as if by std::invoke) with a tuple of arguments (function)
apply_result (C++26)	deduces the result type of invoking a callable object with a tuple of arguments (function)
variant_size (C++26)	obtains the size of reflected variant's list of alternatives (function)
variant_alternative (C++26)	obtains the type of reflected tuple's alternative specified by its index (function)
type_order (C++26)	performs three-way comparison on reflected types (function)
Checking string literals
is_string_literal (C++26)	checks if a pointer points into a string literal (function)

Notes

Feature-test macro	Value	Std	Feature
__cpp_lib_reflection	202506L	(C++26)	<meta>: Reflection library support. Constexpr exceptions as error handling in reflection.