Showing content from https://timsong-cpp.github.io/cppwp/n4659/meta.unary below:
23 General utilities library [utilities]
Template Condition Preconditions template <class T>
struct is_const; T is const-qualified template <class T>
struct is_volatile; T is volatile-qualified template <class T>
struct is_trivial; T is a trivial type remove_all_extents_t<T> shall be a complete type or cv void. template <class T>
struct is_trivially_copyable; T is a trivially copyable type remove_all_extents_t<T> shall be a complete type or cv void. template <class T>
struct is_standard_layout; T is a standard-layout type remove_all_extents_t<T> shall be a complete type or cv void. template <class T>
struct is_pod; T is a POD type remove_all_extents_t<T> shall be a complete type or cv void. template <class T>
struct is_empty; T is a class type, but not a union type, with no non-static data members other than bit-fields of length 0, no virtual member functions, no virtual base classes, and no base class B for which is_empty_v<B> is false. If T is a non-union class type, T shall be a complete type. template <class T>
struct is_polymorphic; T is a polymorphic class If T is a non-union class type, T shall be a complete type. template <class T>
struct is_abstract; T is an abstract class If T is a non-union class type, T shall be a complete type. template <class T>
struct is_final; T is a class type marked with the class-virt-specifier final (Clause [class]). [ Note: A union is a class type that can be marked with final. — end note ] If T is a class type, T shall be a complete type. template <class T>
struct is_aggregate; T is an aggregate type ([dcl.init.aggr]) remove_all_extents_t<T> shall be a complete type or cv void. template <class T>
struct is_signed; If is_arithmetic_v<T> is true, the same result as T(-1) < T(0); otherwise, false template <class T>
struct is_unsigned; If is_arithmetic_v<T> is true, the same result as T(0) < T(-1); otherwise, false template <class T, class... Args>
struct is_constructible; For a function type T or for a cv void type T, is_constructible_v<T, Args...> is false, otherwise see below T and all types in the parameter pack Args shall be complete types, cv void, or arrays of unknown bound. template <class T>
struct is_default_constructible; is_constructible_v<T> is true. T shall be a complete type, cv void, or an array of unknown bound. template <class T>
struct is_copy_constructible; For a referenceable type T, the same result as is_constructible_v<T, const T&>, otherwise false. T shall be a complete type, cv void, or an array of unknown bound. template <class T>
struct is_move_constructible; For a referenceable type T, the same result as is_constructible_v<T, T&&>, otherwise false. T shall be a complete type, cv void, or an array of unknown bound. template <class T, class U>
struct is_assignable; The expression declval<T>() = declval<U>() is well-formed when treated as an unevaluated operand. Access checking is performed as if in a context unrelated to T and U. Only the validity of the immediate context of the assignment expression is considered. [ Note: The compilation of the expression can result in side effects such as the instantiation of class template specializations and function template specializations, the generation of implicitly-defined functions, and so on. Such side effects are not in the “immediate context” and can result in the program being ill-formed. — end note ] T and U shall be complete types, cv void, or arrays of unknown bound. template <class T>
struct is_copy_assignable; For a referenceable type T, the same result as is_assignable_v<T&, const T&>, otherwise false. T shall be a complete type, cv void, or an array of unknown bound. template <class T>
struct is_move_assignable; For a referenceable type T, the same result as is_assignable_v<T&, T&&>, otherwise false. T shall be a complete type, cv void, or an array of unknown bound. template <class T, class U>
struct is_swappable_with; The expressions swap(declval<T>(), declval<U>()) and swap(declval<U>(), declval<T>()) are each well-formed when treated as an unevaluated operand in an overload-resolution context for swappable values ([swappable.requirements]). Access checking is performed as if in a context unrelated to T and U. Only the validity of the immediate context of the swap expressions is considered. [ Note: The compilation of the expressions can result in side effects such as the instantiation of class template specializations and function template specializations, the generation of implicitly-defined functions, and so on. Such side effects are not in the “immediate context” and can result in the program being ill-formed. — end note ] T and U shall be complete types, cv void, or arrays of unknown bound. template <class T>
struct is_swappable; For a referenceable type T, the same result as is_swappable_with_v<T&, T&>, otherwise false. T shall be a complete type, cv void, or an array of unknown bound. template <class T>
struct is_destructible; Either T is a reference type, or T is a complete object type for which the expression declval<U&>().~U() is well-formed when treated as an unevaluated operand, where U is remove_all_extents<T>. T shall be a complete type, cv void, or an array of unknown bound. template <class T, class... Args>
struct
is_trivially_constructible; is_constructible_v<T,
Args...> is true and the variable definition for is_constructible, as defined below, is known to call no operation that is not trivial ([basic.types], [special]). T and all types in the parameter pack Args shall be complete types, cv void, or arrays of unknown bound. template <class T>
struct is_trivially_default_constructible; is_trivially_constructible_v<T> is true. T shall be a complete type, cv void, or an array of unknown bound. template <class T>
struct is_trivially_copy_constructible; For a referenceable type T, the same result as is_trivially_constructible_v<T, const T&>, otherwise false. T shall be a complete type, cv void, or an array of unknown bound. template <class T>
struct is_trivially_move_constructible; For a referenceable type T, the same result as is_trivially_constructible_v<T, T&&>, otherwise false. T shall be a complete type, cv void, or an array of unknown bound. template <class T, class U>
struct is_trivially_assignable; is_assignable_v<T, U> is true and the assignment, as defined by is_assignable, is known to call no operation that is not trivial ([basic.types], [special]). T and U shall be complete types, cv void, or arrays of unknown bound. template <class T>
struct is_trivially_copy_assignable; For a referenceable type T, the same result as is_trivially_assignable_v<T&, const T&>, otherwise false. T shall be a complete type, cv void, or an array of unknown bound. template <class T>
struct is_trivially_move_assignable; For a referenceable type T, the same result as is_trivially_assignable_v<T&, T&&>, otherwise false. T shall be a complete type, cv void, or an array of unknown bound. template <class T>
struct is_trivially_destructible; is_destructible_v<T> is true and the indicated destructor is known to be trivial. T shall be a complete type, cv void, or an array of unknown bound. template <class T, class... Args>
struct is_nothrow_constructible; is_constructible_v<T, Args...> is true and the variable definition for is_constructible, as defined below, is known not to throw any exceptions ([expr.unary.noexcept]). T and all types in the parameter pack Args shall be complete types, cv void, or arrays of unknown bound. template <class T>
struct is_nothrow_default_constructible; is_nothrow_constructible_v<T> is true. T shall be a complete type, cv void, or an array of unknown bound. template <class T>
struct is_nothrow_copy_constructible; For a referenceable type T, the same result as is_nothrow_constructible_v<T, const T&>, otherwise false. T shall be a complete type, cv void, or an array of unknown bound. template <class T>
struct is_nothrow_move_constructible; For a referenceable type T, the same result as is_nothrow_constructible_v<T, T&&>, otherwise false. T shall be a complete type, cv void, or an array of unknown bound. template <class T, class U>
struct is_nothrow_assignable; is_assignable_v<T, U> is true and the assignment is known not to throw any exceptions ([expr.unary.noexcept]). T and U shall be complete types, cv void, or arrays of unknown bound. template <class T>
struct is_nothrow_copy_assignable; For a referenceable type T, the same result as is_nothrow_assignable_v<T&, const T&>, otherwise false. T shall be a complete type, cv void, or an array of unknown bound. template <class T>
struct is_nothrow_move_assignable; For a referenceable type T, the same result as is_nothrow_assignable_v<T&, T&&>, otherwise false. T shall be a complete type, cv void, or an array of unknown bound. template <class T, class U>
struct is_nothrow_swappable_with; is_swappable_with_v<T, U> is true and each swap expression of the definition of is_swappable_with<T, U> is known not to throw any exceptions ([expr.unary.noexcept]). T and U shall be complete types, cv void, or arrays of unknown bound. template <class T>
struct is_nothrow_swappable; For a referenceable type T, the same result as is_nothrow_swappable_with_v<T&, T&>, otherwise false. T shall be a complete type, cv void, or an array of unknown bound. template <class T>
struct is_nothrow_destructible; is_destructible_v<T> is true and the indicated destructor is known not to throw any exceptions ([expr.unary.noexcept]). T shall be a complete type, cv void, or an array of unknown bound. template <class T>
struct has_virtual_destructor; T has a virtual destructor If T is a non-union class type, T shall be a complete type. template <class T>
struct has_unique_object_representations; For an array type T, the same result as has_unique_object_representations_v<remove_all_extents_t<T>>, otherwise see below. T shall be a complete type, cv void, or an array of unknown bound.
RetroSearch is an open source project built by @garambo
| Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4