Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      Experimental library header <experimental/reflect>

      From cppreference.com
      <cpp‎ |header‎ |experimental
       
       
      Standard library headers
       
      Experimental library headers
      ExecutionP2300
      <experimental/execution>
      Filesystem TS
      <experimental/filesystem>
      Parallelism TS (v1, v2)
      experimental/algorithm
      experimental/execution_policy
      experimental/exception_list
      experimental/numeric
      <experimental/simd>
      experimental/task_block
      Library Fundamentals 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

      Concurrency TS
      experimental/atomic
      experimental/barrier
      experimental/future
      experimental/latch
      Ranges TS
      Coroutines TS
      experimental/coroutine
      Networking TS
      experimental/buffer
      experimental/executor
      experimental/internet
      experimental/io_context
      <experimental/net>
      experimental/netfwd
      experimental/socket
      experimental/timer
      Reflection TS
      <experimental/reflect>
       

      This header is part of theReflection TS.

      Defined in namespacestd::experimental::reflect
      Defined in inline namespacestd::experimental::reflect::v1

      Contents

      Concepts

      (reflection TS)
      		 specifies that a type is a meta-object type
      (concept)
      (reflection TS)
      		 specifies that a meta-object type is a meta-object sequence type
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a template parameter scope
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects an entity or alias with an associated (possibly empty) name
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a type alias, namespace alias, or an alias introduced by a using-declaration
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects amember-declaration of a class
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects an enumerator
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a variable or data member
      (concept)
      (reflection TS)
      		 specifies that a meta-object type satisfiesRecordMember,Enumerator, orVariable, or reflects a namespace other than the global namespace
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects an entity with a type
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a namespace
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects the global namespace
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a non-union class type
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects an enumeration type
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a class type
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a namespace, class, enumeration, function, closure type, a template parameter scope
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a type
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects an enumerator or a constexpr variable
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a direct base class obtained fromget_base_classes
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a function parameter
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a function (including constructors and destructors)
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects an expression
      (concept)
      specifies that a meta-object type reflects a parenthesized expression
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects afunction-call-expression
      (concept)
      specifies that a meta-object type reflects afunctional-type-conv-expression
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a function (excluding constructors and destructors)
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a member function (excluding constructors and destructors)
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a special member function
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a constructor
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a destructor
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects an operator function or a conversion function
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a conversion function
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects the closure type of a non-generic lambda
      (concept)
      (reflection TS)
      		 specifies that a meta-object type reflects a lambda capture
      (concept)

      Classes

      Object operations
      (reflection TS)
      		 checks if two meta-object types reflect the same entity or alias
      (class template)
      (reflection TS)
      		 obtains the presumed line number of the declaration of the reflected entity or alias
      (class template)
      (reflection TS)
      		 obtains the implementation-defined column number of the declaration of the reflected entity or alias
      (class template)
      (reflection TS)
      		 obtains the presumed file name of the declaration of the reflected entity or alias
      (class template)
      ObjectSequence operations
      (reflection TS)
      		 obtains the size of a meta-object sequence
      (class template)
      (reflection TS)
      		 obtains the meta-object type with specified index in a sequence
      (class template)
      (reflection TS)
      		 applies a template to the meta-object sequence
      (class template)
      Named operations
      (reflection TS)
      		 checks if the reflected entity or alias is named
      (class template)
      (reflection TS)
      		 obtains the unqualified name of the reflected entity or alias
      (class template)
      (reflection TS)
      		 obtains the implementation-defined display name of the reflected entity or alias
      (class template)
      Alias operations
      (reflection TS)
      		 obtains the meta-object type reflecting the associated entity of the reflected alias
      (class template)
      Type operations
      (reflection TS)
      		 obtains the meta-object type reflecting the type of the reflected entity or alias
      (class template)
      (reflection TS)
      		 obtains the type of the reflected entity or alias
      (class template)
      (reflection TS)
      		 checks if the meta-object type reflects an enumeration type
      (class template)
      (reflection TS)
      		 checks if the meta-object type reflects a union type
      (class template)
      checks if the meta-object type reflects a non-union class type whose declaration usesclass orstruct respectively
      (class template)
      ScopeMember operations
      (reflection TS)
      		 obtains the meta-object type reflecting the scope of the reflected entity or alias
      (class template)
      Base operations
      (reflection TS)
      		 obtains the meta-object type reflecting the base class in the given base class relationship
      (class template)
      RecordMember andBase operations
      (reflection TS)
      		 checks if the reflected member or base class is public
      (class template)
      (reflection TS)
      		 checks if the reflected member or base class is protected
      (class template)
      (reflection TS)
      		 checks if the reflected member or base class is private
      (class template)
      Record operations
      obtains a meta-object sequence type whose elements reflect public, accessible, or all data members of the reflected class
      (class template)
      obtains a meta-object sequence type whose elements reflect public, accessible, or all member functions of the reflected class
      (class template)
      (reflection TS)
      		 obtains a meta-object sequence type whose elements reflect all constructors of the reflected class
      (class template)
      (reflection TS)
      		 obtains a meta-object sequence type whose elements reflect all operator functions and conversion functions declared in the reflected class
      (class template)
      (reflection TS)
      		 obtains the meta-object type reflecting the destructor of the reflected class
      (class template)
      obtains a meta-object sequence type whose elements reflect public, accessible, or all nested type or member typedefs of the reflected class
      (class template)
      obtains a meta-object sequence type whose elements reflect public, accessible, or all base classes of the reflected class
      (class template)
      Enum operations
      (reflection TS)
      		 checks whether the reflected enumeration is scoped
      (class template)
      (reflection TS)
      		 obtains a meta-object sequence type whose elements reflects the enumerators of the reflected enumeration
      (class template)
      (reflection TS)
      		 obtains the meta-object type reflecting the underlying type of the reflected enumeration
      (class template)
      Variable operations
      (reflection TS)
      		 obtains the value of the reflected variable which is a constant expression
      (class template)
      (reflection TS)
      		 checks if the variable is declared withthread_local
      (class template)
      FunctionParameter operations
      (reflection TS)
      		 checks whether the reflected parameter has a default argument
      (class template)
      Callable operations
      (reflection TS)
      		 obtains a meta-object sequence type whose elements reflects the parameters of the reflected function
      (class template)
      (reflection TS)
      		 checks whether the parameter list of the reflected function contains an ellipsis parameter
      (class template)
      (reflection TS)
      		 checks whether the reflected function is non-throwing
      (class template)
      (reflection TS)
      		 checks whether the reflected function is deleted
      (class template)
      Variable andCallable operations
      (reflection TS)
      		 checks if the reflected variable or function is constexpr
      (class template)
      Namespace andCallable operations
      (reflection TS)
      		 checks whether the reflected namespace or function is inline
      (class template)
      ParenthesizedExpression operations
      (reflection TS)
      		 obtains the meta-object type reflecting the unparenthesized expression of the reflected parethesized expression
      (class template)
      FunctionCallExpression operations
      (reflection TS)
      		 obtains the meta-object type reflecting the function in the reflectedfunction-call-expression
      (class template)
      FunctionalTypeConversion operations
      (reflection TS)
      		 obtains the meta-object type reflecting the constructor in reflectedfunctional-type-conv-expression
      (class template)
      Variable andFunction operations
      (reflection TS)
      		 get the address of the reflected variable or function, or the pointer-to-member value to the reflected non-static member
      (class template)
      MemberFunction operations
      checks if the reflected member function is declared withconst,volatile,&, or&& qualifier respectively
      (class template)
      (reflection TS)
      		 checks if the reflected member function overrides a member function of base class
      (class template)
      Record andMemberFunction operations
      (reflection TS)
      		 checks if the reflected class or member function is marked withfinal
      (class template)
      Variable andMemberFunction operations
      (reflection TS)
      		 checks if the reflected variable is of static storage duration, or the reflected member function is static
      (class template)
      SpecialMemberFunction operations
      (reflection TS)
      		 checks if the reflected special member function is implicitly declared
      (class template)
      (reflection TS)
      		 checks if the reflected special member function is defaulted in its first declaration
      (class template)
      Constructor andConversionOperator operations
      (reflection TS)
      		 checks if the reflected constructor or conversion function is declared withexplicit
      (class template)
      MemberFunction andDestructor operations
      (reflection TS)
      		 checks if the reflected member function is virtual
      (class template)
      (reflection TS)
      		 checks if the reflected member function is pure virtual
      (class template)
      Lambda operations
      (reflection TS)
      		 obtains a meta-object sequence type whose elements reflect the captures of the reflected closure type
      (class template)
      checks if the capture-default of the lambda expression of the reflected closure type is= or& respectively
      (class template)
      (reflection TS)
      		 checks if theoperator() of the reflected closure type is declared withconst
      (class template)
      LambdaCapture operations
      (reflection TS)
      		 checks if the reflected lambda capture is explicitly captured
      (class template)
      (reflection TS)
      		 checks if the reflected lambda capture is an init-capture
      (class template)

      [edit]Synopsis

      namespace std::experimental::reflect{inlinenamespace v1{ // 21.12.3 Concepts for meta-object typestemplate<class T>concept Object=/* see description */;template<class T>concept ObjectSequence=/* see description */;// refines Objecttemplate<class T>concept TemplateParameterScope=/* see description */;// refines Scopetemplate<class T>concept Named=/* see description */;// refines Objecttemplate<class T>concept Alias=/* see description */;// refines Named and ScopeMembertemplate<class T>concept RecordMember=/* see description */;// refines ScopeMembertemplate<class T>concept Enumerator=/* see description */;// refines Constanttemplate<class T>concept Variable=/* see description */;// refines Typed and ScopeMembertemplate<class T>concept ScopeMember=/* see description */;// refines Namedtemplate<class T>concept Typed=/* see description */;// refines Objecttemplate<class T>concept Namespace=/* see description */;// refines Named and Scopetemplate<class T>concept GlobalScope=/* see description */;// refines Namespacetemplate<class T>concept Class=/* see description */;// refines Recordtemplate<class T>concept Enum=/* see description */;// refines Type, Scope, and ScopeMembertemplate<class T>concept Record=/* see description */;// refines Type, Scope, and ScopeMembertemplate<class T>concept Scope=/* see description */;// refines Objecttemplate<class T>concept Type=/* see description */;// refines Namedtemplate<class T>concept Constant=/* see description */;// refines Typed and ScopeMembertemplate<class T>concept Base=/* see description */;// refines Objecttemplate<class T>concept FunctionParameter=/* see description */;// refines Typed and ScopeMembertemplate<class T>concept Callable=/* see description */;// refines Scope and ScopeMembertemplate<class T>concept Expression=/* see description */;// refines Objecttemplate<class T>concept ParenthesizedExpression=/* see description */;// refines Expressiontemplate<class T>concept FunctionCallExpression=/* see description */;// refines Expressiontemplate<class T>concept FunctionalTypeConversion=/* see description */;// refines Expressiontemplate<class T>concept Function=/* see description */;// refines Typed and Callabletemplate<class T>concept MemberFunction=/* see description */;// refines RecordMember and Functiontemplate<class T>concept SpecialMemberFunction=/* see description */;// refines RecordMembertemplate<class T>concept Constructor=/* see description */;// refines Callable and RecordMembertemplate<class T>concept Destructor=/* see description */;// refines Callable and SpecialMemberFunctiontemplate<class T>concept Operator=/* see description */;// refines Functiontemplate<class T>concept ConversionOperator=/* see description */;// refines MemberFunction and Operatortemplate<class T>concept Lambda=/* see description */;// refines Type and Scopetemplate<class T>concept LambdaCapture=/* see description */;// refines Variable // 21.12.4 Meta-object operations// Multi-concept operationstemplate<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>constexprauto is_public_v= is_public<T>::value;template<class T>requires RecordMember<T>|| Base<T>constexprauto is_protected_v= is_protected<T>::value;template<class T>requires RecordMember<T>|| Base<T>constexprauto is_private_v= is_private<T>::value;template<class T>requires Variable<T>|| Callable<T>constexprauto is_constexpr_v= is_constexpr<T>::value;template<class T>requires Variable<T>|| MemberFunction<T>constexprauto is_static_v= is_static<T>::value;template<class T>requires Class<T>|| MemberFunction<T>constexprauto is_final_v= is_final<T>::value;template<class T>requires Constructor<T>|| ConversionOperator<T>constexprauto is_explicit_v= is_explicit<T>::value;template<class T>requires Namespace<T>|| Callable<T>constexprauto is_inline_v= is_inline<T>::value;template<class T>requires Base<T>|| MemberFunction<T>|| Destructor<T>constexprauto is_virtual_v= is_virtual<T>::value;template<class T>requires MemberFunction<T>|| Destructor<T>constexprauto is_pure_virtual_v= is_pure_virtual<T>::value;template<class T>requires Variable<T>|| Function<T>constexprauto get_pointer_v= get_pointer<T>::value; // 21.12.4.1 Object operationstemplate<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>constexprauto reflects_same_v= reflects_same<T1, T2>::value;template<class T>constexprauto get_source_line_v= get_source_line<T>::value;template<class T>constexprauto get_source_column_v= get_source_column<T>::value;template<class T>constexprauto get_source_file_name_v= get_source_file_name<T>::value; // 21.12.4.2 ObjectSequence operationstemplate<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>constexprauto 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 operationstemplate<Named T>struct is_unnamed;template<Named T>struct get_name;template<Named T>struct get_display_name; template<Named T>constexprauto is_unnamed_v= is_unnamed<T>::value;template<Named T>constexprauto get_name_v= get_name<T>::value;template<Named T>constexprauto get_display_name_v= get_display_name<T>::value; // 21.12.4.4 Alias operationstemplate<Alias T>struct get_aliased; template<Alias T>using get_aliased_t=typename get_aliased<T>::type; // 21.12.4.5 Type operationstemplate<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>constexprauto is_enum_v= is_enum<T>::value;template<Class T>constexprauto uses_class_key_v= uses_class_key<T>::value;template<Class T>constexprauto uses_struct_key_v= uses_struct_key<T>::value;template<Type T>constexprauto is_union_v= is_union<T>::value; // 21.12.4.6 Member operationstemplate<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 operationstemplate<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 operationstemplate<Enum T>struct is_scoped_enum;template<Enum T>struct get_enumerators;template<Enum T>struct get_underlying_type; template<Enum T>constexprauto 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 operationstemplate<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>constexprauto get_constant_v= get_constant<T>::value;template<Variable T>constexprauto is_thread_local_v= is_thread_local<T>::value; // 21.12.4.10 Base operationstemplate<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 operationstemplate<Namespace T>struct is_inline<T>; // 21.12.4.12 FunctionParameter operationstemplate<FunctionParameter T>struct has_default_argument; template<FunctionParameter T>constexprauto has_default_argument_v= has_default_argument<T>::value; // 21.12.4.13 Callable operationstemplate<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>constexprauto is_vararg_v= is_vararg<T>::value;template<Callable T>constexprauto is_deleted_v= is_deleted<T>::value; // 21.12.4.14 ParenthesizedExpression operationstemplate<ParenthesizedExpression T>struct get_subexpression; template<ParenthesizedExpression T>using get_subexpression_t=typename get_subexpression<T>::type; // 21.12.4.15 FunctionCallExpression operationstemplate<FunctionCallExpression T>struct get_callable; template<FunctionCallExpression T>using get_callable_t=typename get_callable<T>::type; // 21.12.4.16 FunctionalTypeConversion operationstemplate<FunctionalTypeConversion T>struct get_constructor; template<FunctionalTypeConversion T>using get_constructor_t=typename get_constructor<T>::type; // 21.12.4.17 Function operationstemplate<Function T>struct get_pointer<T>; // 21.12.4.18 MemberFunction operationstemplate<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>constexprauto is_const_v= is_const<T>::value;template<MemberFunction T>constexprauto is_volatile_v= is_volatile<T>::value;template<MemberFunction T>constexprauto has_lvalueref_qualifier_v= has_lvalueref_qualifier<T>::value;template<MemberFunction T>constexprauto has_rvalueref_qualifier_v= has_rvalueref_qualifier<T>::value;template<MemberFunction T>constexprauto is_override_v= is_override<T>::value; // 21.12.4.19 SpecialMemberFunction operationstemplate<SpecialMemberFunction T>struct is_implicitly_declared;template<SpecialMemberFunction T>struct is_defaulted; template<SpecialMemberFunction T>constexprauto is_implicitly_declared_v= is_implicitly_declared<T>::value;template<SpecialMemberFunction T>constexprauto is_defaulted_v= is_defaulted<T>::value; // 21.12.4.20 Constructor operationstemplate<Constructor T>struct is_explicit<T>; // 21.12.4.21 Destructor operationstemplate<Destructor T>struct is_virtual<T>;template<Destructor T>struct is_pure_virtual<T>; // 21.12.4.22 ConversionOperator operationstemplate<ConversionOperator T>struct is_explicit<T>; // 21.12.4.23 Lambda operationstemplate<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>constexprauto uses_default_copy_capture_v= uses_default_copy_capture<T>::value;template<Lambda T>constexprauto uses_default_reference_capture_v= uses_default_reference_capture<T>::value;template<Lambda T>constexprauto is_call_operator_const_v= is_call_operator_const<T>::value; // 21.12.4.24 LambdaCapture operationstemplate<LambdaCapture T>struct is_explicitly_captured;template<LambdaCapture T>struct is_init_capture; template<LambdaCapture T>constexprauto is_explicitly_captured_v= is_explicitly_captured<T>::value;template<LambdaCapture T>constexprauto is_init_capture_v= is_init_capture<T>::value; }// inline namespace v1}// namespace std::experimental::reflect
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/header/experimental/reflect&oldid=148848"
      [8]ページ先頭
      ©2009-2026 Movatter.jp