實驗性庫標頭檔案 <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)

指定元物件型別反映類型別名、命名空間別名或由 using 宣告引入的別名
(概念)

RecordMember

(反射 TS)

指定元物件型別反映類的成員宣告
(概念)

Enumerator

(反射 TS)

指定元物件型別反映列舉器
(概念)

Variable

(反射 TS)

指定元物件型別反映變數或資料成員
(概念)

ScopeMember

(反射 TS)

指定元物件型別滿足 RecordMember、Enumerator 或 Variable，或反映除全域性名稱空間以外的名稱空間
(概念)

Typed

(反射 TS)

指定元物件型別反映具有型別的實體
(概念)

Namespace

(反射 TS)

指定元物件型別反映名稱空間
(概念)

GlobalScope

(反射 TS)

指定元物件型別反映全域性名稱空間
(概念)

Class

(反射 TS)

指定元物件型別反映非聯合類型別
(概念)

Enum

(反射 TS)

指定元物件型別反映列舉型別
(概念)

Record

(反射 TS)

指定元物件型別反映類型別
(概念)

作用域

(反射 TS)

指定元物件型別反映名稱空間、類、列舉、函式、閉包型別、模板引數作用域
(概念)

型別

(反射 TS)

指定元物件型別反映型別
(概念)

Constant

(反射 TS)

指定元物件型別反映列舉器或 constexpr 變數
(概念)

Base

(反射 TS)

指定元物件型別反映從 get_base_classes 獲取的直接基類
(概念)

FunctionParameter

(反射 TS)

指定元物件型別反映函式引數
(概念)

Callable

(反射 TS)

指定元物件型別反映函式（包括建構函式和解構函式）
(概念)

Expression

(反射 TS)

指定元物件型別反映表示式
(概念)

ParenthesizedExpression

(反射 TS)

指定元物件型別反映帶括號的表示式
(概念)

FunctionCallExpression

(反射 TS)

指定元物件型別反映函式呼叫表示式
(概念)

FunctionalTypeConversion

(反射 TS)

指定元物件型別反映函式式型別轉換表示式
(概念)

Function

(反射 TS)

指定元物件型別反映函式（不包括建構函式和解構函式）
(概念)

MemberFunction

(反射 TS)

指定元物件型別反映成員函式（不包括建構函式和解構函式）
(概念)

SpecialMemberFunction

(反射 TS)

指定元物件型別反映特殊成員函式
(概念)

Constructor

(反射 TS)

指定元物件型別反映建構函式
(概念)

解構函式

(反射 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)

獲取反映所反映函式呼叫表示式中函式的元物件型別
(類模板)

`FunctionalTypeConversion` 操作

get_constructor

(反射 TS)

獲取反映所反映函式式型別轉換表示式中建構函式的元物件型別
(類模板)

`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)

檢查所反映的特殊成員函式是否在其第一個宣告中 defaulted
(類模板)

`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 表示式的捕獲預設值是否分別為 = 或 &
(類模板)

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

編譯器支援
自由（freestanding）與宿主（hosted）
語言
標準庫
標準庫標頭檔案
具名要求
特性測試宏 (C++20)
語言支援庫
概念庫 (C++20)
診斷庫
記憶體管理庫
超程式設計庫 (C++11)
通用工具庫
容器庫
迭代器庫
範圍庫 (C++20)
演算法庫
字串庫
文字處理庫
數值庫
日期和時間庫
輸入/輸出庫
檔案系統庫 (C++17)
併發支援庫 (C++11)
執行控制庫 (C++26)
技術規範
符號索引
外部庫

cppreference.com

名稱空間

變體

檢視

操作

實驗性庫標頭檔案 <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.com

名稱空間

變體

檢視

操作

實驗性庫標頭檔案 <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` 操作