命名空间
变体
操作

实验库头文件 <experimental/reflect>

来自 cppreference.com
< cpp‎ | header‎ | experimental
 
C++
 
标准库头文件
语言支持
概念
<concepts> (C++20)
诊断
<system_error> (C++11)

内存管理
<memory_resource> (C++17)  
元编程
<type_traits> (C++11)
<ratio> (C++11)
通用工具
<utility>
<tuple> (C++11)
<optional> (C++17)
<variant> (C++17)
<any> (C++17)
<debugging> (C++26)
<expected> (C++23)
<bitset>
<charconv> (C++17)
<format> (C++20)
<bit> (C++20)

字符串
<cuchar> (C++11)

容器
<flat_set> (C++23)
<span> (C++20)
<mdspan> (C++23)
<inplace_vector> (C++26)
迭代器
<iterator>
范围
<ranges> (C++20)
<generator> (C++23)
算法
数值
<cfenv> (C++11)
<complex>
<cmath>
<linalg> (C++26)
<numbers> (C++20)

时间
<chrono> (C++11)
本地化
<codecvt> (C++11/17/26*)
<text_encoding> (C++26)
输入/输出
<filesystem> (C++17)
<cstdio>
<cinttypes> (C++11)
<strstream> (C++98/26*)
正则表达式
<regex> (C++11)
并发支持
<stop_token> (C++20)
<thread> (C++11)
<atomic> (C++11)
<rcu> (C++26)
<stdatomic.h> (C++23)
<mutex> (C++11)
<shared_mutex> (C++14)

<condition_variable> (C++11)  
<semaphore> (C++20)
<latch> (C++20)

<barrier> (C++20)
<future> (C++11)
<hazard_pointer> (C++26)

C 兼容性
<cstdbool> (C++11/17/20*)  
<ccomplex> (C++11/17/20*)
<ctgmath> (C++11/17/20*)

<cstdalign> (C++11/17/20*)

<ciso646> (直到 C++20)

 
实验库头文件
执行 P2300
<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
协程 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 中

内容

概念

(反射 TS)
 指定一个类型是元对象类型
(概念)
(反射 TS)
 指定元对象类型是元对象序列类型
(概念)
(反射 TS)
 指定元对象类型反映了模板参数范围
(概念)
(反射 TS)
 指定元对象类型反映了具有关联（可能为空）名称的实体或别名
(概念)
(反射 TS)
 指定元对象类型反映了类型别名、命名空间别名或由 using 声明引入的别名
(概念)
(反射 TS)
 指定元对象类型反映了类的 成员声明
(概念)
(反射 TS)
 指定元对象类型反映了枚举成员
(概念)
(反射 TS)
 指定元对象类型反映了变量或数据成员
(概念)
(反射 TS)
 指定元对象类型满足 RecordMember、Enumerator 或 Variable，或者反映了除全局命名空间之外的命名空间
(概念)
(反射 TS)
 指定元对象类型反映了具有类型的实体
(概念)
(反射 TS)
 指定元对象类型反映了命名空间
(概念)
(反射 TS)
 指定元对象类型反映了全局命名空间
(概念)
(反射 TS)
 指定元对象类型反映了非联合类类型
(概念)
(反射 TS)
 指定元对象类型反映了枚举类型
(概念)
(反射 TS)
 指定元对象类型反映了类类型
(概念)
(反射 TS)
 指定元对象类型反映了命名空间、类、枚举、函数、闭包类型、模板参数范围
(概念)
(反射 TS)
 指定元对象类型反映了类型
(概念)
(反射 TS)
 指定元对象类型反映了枚举成员或 constexpr 变量
(概念)
(反射 TS)
 指定元对象类型反映了从 get_base_classes 获得的直接基类
(概念)
(反射 TS)
 指定元对象类型反映了函数参数
(概念)
(反射 TS)
 指定元对象类型反映了函数（包括构造函数和析构函数）
(概念)
(反射 TS)
 指定元对象类型反映了表达式
(概念)
(反射 TS)
 指定元对象类型反映了带括号的表达式
(概念)
(反射 TS)
 指定元对象类型反映了 函数调用表达式
(概念)
(反射 TS)
 指定元对象类型反映了 函数类型转换表达式
(概念)
(反射 TS)
 指定元对象类型反映了函数（不包括构造函数和析构函数）
(概念)
(反射 TS)
 指定元对象类型反映了成员函数（不包括构造函数和析构函数）
(概念)
(反射 TS)
 指定元对象类型反映了特殊成员函数
(概念)
(反射 TS)
 指定元对象类型反映了构造函数
(概念)
(反射 TS)
 指定元对象类型反映了析构函数
(概念)
(反射 TS)
 指定元对象类型反映了运算符函数或转换函数
(概念)
(反射 TS)
 指定元对象类型反映了转换函数
(概念)
(反射 TS)
 指定元对象类型反映了非泛型 lambda 的闭包类型
(概念)
(反射 TS)
 指定元对象类型反映了 lambda 捕获
(概念)

类

对象 操作
(反射 TS)
 检查两个元对象类型是否反映了相同的实体或别名
(类模板)
(反射 TS)
 获取反映的实体或别名的声明的假定行号
(类模板)
(反射 TS)
 获取反映的实体或别名的声明的实现定义列号
(类模板)
(反射 TS)
 获取反映的实体或别名的声明的假定文件名
(类模板)
对象序列 操作
(反射 TS)
 获取元对象序列的大小
(类模板)
(反射 TS)
 获取序列中指定索引的元对象类型
(类模板)
(反射 TS)
 将模板应用于元对象序列
(类模板)
命名 操作
(反射 TS)
 检查反映的实体或别名是否已命名
(类模板)
(反射 TS)
 获取反映的实体或别名的非限定名称
(类模板)
(反射 TS)
 获取反映的实体或别名的实现定义显示名称
(类模板)
别名 操作
(反射 TS)
 获取反映与反映的别名关联的实体的元对象类型
(类模板)
类型 操作
(反射 TS)
 获取反映反映的实体或别名的类型的元对象类型
(类模板)
(反射 TS)
 获取反映的实体或别名的类型
(类模板)
(反射 TS)
 检查元对象类型是否反映了枚举类型
(类模板)
(反射 TS)
 检查元对象类型是否反映了联合类型
(类模板)
(反射 TS)
 检查元对象类型是否反映了非联合类类型，其声明分别使用 class 或 struct
(类模板)
范围成员 操作
(反射 TS)
 获取反映反映的实体或别名的范围的元对象类型
(类模板)
基类 操作
(反射 TS)
 获取反映给定基类关系中的基类的元对象类型
(类模板)
记录成员 和 基类 操作
(反射 TS)
 检查反映的成员或基类是否为公有
(类模板)
(反射 TS)
 检查反映的成员或基类是否为保护
(类模板)
(反射 TS)
 检查反映的成员或基类是否为私有
(类模板)
记录 操作
(反射 TS)
 获取元对象序列类型，其元素反映反映的类的公有、可访问或所有数据成员
(类模板)
(反射 TS)
 获取元对象序列类型，其元素反映反映的类的公有、可访问或所有成员函数
(类模板)
(反射 TS)
 获取元对象序列类型，其元素反映反映的类所有构造函数
(类模板)
(反射 TS)
 获取元对象序列类型，其元素反映在反映的类中声明的所有运算符函数和转换函数
(类模板)
(反射 TS)
 获取反映反映的类析构函数的元对象类型
(类模板)
(反射 TS)
 获取元对象序列类型，其元素反映反映的类的公有、可访问或所有嵌套类型或成员类型定义
(类模板)
(反射 TS)
 获取元对象序列类型，其元素反映反映的类的公有、可访问或所有基类
(类模板)
枚举 操作
(反射 TS)
 检查反映的枚举是否为作用域枚举
(类模板)
(反射 TS)
 获取元对象序列类型，其元素反映反映的枚举的枚举成员
(类模板)
(反射 TS)
 获取反映反映的枚举的底层类型的元对象类型
(类模板)
变量 操作
(反射 TS)
 获取反映的变量的值，该变量是一个常量表达式
(类模板)
(反射 TS)
 检查变量是否使用 thread_local 声明
(类模板)
函数参数 操作
(反射 TS)
 检查反映的参数是否具有默认参数
(类模板)
可调用 操作
(反射 TS)
 获取元对象序列类型，其元素反映反映的函数的参数
(类模板)
(反射 TS)
 检查反映的函数的参数列表是否包含省略号参数
(类模板)
(反射 TS)
 检查反映的函数是否是非抛出函数
(类模板)
(反射 TS)
 检查反射函数是否已删除
(类模板)
Variable 和 Callable 操作
(反射 TS)
 检查反射变量或函数是否为 constexpr
(类模板)
Namespace 和 Callable 操作
(反射 TS)
 检查反射命名空间或函数是否为内联
(类模板)
ParenthesizedExpression 操作
(反射 TS)
 获取反映反射括号表达式中未加括号表达式的元对象类型
(类模板)
FunctionCallExpression 操作
(反射 TS)
 获取反映反射函数调用表达式中函数的元对象类型
(类模板)
FunctionalTypeConversion 操作
(反射 TS)
 获取反映反射函数类型转换表达式中构造函数的元对象类型
(类模板)
Variable 和 Function 操作
(反射 TS)
 获取反射变量或函数的地址，或反射非静态成员的指向成员的值
(类模板)
MemberFunction 操作
(反射 TS)
 分别检查反射成员函数是否用 const，volatile，& 或 && 限定符声明
(类模板)
(反射 TS)
 检查反射成员函数是否重写基类的成员函数
(类模板)
Record 和 MemberFunction 操作
(反射 TS)
 检查反射类或成员函数是否用 final 标记
(类模板)
Variable 和 MemberFunction 操作
(反射 TS)
 检查反射变量是否为静态存储期限，或反射成员函数是否为静态
(类模板)
SpecialMemberFunction 操作
(反射 TS)
 检查反射特殊成员函数是否为隐式声明
(类模板)
(反射 TS)
 检查反射特殊成员函数在其第一个声明中是否为默认
(类模板)
Constructor 和 ConversionOperator 操作
(反射 TS)
 检查反射构造函数或转换函数是否用 explicit 声明
(类模板)
MemberFunction 和 Destructor 操作
(反射 TS)
 检查反射成员函数是否为虚函数
(类模板)
(反射 TS)
 检查反射成员函数是否为纯虚函数
(类模板)
Lambda 操作
(反射 TS)
 获取一个元对象序列类型，其元素反映反射闭包类型的捕获
(类模板)
(反射 TS)
 分别检查反射闭包类型中 lambda 表达式的捕获默认值是否为 = 或 &
(类模板)
(反射 TS)
 检查反射闭包类型中 operator() 是否用 const 声明
(类模板)
LambdaCapture 操作
(反射 TS)
 检查反射 lambda 捕获是否为显式捕获
(类模板)
(反射 TS)
 检查反射 lambda 捕获是否为初始化捕获
(类模板)

[edit] 提要

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
检索自 "https://cppreference.cn/mwiki/index.php?title=cpp/header/experimental/reflect&oldid=148848"