实验性库头文件 <experimental/reflect>

出自cppreference.com
< cpp‎ | header‎ | experimental


 
C++
 
標準庫頭
通用工具
<any> (C++17)
<bitset>
<bit> (C++20)
<charconv> (C++17)
<expected> (C++23)
<format> (C++20)
<functional>
<optional> (C++17)
<stdbit.h> (C++26)
<tuple> (C++11)
<typeindex> (C++11)
<utility>
<variant> (C++17)
容器
<array> (C++11)
<deque>
<flat_map> (C++23)
<flat_set> (C++23)
<forward_list> (C++11)
<hive> (C++26)
<inplace_vector> (C++26)   
<list>
<map>
<mdspan> (C++23)
<queue>
<set>
<span> (C++20)
<stack>
<unordered_map> (C++11)
<unordered_set> (C++11)
<vector>
迭代器
<iterator>
範圍
<generator> (C++23)
<ranges> (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)
 指定元對象類型反射成員函數I（不含構造函數與析構函數）
(概念)
(反射 TS)
 指定元對象類型反射特殊成員函數
(概念)
(反射 TS)
 指定元對象類型反射構造函數
(概念)
(反射 TS)
 指定元對象類型反射析構函數
(概念)
(反射 TS)
 指定元對象類型反射運算符函數或轉換函數
(概念)
(反射 TS)
 指定元對象類型反射轉換函數
(概念)
(反射 TS)
 指定元對象類型反射非泛型 lambda 的閉包類型
(概念)
(反射 TS)
 指定元對象類型反射 lambda 捕獲
(概念)

類

Object 操作
(反射 TS)
 檢查兩個元對象類型是否反射同一實體或別名
(類模板)
(反射 TS)
 獲得被反射實體或別名的聲明的預設行號
(類模板)
(反射 TS)
 獲得被反射實體或別名的聲明的實現定義列號
(類模板)
(反射 TS)
 獲得被反射實體或別名的聲明的預設文件名
(類模板)
ObjectSequence 操作
(反射 TS)
 獲得元對象序列的大小
(類模板)
(反射 TS)
 獲得元對象序列中擁有給定下標的元對象類型
(類模板)
(反射 TS)
 應用模板到元對象序列
(類模板)
Named 操作
(反射 TS)
 檢查被反射實體或別名是否為無名
(類模板)
(反射 TS)
 獲得被反射實體或別名的無限定名
(類模板)
(反射 TS)
 獲得被反射實體或別名的實現定義顯示名
(類模板)
Alias 操作
(反射 TS)
 獲得反射被反射別名的關聯實體的元對象類型
(類模板)
Type 操作
(反射 TS)
 獲得反射被反射實體或別名的類型的元對象類型
(類模板)
(反射 TS)
 獲得反射被反射實體或別名的類型
(類模板)
(反射 TS)
 檢查元對象類型是否反射枚舉類型
(類模板)
(反射 TS)
 檢查元對象類型是否反射聯合體類型
(類模板)
(反射 TS)
 分別檢查元對象類型是否反射聲明使用 class 或 struct 的非聯合類類型
(類模板)
ScopeMember 操作
(反射 TS)
 獲得反射被反射實體或別名的作用域的元對象類型
(類模板)
Base 操作
(反射 TS)
 獲得反射給定基類關係中基類的元對象類型
(類模板)
RecordMember 與 Base 操作
(反射 TS)
 檢查被反射的成員或基類是否為公開
(類模板)
(反射 TS)
 檢查被反射的成員或基類是否為受保護
(類模板)
(反射 TS)
 檢查被反射的成員或基類是否為私有
(類模板)
Record 操作
(反射 TS)
 獲得元素反射被反射類的公開、可訪問或全部數據成員的元對象序列類型
(類模板)
(反射 TS)
 獲得元素反射被反射類的公開、可訪問或全部成員函數的元對象序列類型
(類模板)
(反射 TS)
 獲得元素反射被反射類的全部構造函數的的元對象序列類型
(類模板)
(反射 TS)
 獲得元素反射聲明於被反射類中的所有運算符函數及轉換函數的的元對象序列類型
(類模板)
(反射 TS)
 獲得反射被反射類的析構函數的元對象類型
(類模板)
(反射 TS)
 獲得元素反射被反射類的公開、可訪問或全部成員類型的元對象序列類型
(類模板)
(反射 TS)
 獲得元素反射被反射類的公開、可訪問或全部基類的元對象序列類型
(類模板)
Enum 操作
(反射 TS)
 檢查被反射枚舉是否有作用域
(類模板)
(反射 TS)
 獲得元素反射被反射枚舉的枚舉項的元對象序列類型
(類模板)
(反射 TS)
 獲得反射被反射枚舉的底層類型的元對象類型
(類模板)
Variable 操作
(反射 TS)
 獲得作為常量表達式的被反射變數的值
(類模板)
(反射 TS)
 檢查變數是否聲明帶 thread_local
(類模板)
FunctionParameter 操作
(反射 TS)
 檢查被反射的形參是否有默認實參
(類模板)
Callable 操作
(反射 TS)
 獲得元素反射被反射函數的形參的元對象序列類型
(類模板)
(反射 TS)
 檢查被反射函數的形參列表是否含有省略號形參
(類模板)
(反射 TS)
 檢查被反射函數是否為不拋出
(類模板)
(反射 TS)
 檢查被反射函數是否為被棄置
(類模板)
Variable 與 Callable 操作
(反射 TS)
 檢查被反射變數或函數是否為 constexpr
(類模板)
Namespace 與 Callable 操作
(反射 TS)
 檢查被反射的命名空間或函數是否為 inline
(類模板)
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 捕獲是否為初始化捕獲
(類模板)

[編輯] 概要

namespace std::experimental::reflect {
inline namespace v1 {
 
// 21.12.3 元对象类型的概念
template <class T>
concept Object = /* 见描述 */;
template <class T>
concept ObjectSequence = /* 见描述 */; // 细化 Object
template <class T>
concept TemplateParameterScope = /* 见描述 */; // 细化 Scope
template <class T>
concept Named = /* 见描述 */;          // 细化 Object
template <class T>
concept Alias = /* 见描述 */;          // 细化 Named 与 ScopeMember
template <class T>
concept RecordMember = /* 见描述 */;   // 细化 ScopeMember
template <class T>
concept Enumerator = /* 见描述 */;     // 细化 Constant
template <class T>
concept Variable = /* 见描述 */;       // 细化 Typed 与 ScopeMember
template <class T>
concept ScopeMember = /* 见描述 */;    // 细化 Named
template <class T>
concept Typed = /* 见描述 */;          // 细化 Object
template <class T>
concept Namespace = /* 见描述 */;      // 细化 Named 与 Scope
template <class T>
concept GlobalScope = /* 见描述 */;    // 细化 Namespace
template <class T>
concept Class = /* 见描述 */;          // 细化 Record
template <class T>
concept Enum = /* 见描述 */;           // 细化 Type, Scope, 与 ScopeMember
template <class T>
concept Record = /* 见描述 */;         // 细化 Type, Scope, 与 ScopeMember
template <class T>
concept Scope = /* 见描述 */;          // 细化 Object
template <class T>
concept Type = /* 见描述 */;           // 细化 Named
template <class T>
concept Constant = /* 见描述 */;       // 细化 Typed 与 ScopeMember
template <class T>
concept Base = /* 见描述 */;           // 细化 Object
template <class T>
concept FunctionParameter = /* 见描述 */; // 细化 Typed 与 ScopeMember
template <class T>
concept Callable = /* 见描述 */;       // 细化 Scope 与 ScopeMember
template <class T>
concept Expression = /* 见描述 */;     // 细化 Object
template <class T>
concept ParenthesizedExpression = /* 见描述 */; // 细化 Expression
template <class T>
concept FunctionCallExpression = /* 见描述 */; // 细化 Expression
template <class T>
concept FunctionalTypeConversion = /* 见描述 */; // 细化 Expression
template <class T>
concept Function = /* 见描述 */;       // 细化 Typed 与 Callable
template <class T>
concept MemberFunction = /* 见描述 */; // 细化 RecordMember 与 Function
template <class T>
concept SpecialMemberFunction = /* 见描述 */; // 细化 RecordMember
template <class T>
concept Constructor = /* 见描述 */;    // 细化 Callable 与 RecordMember
template <class T>
concept Destructor = /* 见描述 */;     // 细化 Callable 与 SpecialMemberFunction
template <class T>
concept Operator = /* 见描述 */;       // 细化 Function
template <class T>
concept ConversionOperator = /* 见描述 */; // 细化 MemberFunction 与 Operator
template <class T>
concept Lambda = /* 见描述 */;         // 细化 Type 与 Scope
template <class T>
concept LambdaCapture = /* 见描述 */;  // 细化 Variable
 
// 21.12.4 元对象操作
// 多重概念操作
template <Object T> struct is_public;
template <Object T> struct is_protected;
template <Object T> struct is_private;
template <Object T> struct is_constexpr;
template <Object T> struct is_static;
template <Object T> struct is_final;
template <Object T> struct is_explicit;
template <Object T> struct is_inline;
template <Object T> struct is_virtual;
template <Object T> struct is_pure_virtual;
template <Object T> struct get_pointer;
 
template <class T>
requires RecordMember<T> || Base<T>
  constexpr auto is_public_v = is_public<T>::value;
template <class T>
requires RecordMember<T> || Base<T>
  constexpr auto is_protected_v = is_protected<T>::value;
template <class T>
requires RecordMember<T> || Base<T>
  constexpr auto is_private_v = is_private<T>::value;
template <class T>
requires Variable<T> || Callable<T>
  constexpr auto is_constexpr_v = is_constexpr<T>::value;
template <class T>
requires Variable<T> || MemberFunction<T>
  constexpr auto is_static_v = is_static<T>::value;
template <class T>
requires Class<T> || MemberFunction<T>
  constexpr auto is_final_v = is_final<T>::value;
template <class T>
requires Constructor<T> || ConversionOperator<T>
  constexpr auto is_explicit_v = is_explicit<T>::value;
template <class T>
requires Namespace<T> || Callable<T>
  constexpr auto is_inline_v = is_inline<T>::value;
template <class T>
requires Base<T> || MemberFunction<T> || Destructor<T>
  constexpr auto is_virtual_v = is_virtual<T>::value;
template <class T>
requires MemberFunction<T> || Destructor<T>
  constexpr auto is_pure_virtual_v = is_pure_virtual<T>::value;
template <class T>
requires Variable<T> || Function<T>
  constexpr auto get_pointer_v = get_pointer<T>::value;
 
// 21.12.4.1 Object 操作
template <Object T1, Object T2> struct reflects_same;
template <Object T> struct get_source_line;
template <Object T> struct get_source_column;
template <Object T> struct get_source_file_name;
 
template <Object T1, Object T2>
  constexpr auto reflects_same_v = reflects_same<T1, T2>::value;
template <class T>
  constexpr auto get_source_line_v = get_source_line<T>::value;
template <class T>
  constexpr auto get_source_column_v = get_source_column<T>::value;
template <class T>
  constexpr auto get_source_file_name_v = get_source_file_name<T>::value;
 
// 21.12.4.2 ObjectSequence 操作
template <ObjectSequence T> struct get_size;
template <size_t I, ObjectSequence T> struct get_element;
template <template <class...> class Tpl, ObjectSequence T>
  struct unpack_sequence;
 
template <ObjectSequence T>
  constexpr auto get_size_v = get_size<T>::value;
template <size_t I, ObjectSequence T>
  using get_element_t = typename get_element<I, T>::type;
template <template <class...> class Tpl, ObjectSequence T>
  using unpack_sequence_t = typename unpack_sequence<Tpl, T>::type;
 
// 21.12.4.3 Named 操作
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 操作
template <Alias T> struct get_aliased;
 
template <Alias T>
  using get_aliased_t = typename get_aliased<T>::type;
 
// 21.12.4.5 Type 操作
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 操作
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 操作
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 操作
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 操作
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 操作
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 操作
template <Namespace T> struct is_inline<T>;
 
// 21.12.4.12 FunctionParameter 操作
template <FunctionParameter T> struct has_default_argument;
 
template <FunctionParameter T>
  constexpr auto has_default_argument_v = has_default_argument<T>::value;
 
// 21.12.4.13 Callable 操作
template <Callable T> struct get_parameters;
template <Callable T> struct is_vararg;
template <Callable T> struct is_constexpr<T>;
template <Callable T> struct is_noexcept;
template <Callable T> struct is_inline<T>;
template <Callable T> struct is_deleted;
 
template <Callable T>
  using get_parameters_t = typename get_parameters<T>::type;
template <Callable T>
  constexpr auto is_vararg_v = is_vararg<T>::value;
template <Callable T>
  constexpr auto is_deleted_v = is_deleted<T>::value;
 
// 21.12.4.14 ParenthesizedExpression 操作
template <ParenthesizedExpression T> struct get_subexpression;
 
template <ParenthesizedExpression T>
  using get_subexpression_t = typename get_subexpression<T>::type;
 
// 21.12.4.15 FunctionCallExpression 操作
template <FunctionCallExpression T> struct get_callable;
 
template <FunctionCallExpression T>
  using get_callable_t = typename get_callable<T>::type;
 
// 21.12.4.16 FunctionalTypeConversion 操作
template <FunctionalTypeConversion T> struct get_constructor;
 
template <FunctionalTypeConversion T>
  using get_constructor_t = typename get_constructor<T>::type;
 
// 21.12.4.17 Function 操作
template <Function T> struct get_pointer<T>;
 
// 21.12.4.18 MemberFunction 操作
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 操作
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 操作
template <Constructor T> struct is_explicit<T>;
 
// 21.12.4.21 Destructor 操作
template <Destructor T> struct is_virtual<T>;
template <Destructor T> struct is_pure_virtual<T>;
 
// 21.12.4.22 ConversionOperator 操作
template <ConversionOperator T> struct is_explicit<T>;
 
// 21.12.4.23 Lambda 操作
template <Lambda T> struct get_captures;
template <Lambda T> struct uses_default_copy_capture;
template <Lambda T> struct uses_default_reference_capture;
template <Lambda T> struct is_call_operator_const;
 
template <Lambda T>
  using get_captures_t = typename get_captures<T>::type;
template <Lambda T>
  constexpr auto uses_default_copy_capture_v = uses_default_copy_capture<T>::value;
template <Lambda T>
  constexpr auto uses_default_reference_capture_v = uses_default_reference_capture<T>::value;
template <Lambda T>
  constexpr auto is_call_operator_const_v = is_call_operator_const<T>::value;
 
// 21.12.4.24 LambdaCapture 操作
template <LambdaCapture T> struct is_explicitly_captured;
template <LambdaCapture T> struct is_init_capture;
 
template <LambdaCapture T>
  constexpr auto is_explicitly_captured_v = is_explicitly_captured<T>::value;
template <LambdaCapture T>
  constexpr auto is_init_capture_v = is_init_capture<T>::value;
 
} // inline namespace v1
} // namespace std::experimental::reflect
取自「https://zh.cppreference.com/mwiki/index.php?title=cpp/header/experimental/reflect&oldid=84172」