Showing content from https://timsong-cpp.github.io/cppwp/n4140/meta below:
20 General utilities library [utilities]
Template Condition Preconditions template <class T>
struct is_const; T is const-qualified ([basic.type.qualifier]) template <class T>
struct is_volatile; T is volatile-qualified ([basic.type.qualifier]) template <class T>
struct is_trivial; T is a trivial type ([basic.types]) remove_all_extents_t<T> shall be a complete type or (possibly cv-qualified) void. template <class T>
struct is_trivially_copyable; T is a trivially copyable type ([basic.types]) remove_all_extents_t<T> shall be a complete type or (possibly cv-qualified) void. template <class T>
struct is_standard_layout; T is a standard-layout type ([basic.types]) remove_all_extents_t<T> shall be a complete type or (possibly cv-qualified) void. template <class T>
struct is_pod; T is a POD type ([basic.types]) remove_all_extents_t<T> shall be a complete type or (possibly cv-qualified) void. template <class T>
struct is_literal_type; T is a literal type ([basic.types]) remove_all_extents_t<T> shall be a complete type or (possibly cv-qualified) 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<B>::value 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 ([class.virtual]) 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 ([class.abstract]) 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_signed; If is_arithmetic<T>::value is true, the same result as integral_constant<bool, T(-1) < T(0)>::value; otherwise, false template <class T>
struct is_unsigned; If is_arithmetic<T>::value is true, the same result as integral_constant<bool, T(0) < T(-1)>::value; otherwise, false template <class T, class... Args>
struct is_constructible; see below T and all types in the parameter pack Args shall be complete types, (possibly cv-qualified) void, or arrays of unknown bound. template <class T>
struct is_default_constructible; is_constructible<T>::value is true. T shall be a complete type, (possibly cv-qualified) 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<T, const T&>::value, otherwise false. T shall be a complete type, (possibly cv-qualified) 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<T, T&&>::value, otherwise false. T shall be a complete type, (possibly cv-qualified) 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 (Clause [expr]). 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, (possibly cv-qualified) void, or arrays of unknown bound. template <class T>
struct is_copy_assignable; For a referenceable type T, the same result as is_assignable<T&, const T&>::value, otherwise false. T shall be a complete type, (possibly cv-qualified) 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<T&, T&&>::value, otherwise false. T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. template <class T>
struct is_destructible; For reference types, is_destructible<T>::value is true.
For incomplete types and function types, is_destructible<T>::value is false.
For object types and given U equal to remove_all_extents_t<T>, if the expression std::declval<U&>().~U() is well-formed when treated as an unevaluated operand (Clause [expr]),
then is_destructible<T>::value is true, otherwise it is false. T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. template <class T, class... Args>
struct
is_trivially_constructible; is_constructible<T,
Args...>::value 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, (possibly cv-qualified) void, or arrays of unknown bound. template <class T>
struct is_trivially_default_constructible; is_trivially_constructible<T>::value is true. T shall be a complete type, (possibly cv-qualified) 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<T, const T&>::value, otherwise false. T shall be a complete type, (possibly cv-qualified) 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<T, T&&>::value, otherwise false. T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. template <class T, class U>
struct is_trivially_assignable; is_assignable<T, U>::value 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, (possibly cv-qualified) 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<T&, const T&>::value, otherwise false. T shall be a complete type, (possibly cv-qualified) 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<T&, T&&>::value, otherwise false. T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. template <class T>
struct is_trivially_destructible; is_destructible<T>::value is true and the indicated destructor is known to be trivial. T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. template <class T, class... Args>
struct is_nothrow_constructible; is_constructible<T, Args...>::value 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, (possibly cv-qualified) void, or arrays of unknown bound. template <class T>
struct is_nothrow_default_constructible; is_nothrow_constructible<T>::value is true. T shall be a complete type, (possibly cv-qualified) 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<T, const T&>::value, otherwise false. T shall be a complete type, (possibly cv-qualified) 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<T, T&&>::value, otherwise false. T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. template <class T, class U>
struct is_nothrow_assignable; is_assignable<T, U>::value is true and the assignment is known not to throw any exceptions ([expr.unary.noexcept]). T and U shall be complete types, (possibly cv-qualified) 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<T&, const T&>::value, otherwise false. T shall be a complete type, (possibly cv-qualified) 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<T&, T&&>::value, otherwise false. T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. template <class T>
struct is_nothrow_destructible; is_destructible<T>::value is true and the indicated destructor is known not to throw any exceptions ([expr.unary.noexcept]). T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. template <class T>
struct has_virtual_destructor; T has a virtual destructor ([class.dtor]) If T is a non-union class type, T shall be a complete type.
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