SysTutorials

Linux Manual Pages › Section 3

stdcommon_type(3)

std::common_type - std::common_type

Synopsis

Defined in header<type_traits>
    template <class... T>
    (since C++ 11)
        struct 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.

      * Otherwise, if std::decay<decltype(false ? std::declval<const T1 &>() : std::declval<const T2 &>())>::type is a valid type, the member type denotes that type; (since C++20)       * Otherwise, there is no member type.

Member types

Name Definition type the common type for all T…

Helper types

template< class… T > (since C++14) using common_type_t = typename common_type<T…>::type;

Specializations

Users may specialize common_type for types T1 and T2 if

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:

                                          specializes the std::common_type trait std::common_type<std::chrono::duration> (class template specialization)                                           specializes the std::common_type trait std::common_type<std::chrono::time_point> (class template specialization)

Possible implementation

  // primary template (used for zero types)   template <class …T>   struct common_type {};

  //////// one type   template <class T>   struct common_type<T> : common_type<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. DR Applied to Behavior as published Correct behavior LWG_2141 C++11 common_type<int, int>::type is int&& decayed result type LWG_2408 C++11 common_type is not SFINAE-friendly made SFINAE-friendly LWG_2460 C++11 common_type specializations are nearly impossible to write reduced number of specializations needed

Examples

Demonstrates mixed-mode arithmetic on a user-defined class // Run this code

#include <iostream>
#include <type_traits>
template <class T>
struct Number {
T n;
};
template <class T, class U>
Number<typename std::common_type<T, U>::type> operator+(const Number<T> &lhs,
const Number<U> &rhs)
{
return {lhs.n + rhs.n};
}
int main()
{
Number<int> i1 = {1}, i2 = {2};
Number<double> d1 = {2.3}, d2 = {3.5};
std::cout << "i1i2: " << (i1 + i2).n << "\ni1d2: " << (i1 + d2).n << ‘\n’
<< "d1i2: " << (d1 + i2).n << "\nd1d2: " << (d1 + d2).n << ‘\n’;
}

Output:

  i1i2: 3   i1d2: 4.5   d1i2: 4.3   d1d2: 5.8