This subclause describes components used by C++ programs, particularly in templates, to support the widest possible range of types, optimise template code usage, detect type related user errors, and perform type inference and transformation at compile time. It includes type classification traits, type property inspection traits, and type transformations. The type classification traits describe a complete taxonomy of all possible C++ types, and state where in that taxonomy a given type belongs. The type property inspection traits allow important characteristics of types or of combinations of types to be inspected. The type transformations allow certain properties of types to be manipulated.
A UnaryTypeTrait describes a property of a type. It shall be a class template that takes one template type argument and, optionally, additional arguments that help define the property being described. It shall be DefaultConstructible, CopyConstructible, and publicly and unambiguously derived, directly or indirectly, from its BaseCharacteristic, which is a specialization of the template integral_constant ([meta.help]), with the arguments to the template integral_constant determined by the requirements for the particular property being described. The member names of the BaseCharacteristic shall not be hidden and shall be unambiguously available in the UnaryTypeTrait.
A BinaryTypeTrait describes a relationship between two types. It shall be a class template that takes two template type arguments and, optionally, additional arguments that help define the relationship being described. It shall be DefaultConstructible, CopyConstructible, and publicly and unambiguously derived, directly or indirectly, from its BaseCharacteristic, which is a specialization of the template integral_constant ([meta.help]), with the arguments to the template integral_constant determined by the requirements for the particular relationship being described. The member names of the BaseCharacteristic shall not be hidden and shall be unambiguously available in the BinaryTypeTrait.
A TransformationTrait modifies a property of a type. It shall be a class template that takes one template type argument and, optionally, additional arguments that help define the modification. It shall define a nested type named type, which shall be a synonym for the modified type.
namespace std {
// [meta.help], helper class:
template <class T, T v> struct integral_constant;
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
// [meta.unary.cat], primary type categories:
template <class T> struct is_void;
template <class T> struct is_integral;
template <class T> struct is_floating_point;
template <class T> struct is_array;
template <class T> struct is_pointer;
template <class T> struct is_lvalue_reference;
template <class T> struct is_rvalue_reference;
template <class T> struct is_member_object_pointer;
template <class T> struct is_member_function_pointer;
template <class T> struct is_enum;
template <class T> struct is_union;
template <class T> struct is_class;
template <class T> struct is_function;
// [meta.unary.comp], composite type categories:
template <class T> struct is_reference;
template <class T> struct is_arithmetic;
template <class T> struct is_fundamental;
template <class T> struct is_object;
template <class T> struct is_scalar;
template <class T> struct is_compound;
template <class T> struct is_member_pointer;
// [meta.unary.prop], type properties:
template <class T> struct is_const;
template <class T> struct is_volatile;
template <class T> struct is_trivial;
template <class T> struct is_trivially_copyable;
template <class T> struct is_standard_layout;
template <class T> struct is_pod;
template <class T> struct is_literal_type;
template <class T> struct is_empty;
template <class T> struct is_polymorphic;
template <class T> struct is_abstract;
template <class T> struct is_signed;
template <class T> struct is_unsigned;
template <class T, class... Args> struct is_constructible;
template <class T> struct is_default_constructible;
template <class T> struct is_copy_constructible;
template <class T> struct is_move_constructible;
template <class T, class U> struct is_assignable;
template <class T> struct is_copy_assignable;
template <class T> struct is_move_assignable;
template <class T> struct is_destructible;
template <class T, class... Args> struct is_trivially_constructible;
template <class T> struct is_trivially_default_constructible;
template <class T> struct is_trivially_copy_constructible;
template <class T> struct is_trivially_move_constructible;
template <class T, class U> struct is_trivially_assignable;
template <class T> struct is_trivially_copy_assignable;
template <class T> struct is_trivially_move_assignable;
template <class T> struct is_trivially_destructible;
template <class T, class... Args> struct is_nothrow_constructible;
template <class T> struct is_nothrow_default_constructible;
template <class T> struct is_nothrow_copy_constructible;
template <class T> struct is_nothrow_move_constructible;
template <class T, class U> struct is_nothrow_assignable;
template <class T> struct is_nothrow_copy_assignable;
template <class T> struct is_nothrow_move_assignable;
template <class T> struct is_nothrow_destructible;
template <class T> struct has_virtual_destructor;
// [meta.unary.prop.query], type property queries:
template <class T> struct alignment_of;
template <class T> struct rank;
template <class T, unsigned I = 0> struct extent;
// [meta.rel], type relations:
template <class T, class U> struct is_same;
template <class Base, class Derived> struct is_base_of;
template <class From, class To> struct is_convertible;
// [meta.trans.cv], const-volatile modifications:
template <class T> struct remove_const;
template <class T> struct remove_volatile;
template <class T> struct remove_cv;
template <class T> struct add_const;
template <class T> struct add_volatile;
template <class T> struct add_cv;
// [meta.trans.ref], reference modifications:
template <class T> struct remove_reference;
template <class T> struct add_lvalue_reference;
template <class T> struct add_rvalue_reference;
// [meta.trans.sign], sign modifications:
template <class T> struct make_signed;
template <class T> struct make_unsigned;
// [meta.trans.arr], array modifications:
template <class T> struct remove_extent;
template <class T> struct remove_all_extents;
// [meta.trans.ptr], pointer modifications:
template <class T> struct remove_pointer;
template <class T> struct add_pointer;
// [meta.trans.other], other transformations:
template <std::size_t Len,
std::size_t Align = default-alignment> // see [meta.trans.other]
struct aligned_storage;
template <std::size_t Len, class... Types> struct aligned_union;
template <class T> struct decay;
template <bool, class T = void> struct enable_if;
template <bool, class T, class F> struct conditional;
template <class... T> struct common_type;
template <class T> struct underlying_type;
template <class> class result_of; // not defined
template <class F, class... ArgTypes> class result_of<F(ArgTypes...)>;
} // namespace std
The behavior of a program that adds specializations for any of the class templates defined in this subclause is undefined unless otherwise specified.
namespace std {
template <class T, T v>
struct integral_constant {
static constexpr T value = v;
typedef T value_type;
typedef integral_constant<T,v> type;
constexpr operator value_type() { return value; }
};
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
}
The class template integral_constant and its associated typedefs true_type and false_type are used as base classes to define the interface for various type traits.
This sub-clause contains templates that may be used to query the properties of a type at compile time.
Each of these templates shall be a UnaryTypeTrait ([meta.rqmts]) with a BaseCharacteristic of true_type if the corresponding condition is true, otherwise false_type.
The primary type categories correspond to the descriptions given in section [basic.types] of the C++ standard.
For any given type T, the result of applying one of these templates to T and to cv-qualified T shall yield the same result.
[ Note: For any given type T, exactly one of the primary type categories has a value member that evaluates to true. — end note ]
| Template | Condition | Comments |
|
template <class T> struct is_void; | T is void | |
|
template <class T> struct is_integral; | T is an integral type ([basic.fundamental]) | |
|
template <class T> struct is_floating_point; | T is a floating point type ([basic.fundamental]) | |
|
template <class T> struct is_array; | T is an array type ([basic.compound]) of known or unknown extent | Class template array ([array]) is not an array type. |
|
template <class T> struct is_pointer; | T is a pointer type ([basic.compound]) | Includes pointers to functions but not pointers to non-static members. |
|
template <class T> struct is_lvalue_reference; | T is an lvalue reference type ([dcl.ref]) | |
|
template <class T> struct is_rvalue_reference; | T is an rvalue reference type ([dcl.ref]) | |
|
template <class T> struct is_member_object_pointer; | T is a pointer to non-static data member | |
|
template <class T> struct is_member_function_pointer; | T is a pointer to non-static member function | |
|
template <class T> struct is_enum; | T is an enumeration type ([basic.compound]) | |
|
template <class T> struct is_union; | T is a union type ([basic.compound]) | |
|
template <class T> struct is_class; | T is a class type but not a union type ([basic.compound]) | |
|
template <class T> struct is_function; | T is a function type ([basic.compound]) |
These templates provide convenient compositions of the primary type categories, corresponding to the descriptions given in section [basic.types].
For any given type T, the result of applying one of these templates to T, and to cv-qualified T shall yield the same result.
| Template | Condition | Comments |
|
template <class T> struct is_reference; | T is an lvalue reference or an rvalue reference | |
|
template <class T> struct is_arithmetic; | T is an arithmetic type ([basic.fundamental]) | |
|
template <class T> struct is_fundamental; | T is a fundamental type ([basic.fundamental]) | |
|
template <class T> struct is_object; | T is an object type ([basic.types]) | |
|
template <class T> struct is_scalar; | T is a scalar type ([basic.types]) | |
|
template <class T> struct is_compound; | T is a compound type ([basic.compound]) | |
|
template <class T> struct is_member_pointer; | T is a pointer to non-static data member or non-static member function |
These templates provide access to some of the more important properties of types.
It is unspecified whether the library defines any full or partial specializations of any of these templates.
For all of the class templates X declared in this Clause, instantiating that template with a template-argument that is a class template specialization may result in the implicit instantiation of the template argument if and only if the semantics of X require that the argument must be a complete type.
| 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]) | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_trivially_copyable; | T is a trivially copyable type ([basic.types]) | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_standard_layout; | T is a standard-layout type ([basic.types]) | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_pod; | T is a POD type ([basic.types]) | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_literal_type; | T is a literal type ([basic.types]) | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| 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. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_polymorphic; | T is a polymorphic class ([class.virtual]) | T shall be a complete type, type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_abstract; | T is an abstract class ([class.abstract]) | T shall be a complete type, type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_signed; | is_arithmetic<T>::value && T(-1) < T(0) | |
| template <class T> struct is_unsigned; | is_arithmetic<T>::value && T(0) < T(-1) | |
| 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; | is_constructible<T, const 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_move_constructible; | is_constructible<T, T&&>::value is true. | 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; | is_assignable<T&, const 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_move_assignable; | is_assignable<T&, 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_destructible; |
For a complete type T and given template <class U> struct test { U u; };, test<T>::~test() is not deleted. | 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; | is_trivially_constructible<T, const 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_move_constructible; | is_trivially_constructible<T, T&&>::value is true. | 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; | is_trivially_assignable<T&, const 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_move_assignable; | is_trivially_assignable<T&, 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_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; | is_nothrow_constructible<T, const 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_move_constructible; | is_nothrow_constructible<T, T&&>::value is true. | 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; | is_nothrow_assignable<T&, const 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_move_assignable; | is_nothrow_assignable<T&, 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_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]) | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
[ Example:
is_const<const volatile int>::value // true is_const<const int*>::value // false is_const<const int&>::value // false is_const<int[3]>::value // false is_const<const int[3]>::value // true
— end example ]
[ Example:
remove_const<const volatile int>::type // volatile int remove_const<const int* const>::type // const int* remove_const<const int&>::type // const int& remove_const<const int[3]>::type // int[3]
— end example ]
Given the following function prototype:
template <class T> typename add_rvalue_reference<T>::type create();
the predicate condition for a template specialization is_constructible<T, Args...> shall be satisfied if and only if the following variable definition would be well-formed for some invented variable t:
T t(create<Args>()...);
[ Note: These tokens are never interpreted as a function declaration. — end note ] Access checking is performed as if in a context unrelated to T and any of the Args. Only the validity of the immediate context of the variable initialization is considered. [ Note: The evaluation of the initialization 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 ]
This sub-clause contains templates that may be used to query properties of types at compile time.
| Template | Value |
|
template <class T> struct alignment_of; |
alignof(T). Requires: alignof(T) shall be a valid expression ([expr.alignof]) |
| template <class T> struct rank; | If T names an array type, an integer value representing the number of dimensions of T; otherwise, 0. |
| template <class T, unsigned I = 0> struct extent; | If T is not an array type, or if it has rank less than or equal to I, or if I is 0 and T has type “array of unknown bound of U”, then 0; otherwise, the bound ([dcl.array]) of the I'th dimension of T, where indexing of I is zero-based |
[ Example:
// the following assertions hold:
assert(rank<int>::value == 0);
assert(rank<int[2]>::value == 1);
assert(rank<int[][4]>::value == 2);
— end example ]
[ Example:
// the following assertions hold:
assert(extent<int>::value == 0);
assert(extent<int[2]>::value == 2);
assert(extent<int[2][4]>::value == 2);
assert(extent<int[][4]>::value == 0);
assert((extent<int, 1>::value) == 0);
assert((extent<int[2], 1>::value) == 0);
assert((extent<int[2][4], 1>::value) == 4);
assert((extent<int[][4], 1>::value) == 4);
— end example ]
This sub-clause contains templates that may be used to query relationships between types at compile time.
Each of these templates shall be a BinaryTypeTrait ([meta.rqmts]) with a BaseCharacteristic of true_type if the corresponding condition is true, otherwise false_type.
| Template | Condition | Comments |
|
template <class T, class U> struct is_same; | T and U name the same type with the same cv-qualifications | |
| template <class Base, class Derived> struct is_base_of; | Base is a base class of Derived ([class.derived]) without regard to cv-qualifiers or Base and Derived are not unions and name the same class type without regard to cv-qualifiers | If Base and Derived are class types and are different types (ignoring possible cv-qualifiers) then Derived shall be a complete type. [ Note: Base classes that are private, protected, or ambiguous are, nonetheless, base classes. — end note ] |
| template <class From, class To> struct is_convertible; | see below | From and To shall be complete types, arrays of unknown bound, or (possibly cv-qualified) void types. |
[ Example:
struct B {};
struct B1 : B {};
struct B2 : B {};
struct D : private B1, private B2 {};
is_base_of<B, D>::value // true
is_base_of<const B, D>::value // true
is_base_of<B, const D>::value // true
is_base_of<B, const B>::value // true
is_base_of<D, B>::value // false
is_base_of<B&, D&>::value // false
is_base_of<B[3], D[3]>::value // false
is_base_of<int, int>::value // false
— end example ]
Given the following function prototype:
template <class T> typename add_rvalue_reference<T>::type create();
the predicate condition for a template specialization is_convertible<From, To> shall be satisfied if and only if the return expression in the following code would be well-formed, including any implicit conversions to the return type of the function:
To test() {
return create<From>();
}
[ Note: This requirement gives well defined results for reference types, void types, array types, and function types. — end note ] Access checking is performed as if in a context unrelated to To and From. Only the validity of the immediate context of the expression of the return-statement (including conversions to the return type) is considered. [ Note: The evaluation of the conversion 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 ]
This sub-clause contains templates that may be used to transform one type to another following some predefined rule.
Each of the templates in this subclause shall be a TransformationTrait ([meta.rqmts]).
| Template | Comments |
|
template <class T> struct remove_const; | The member typedef type shall name the same type as T except that any top-level const-qualifier has been removed. [ Example: remove_const<const volatile int>::type evaluates to volatile int, whereas remove_const<const int*>::type evaluates to const int*. — end example ] |
|
template <class T> struct remove_volatile; | The member typedef type shall name the same type as T except that any top-level volatile-qualifier has been removed. [ Example: remove_volatile<const volatile int>::type evaluates to const int, whereas remove_volatile<volatile int*>::type evaluates to volatile int*. — end example ] |
|
template <class T> struct remove_cv; | The member typedef type shall be the same as T except that any top-level cv-qualifier has been removed. [ Example: remove_cv<const volatile int>::type evaluates to int, whereas remove_cv<const volatile int*>::type evaluates to const volatile int*. — end example ] |
|
template <class T> struct add_const; | If T is a reference, function, or top-level const-qualified type, then type shall name the same type as T, otherwise T const. |
|
template <class T> struct add_volatile; | If T is a reference, function, or top-level volatile-qualified type, then type shall name the same type as T, otherwise T volatile. |
|
template <class T> struct add_cv; | The member typedef type shall name the same type as add_const<typename add_volatile<T>::type>::type. |
| Template | Comments |
|
template <class T> struct remove_reference; | If T has type “reference to T1” then the member typedef type shall name T1; otherwise, type shall name T. |
| template <class T> struct add_lvalue_reference; | If T names an object or function type then the member typedef type shall name T&; otherwise, if T names a type “rvalue reference to T1” then the member typedef type shall name T1&; otherwise, type shall name T. |
| template <class T> struct add_rvalue_reference; | If T names an object or function type then the member typedef type shall name T&&; otherwise, type shall name T. [ Note: This rule reflects the semantics of reference collapsing ([dcl.ref]). For example, when a type T names a type T1&, the type add_rvalue_reference<T>::type is not an rvalue reference. — end note ] |
| Template | Comments |
|
template <class T> struct make_signed; |
If T names a (possibly cv-qualified) signed integer
type ([basic.fundamental]) then the member typedef
type shall name the type T; otherwise,
if T names a (possibly cv-qualified) unsigned integer
type then type shall name the corresponding
signed integer type, with the same cv-qualifiers as T;
otherwise, type shall name the signed integer type with smallest
rank ([conv.rank]) for which
sizeof(T) == sizeof(type), with the same
cv-qualifiers as T. Requires: T shall be a (possibly cv-qualified) integral type or enumeration but not a bool type. |
|
template <class T> struct make_unsigned; |
If T names a (possibly cv-qualified) unsigned integer
type ([basic.fundamental]) then the member typedef
type shall name the type T; otherwise,
if T names a (possibly cv-qualified) signed integer
type then type shall name the corresponding
unsigned integer type, with the same cv-qualifiers as T;
otherwise, type shall name the unsigned integer type with smallest
rank ([conv.rank]) for which
sizeof(T) == sizeof(type), with the same
cv-qualifiers as T. Requires: T shall be a (possibly cv-qualified) integral type or enumeration but not a bool type. |
| Template | Comments |
|
template <class T> struct remove_extent; | If T names a type “array of U”, the member typedef type shall be U, otherwise T. [ Note: For multidimensional arrays, only the first array dimension is removed. For a type “array of const U”, the resulting type is const U. — end note ] |
|
template <class T> struct remove_all_extents; | If T is “multi-dimensional array of U”, the resulting member typedef type is U, otherwise T. |
[Example
// the following assertions hold:
assert((is_same<remove_extent<int>::type, int>::value));
assert((is_same<remove_extent<int[2]>::type, int>::value));
assert((is_same<remove_extent<int[2][3]>::type, int[3]>::value));
assert((is_same<remove_extent<int[][3]>::type, int[3]>::value));
— end example ]
[Example
// the following assertions hold:
assert((is_same<remove_all_extents<int>::type, int>::value));
assert((is_same<remove_all_extents<int[2]>::type, int>::value));
assert((is_same<remove_all_extents<int[2][3]>::type, int>::value));
assert((is_same<remove_all_extents<int[][3]>::type, int>::value));
— end example ]
| Template | Comments |
|
template <class T> struct remove_pointer; | If T has type “(possibly cv-qualified) pointer to T1” then the member typedef type shall name T1; otherwise, it shall name T. |
|
template <class T> struct add_pointer; | The member typedef type shall name the same type as remove_reference<T>::type*. |
| Template | Condition | Comments |
|
template <std::size_t Len, std::size_t Align = default-alignment> struct aligned_storage; | Len shall not be zero. Align shall be equal to alignof(T) for some type T or to default-alignment. | The value of default-alignment shall be the most stringent alignment requirement for any C++ object type whose size is no greater than Len ([basic.types]). The member typedef type shall be a POD type suitable for use as uninitialized storage for any object whose size is at most Len and whose alignment is a divisor of Align. |
| template <std::size_t Len, class... Types> struct aligned_union; | At least one type is provided. | The member typedef type shall be a POD type suitable for use as uninitialized storage for any object whose type is listed in Types; its size shall be at least Len. The static member alignment_value shall be an integral constant of type std::size_t whose value is the strictest alignment of all types listed in Types. |
| template <class T> struct decay; | Let U be remove_reference<T>::type. If is_array<U>::value is true, the member typedef type shall equal remove_extent<U>::type*. If is_function<U>::value is true, the member typedef type shall equal add_pointer<U>::type. Otherwise the member typedef type equals remove_cv<U>::type. [ Note: This behavior is similar to the lvalue-to-rvalue ([conv.lval]), array-to-pointer ([conv.array]), and function-to-pointer ([conv.func]) conversions applied when an lvalue expression is used as an rvalue, but also strips cv-qualifiers from class types in order to more closely model by-value argument passing. — end note ] | |
| template <bool B, class T = void> struct enable_if; | If B is true, the member typedef type shall equal T; otherwise, there shall be no member typedef type. | |
| template <bool B, class T, class F> struct conditional; | If B is true, the member typedef type shall equal T. If B is false, the member typedef type shall equal F. | |
| template <class... T> struct common_type; | The member typedef type shall be defined as set out below. All types in the parameter pack T shall be complete or (possibly cv) void. A program may specialize this trait if at least one template parameter in the specialization is a user-defined type. [ Note: Such specializations are needed when only explicit conversions are desired among the template arguments. — end note ] | |
| template <class T> struct underlying_type; | T shall be an enumeration type ([dcl.enum]) | The member typedef type shall name the underlying type of T. |
| template <class Fn, class... ArgTypes> struct result_of<Fn(ArgTypes...)>; | Fn shall be a callable type ([func.def]), reference to function, or reference to callable type. The expression decltype(INVOKE(declval<Fn>(), declval<ArgTypes>()...)) shall be well formed. | The member typedef type shall name the type decltype(INVOKE(declval<Fn>(), declval<ArgTypes>()...)) |
[ Note: A typical implementation would define aligned_storage as:
template <std::size_t Len, std::size_t Alignment>
struct aligned_storage {
typedef struct {
alignas(Alignment) unsigned char __data[Len];
} type;
};
— end note ]
It is implementation-defined whether any extended alignment is supported ([basic.align]).
The nested typedef common_type::type shall be defined as follows:
template <class ...T> struct common_type;
template <class T>
struct common_type<T> {
typedef T type;
};
template <class T, class U>
struct common_type<T, U> {
typedef decltype(true ? declval<T>() : declval<U>()) type;
};
template <class T, class U, class... V>
struct common_type<T, U, V...> {
typedef typename common_type<typename common_type<T, U>::type, V...>::type type;
};
[ Example: Given these definitions:
typedef bool (&PF1)();
typedef short (*PF2)(long);
struct S {
operator PF2() const;
double operator()(char, int&);
void fn(long) const;
char data;
};
typedef void (S::*PMF)(long) const;
typedef char S::*PMD;
the following assertions will hold:
static_assert(is_same<result_of<S(int)>::type, short>::value, "Error!"); static_assert(is_same<result_of<S&(unsigned char, int&)>::type, double>::value, "Error!"); static_assert(is_same<result_of<PF1()>::type, bool>::value, "Error!"); static_assert(is_same<result_of<PMF(unique_ptr<S>, int)>::type, void>::value, "Error!"); static_assert(is_same<result_of<PMD(S)>::type, char&&>::value, "Error!"); static_assert(is_same<result_of<PMD(const S*)>::type, const char&>::value, "Error!");
— end example ]