# std::common_type

From cppreference.com
< cpp‎ | types

Defined in header `<type_traits>` |  |
template< class... T > struct common_type; |  | (since C++11)

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, if there is a user specialization for std::common_type<T1, T2>, that specialization is used;
  - Otherwise, if std::decay<decltype(false ? std::declval<T1>() : std::declval<T2>())>::type is a valid type, the member `type` denotes that 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`.

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

If an instantiation of a template above depends, directly or indirectly, on an incomplete type, and that instantiation could yield a different result if that type were hypothetically completed, the behavior is undefined.

### 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; |  | (since C++14)

### 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:

std::common_type<std::chrono::duration> | specializes the std::common_type trait (class template specialization)
std::common_type<std::chrono::time_point> | specializes the std::common_type trait (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

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/types/common_type&oldid=109735"