std::experimental::ranges::common_type
| Defined in header <experimental/ranges/type_traits>
|
||
| template< class... T > struct common_type; |
(ranges TS) | |
Determines the common type among all types T..., that is the type all T... can be implicitly converted to. If such a type exists (as determined according to the rules below), the member type names that type. Otherwise, there is no member type. The behavior is undefined if any of the types in T... is an incomplete type other than (possibly cv-qualified) void.
- If sizeof...(T) is zero, there is no member
type. - If sizeof...(T) is one (i.e.,
T...contains only one typeT0), the membertypenames the same type as std::decay_t<T0>. - If sizeof...(T) is two (i.e.,
T...contains exactly two typesT1andT2),
- If applying std::decay to at least one of
T1andT2produces a different type, the membertypenames the same type as ranges::common_type_t<std::decay_t<T1>, std::decay_t<T2>>, if it exists; if not, there is no membertype; - Otherwise, (and unless there is a user specialization for ranges::common_type<T1, T2>), if std::common_type_t<T1, T2> is well-formed, then the member
typedenotes that type; - Otherwise, the member
typedenotes the type std::decay_t<decltype(false ? std::declval<const T1&>() : std::declval<const T2&>())>, if that conditional expression is well-formed; if not, there is no membertype.
- If applying std::decay to at least one of
- If sizeof...(T) is greater than two (i.e.,
T...consists of the typesT1, T2, R...), then if ranges::common_type_t<T1, T2> exists, the membertypedenotes ranges::common_type_t<ranges::common_type_t<T1, T2>, R...> if such a type exists. In all other cases, there is no membertype.
Member types
| Name | Definition |
type
|
the common type for all T...
|
Helper types
| template< class... T > using common_type_t = typename common_type<T...>::type; |
||
Specializations
Users may specialize common_type for types T1 and T2 if
- At least one of
T1andT2depends on a user-defined type, and - std::decay is an identity transformation for both
T1andT2.
If such a specialization has a member named type, it must be a public and unambiguous member type that names a cv-unqualified non-reference type to which both T1 and T2 are explicitly convertible. Additionally, ranges::common_type_t<T1, T2> and ranges::common_type_t<T2, T1> must denote the same type.
A program that adds common_type specializations in violation of these rules has undefined behavior.
Notes
For arithmetic types not subject to promotion, the common type may be viewed as the type of the (possibly mixed-mode) arithmetic expression such as T0() + T1() + ... + Tn().
Example
| This section is incomplete Reason: no example |
See also
| (C++11) |
determines the common type of a group of types (class template) |
| determine the common reference type of a set of types (class template) |