std::common_type - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

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

- `std::common_type` may be specialized for custom types, e.g. std::chrono::time_point.
- For non-specialized `std::common_type`, the rules for determining the common type between every pair `T1, T2` are exactly the rules for determining the return type of the ternary conditional operator where `T1` and `T2` are the types of its second and the third operands. The common type is the result of std::decay applied to the type of the ternary conditional (since C++14).
- For arithmetic types, the common type may also be viewed as the type of the (possibly mixed-mode) arithmetic expression such as T0() + T1() + ... + Tn().

### [edit] Member types

Name | Definition
`type` | the common type for all `T...`

### [edit] Helper types

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

### [edit] Specializations

Custom specializations of the type trait std::common_type are allowed, as long as at least one parameter is a user-defined type (note that the behavior of a program that adds a specialization to any other class 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) [edit]
std::common_type<std::chrono::time_point> | specializes the std::common_type trait (class template specialization) [edit]

### [edit] Possible implementation

    template <class ...T> struct common_type;

    template <class T>
    struct common_type<T> {
        typedef decay_t<T> type;
    };

    template <class T, class U>
    struct common_type<T, U> {
        typedef decay_t<decltype(true ? declval<T>() : declval<U>())> type;
    };

    template <class T, class U, class... V>
    struct common_type<T, U, V...> {
        typedef common_type_t<common_type_t<T, U>, V...> type;
    };

### [edit] 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 "http://en.cppreference.com/mwiki/index.php?title=cpp/types/common_type&oldid=72375"