实验库头文件 <experimental/reflect>

<experimental/execution>

文件系统 TS

<experimental/filesystem>

并行 TS (v1, v2)

`experimental/algorithm`
`experimental/execution_policy`
`experimental/exception_list`

`experimental/numeric`
`<experimental/simd>`
`experimental/task_block`

库基础 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`

并发 TS

`experimental/atomic`
`experimental/barrier`

`experimental/future`
`experimental/latch`

范围 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>`

协程 TS

experimental/coroutine

网络 TS

`experimental/buffer`
`experimental/executor`
`experimental/internet`
`experimental/io_context`

`<experimental/net>`
`experimental/netfwd`
`experimental/socket`
`experimental/timer`

反射 TS

<experimental/reflect>

[编辑]

此头文件是反射 TS 的一部分。

定义于命名空间 std::experimental::reflect

定义于内联命名空间 std::experimental::reflect::v1

概念

Object

(反射 TS)

指定类型为元对象类型
(概念)

ObjectSequence

(反射 TS)

指定元对象类型为元对象序列类型
(概念)

TemplateParameterScope

(反射 TS)

指定元对象类型反映模板参数作用域
(概念)

Named

(反射 TS)

指定元对象类型反映具有关联名称（可能为空）的实体或别名
(概念)

Alias

(反射 TS)

指定元对象类型反映类型别名、命名空间别名或使用声明引入的别名
(概念)

RecordMember

(反射 TS)

指定元对象类型反映类的 member-declaration
(概念)

Enumerator

(反射 TS)

指定元对象类型反映枚举器
(概念)

Variable

(反射 TS)

指定元对象类型反映变量或数据成员
(概念)

ScopeMember

(反射 TS)

指定元对象类型满足 RecordMember、Enumerator 或 Variable，或反映全局命名空间以外的命名空间
(概念)

Typed

(反射 TS)

指定元对象类型反映具有类型的实体
(概念)

Namespace

(反射 TS)

指定元对象类型反映命名空间
(概念)

GlobalScope

(反射 TS)

指定元对象类型反映全局命名空间
(概念)

Class

(反射 TS)

指定元对象类型反映非联合类类型
(概念)

Enum

(反射 TS)

指定元对象类型反映枚举类型
(概念)

Record

(反射 TS)

指定元对象类型反映类类型
(概念)

Scope

(反射 TS)

指定元对象类型反映命名空间、类、枚举、函数、闭包类型、模板参数作用域
(概念)

Type

(反射 TS)

指定元对象类型反映类型
(概念)

Constant

(反射 TS)

指定元对象类型反映枚举器或 constexpr 变量
(概念)

Base

(反射 TS)

指定元对象类型反映从 get_base_classes 获取的直接基类
(概念)

FunctionParameter

(反射 TS)

指定元对象类型反映函数参数
(概念)

Callable

(反射 TS)

指定元对象类型反映函数（包括构造函数和析构函数）
(概念)

Expression

(反射 TS)

指定元对象类型反映表达式
(概念)

ParenthesizedExpression

(反射 TS)

指定元对象类型反映带括号的表达式
(概念)

FunctionCallExpression

(反射 TS)

指定元对象类型反映 function-call-expression
(概念)

FunctionalTypeConversion

(反射 TS)

指定元对象类型反映 functional-type-conv-expression
(概念)

Function

(反射 TS)

指定元对象类型反映函数（不包括构造函数和析构函数）
(概念)

MemberFunction

(反射 TS)

指定元对象类型反映成员函数（不包括构造函数和析构函数）
(概念)

SpecialMemberFunction

(反射 TS)

指定元对象类型反映特殊成员函数
(概念)

Constructor

(反射 TS)

指定元对象类型反映构造函数
(概念)

Destructor

(反射 TS)

指定元对象类型反映析构函数
(概念)

Operator

(反射 TS)

指定元对象类型反映运算符函数或转换函数
(概念)

ConversionOperator

(反射 TS)

指定元对象类型反映转换函数
(概念)

Lambda

(反射 TS)

指定元对象类型反映非泛型 lambda 的闭包类型
(概念)

LambdaCapture

(反射 TS)

指定元对象类型反映 lambda 捕获
(概念)

类

`Object` 操作

reflects_same

(反射 TS)

检查两个元对象类型是否反映相同的实体或别名
(类模板)

get_source_line

(反射 TS)

获取反映的实体或别名的声明的假定行号
(类模板)

get_source_column

(反射 TS)

获取反映的实体或别名的声明的实现定义的列号
(类模板)

get_source_file_name

(反射 TS)

获取反映的实体或别名的声明的假定文件名
(类模板)

`ObjectSequence` 操作

get_size

(反射 TS)

获取元对象序列的大小
(类模板)

get_element

(反射 TS)

获取序列中具有指定索引的元对象类型
(类模板)

unpack_sequence

(反射 TS)

将模板应用于元对象序列
(类模板)

`Named` 操作

is_unnamed

(反射 TS)

检查反映的实体或别名是否已命名
(类模板)

get_name

(反射 TS)

获取反映的实体或别名的非限定名称
(类模板)

get_display_name

(反射 TS)

获取反映的实体或别名的实现定义的显示名称
(类模板)

`Alias` 操作

get_alias

(反射 TS)

获取反映的别名的关联实体的元对象类型
(类模板)

`Type` 操作

get_type

(反射 TS)

获取反映的实体或别名的类型的元对象类型
(类模板)

get_reflected_type

(反射 TS)

获取反映的实体或别名的类型
(类模板)

is_enum

(反射 TS)

检查元对象类型是否反映枚举类型
(类模板)

is_union

(反射 TS)

检查元对象类型是否反映联合类型
(类模板)

uses_class_keyuses_struct_key

(反射 TS)

检查元对象类型是否反映非联合类类型，其声明分别使用 class 或 struct
(类模板)

`ScopeMember` 操作

get_scope

(反射 TS)

获取反映的实体或别名的作用域的元对象类型
(类模板)

`Base` 操作

get_class

(反射 TS)

获取反映给定基类关系中基类的元对象类型
(类模板)

`RecordMember` 和 `Base` 操作

is_public

(反射 TS)

检查反映的成员或基类是否为公有的
(类模板)

is_protected

(反射 TS)

检查反映的成员或基类是否为受保护的
(类模板)

is_private

(反射 TS)

检查反映的成员或基类是否为私有的
(类模板)

`Record` 操作

get_public_data_membersget_accessible_data_membersget_data_members

(反射 TS)

获取元对象序列类型，其元素反映所反映类的公有、可访问或所有数据成员
(类模板)

get_public_member_functionsget_accessible_member_functionsget_member_functions

(反射 TS)

获取元对象序列类型，其元素反映所反映类的公有、可访问或所有成员函数
(类模板)

get_constructors

(反射 TS)

获取元对象序列类型，其元素反映所反映类的所有构造函数
(类模板)

get_operators

(反射 TS)

获取元对象序列类型，其元素反映所反映类中声明的所有运算符函数和转换函数
(类模板)

get_destructor

(反射 TS)

获取反映的类的析构函数的元对象类型
(类模板)

get_public_member_typesget_accessible_member_typesget_member_types

(反射 TS)

获取元对象序列类型，其元素反映所反映类的公有、可访问或所有嵌套类型或成员 typedef
(类模板)

get_public_base_classesget_accessible_base_classesget_base_classes

(反射 TS)

获取元对象序列类型，其元素反映所反映类的公有、可访问或所有基类
(类模板)

`Enum` 操作

is_scoped_enum

(反射 TS)

检查反映的枚举是否为作用域枚举
(类模板)

get_enumerators

(反射 TS)

获取元对象序列类型，其元素反映所反映枚举的枚举器
(类模板)

get_underlying_type

(反射 TS)

获取元对象类型，其反映所反映枚举的底层类型
(类模板)

`Variable` 操作

get_constant

(反射 TS)

获取反映的变量的值，该值是常量表达式
(类模板)

is_thread_local

(反射 TS)

检查变量是否使用 thread_local 声明
(类模板)

`FunctionParameter` 操作

has_default_argument

(反射 TS)

检查反映的参数是否具有默认实参
(类模板)

`Callable` 操作

get_parameters

(反射 TS)

获取元对象序列类型，其元素反映所反映函数的参数
(类模板)

is_vararg

(反射 TS)

检查反映的函数的参数列表是否包含省略号参数
(类模板)

is_noexcept

(反射 TS)

检查反映的函数是否为非抛出
(类模板)

is_deleted

(反射 TS)

检查反映的函数是否已删除
(类模板)

`Variable` 和 `Callable` 操作

is_constexpr

(反射 TS)

检查反映的变量或函数是否为 constexpr
(类模板)

`Namespace` 和 `Callable` 操作

is_inline

(反射 TS)

检查反映的命名空间或函数是否为内联
(类模板)

`ParenthesizedExpression` 操作

get_subexpression

(反射 TS)

获取元对象类型，其反映所反映的带括号的表达式的未加括号的表达式
(类模板)

`FunctionCallExpression` 操作

get_callable

(反射 TS)

获取元对象类型，其反映所反映的 function-call-expression 中的函数
(类模板)

`FunctionalTypeConversion` 操作

get_constructor

(反射 TS)

获取元对象类型，其反映所反映的 functional-type-conv-expression 中的构造函数
(类模板)

`Variable` 和 `Function` 操作

get_pointer

(反射 TS)

获取反映的变量或函数的地址，或指向反映的非静态成员的成员指针值
(类模板)

`MemberFunction` 操作

is_constis_volatilehas_lvalueref_qualifierhas_rvalueref_qualifier

(反射 TS)

检查反映的成员函数是否分别使用 const、volatile、& 或 && 限定符声明
(类模板)

is_override

(反射 TS)

检查反映的成员函数是否覆盖基类的成员函数
(类模板)

`Record` 和 `MemberFunction` 操作

is_final

(反射 TS)

检查反映的类或成员函数是否用 final 标记
(类模板)

`Variable` 和 `MemberFunction` 操作

is_static

(反射 TS)

检查反映的变量是否具有静态存储持续时间，或者反映的成员函数是否为静态
(类模板)

`SpecialMemberFunction` 操作

is_implicitly_declared

(反射 TS)

检查反映的特殊成员函数是否为隐式声明
(类模板)

is_defaulted

(反射 TS)

检查反映的特殊成员函数是否在其首次声明中被默认化
(类模板)

`Constructor` 和 `ConversionOperator` 操作

is_explicit

(反射 TS)

检查反映的构造函数或转换函数是否使用 explicit 声明
(类模板)

`MemberFunction` 和 `Destructor` 操作

is_virtual

(反射 TS)

检查反映的成员函数是否为虚函数
(类模板)

is_pure_virtual

(反射 TS)

检查反映的成员函数是否为纯虚函数
(类模板)

`Lambda` 操作

get_captures

(反射 TS)

获取元对象序列类型，其元素反映所反映闭包类型的捕获
(类模板)

uses_default_copy_captureuses_default_reference_capture

(反射 TS)

检查所反映闭包类型的 lambda 表达式的 capture-default 是否分别为 = 或 &
(类模板)

is_call_operator_const

(反射 TS)

检查所反映闭包类型的 operator() 是否使用 const 声明
(类模板)

`LambdaCapture` 操作

is_explictly_captured

(反射 TS)

检查反映的 lambda 捕获是否为显式捕获
(类模板)

is_init_capture

(反射 TS)

检查反映的 lambda 捕获是否为 init-capture
(类模板)

[编辑] 概要

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

编译器支持
自由和宿主式
语言
标准库
标准库头文件
命名要求
特性测试宏 (C++20)
语言支持库
概念库 (C++20)
诊断库
内存管理库
元编程库 (C++11)
通用工具库
容器库
迭代器库
范围库 (C++20)
算法库
字符串库
文本处理库
数值库
日期和时间库
输入/输出库
文件系统库 (C++17)
并发支持库 (C++11)
执行控制库 (C++26)
技术规范
符号索引
外部库

cppreference.cn

命名空间

变体

视图

操作

实验库头文件 <experimental/reflect>

目录

概念

类

`Object` 操作

`ObjectSequence` 操作

`Named` 操作

`Alias` 操作

`Type` 操作

`ScopeMember` 操作

`Base` 操作

`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.cn

命名空间

变体

视图

操作

实验库头文件 <experimental/reflect>

目录

概念

类

Object 操作

ObjectSequence 操作

Named 操作

Alias 操作

Type 操作

ScopeMember 操作

Base 操作

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` 操作

`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` 操作