std::common_type

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.

• If sizeof...(T) is zero, there is no member type.
• If sizeof...(T) is one (i.e., T... contains only one type T0), the member type names the same type as std::common_type<T0, T0>::type if it exists; otherwise there is no member type.
• If sizeof...(T) is two (i.e., T... contains exactly two types T1 and T2),
  • If applying std::decay to at least one of T1 and T2 produces a different type, the member type names the same type as std::common_type<std::decay<T1>::type, std::decay<T2>::type>::type, if it exists; if not, there is no member type.
  • Otherwise, unless there is a user specialization for std::common_type<T1, T2>, the member type denotes the type std::decay<decltype(false ? std::declval<T1>() : std::declval<T2>())>::type, if that conditional expression is well-formed; if not, there is no member type.
• If sizeof...(T) is greater than two (i.e., T... consists of the types T1, T2, R...), then if std::common_type<T1, T2>::type exists, the member type denotes std::common_type<std::common_type<T1, T2>::type, R...>::type if such a type exists. In all other cases, there is no member type.

The types in the parameter pack T shall each be a complete type, (possibly cv-qualified) void, or an array of unknown bound. Otherwise, the behavior is undefined.

Member types

Helper types

Specializations

Users may specialize common_type for types T1 and T2 if.

• At least one of T1 and T2 depends on a user-defined type, and
• std::decay is an identity transformation for both T1 and T2.

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, std::common_type<T1, T2>::type and std::common_type<T2, T1>::type must denote the same type.

A program that adds common_type specializations in violation of these rules has undefined behavior.

Note that the behavior of a program that adds a specialization to any other template from <type_traits> is undefined.

The following specializations are already provided by the standard library:

Possible implementation

| // primary template (used for zero types) template <class ...T> struct common_type { }; //////// one type template <class T> struct common_type<T> { using type = std::decay_t<T>; }; //////// two types // default implementation for two types template<class T1, class T2> using cond_t = decltype(false ? std::declval<T1>() : std::declval<T2>()); template<class T1, class T2, class=void> struct common_type_2_default { }; template<class T1, class T2> struct common_type_2_default<T1, T2, std::void_t<cond_t<T1, T2>>> { using type = std::decay_t<cond_t<T1, T2>>; }; // dispatcher to decay the type before applying specializations template<class T1, class T2, class D1 = std::decay_t<T1>, class D2=std::decay_t<T2>> struct common_type_2_impl : common_type<D1, D2> {}; template<class D1, class D2> struct common_type_2_impl<D1, D2, D1, D2> : common_type_2_default<D1, D2> {}; template <class T1, class T2> struct common_type<T1, T2> : common_type_2_impl<T1, T2> { }; //////// 3+ types template<class AlwaysVoid, class T1, class T2, class...R> struct common_type_multi_impl { }; template< class T1, class T2, class...R> struct common_type_multi_impl<std::void_t<common_type_t<T1, T2>>, T1, T2, R...> : common_type<common_type_t<T1, T2>, R...> { }; template <class T1, class T2, class... R> struct common_type<T1, T2, R...> : common_type_multi_impl<void, T1, T2, R...> { }; |

|:----|

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().

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

Examples

Demonstrates mixed-mode arithmetic on a user-defined class.

Output:

Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.

http://en.cppreference.com/w/cpp/types/common_type