std::common_type

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.

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 in unevaluated context, with arbitrary first argument of type bool and with xvalues of type T1 and T2 (since C++17)std::declval<T1>() and std::declval<T2>() (until C++17) as the 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).

If sizeof...(T) is zero or if there is no common type, the member type is not defined (std::common_type is SFINAE-friendly)

(since C++17)

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 ? std::declval<T>() : std::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] Notes

For arithmetic types, the common type may be viewed as the type of the (possibly mixed-mode) arithmetic expression such as T0() + T1() + ... + Tn().

[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

Language
Standard library headers
Concepts
Utilities library
Strings library
Containers library
Algorithms library
Iterators library
Numerics library
Input/output library
Localizations library
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)
Technical Specifications

Type support (basic types, RTTI, type traits)
Dynamic memory management
Error handling
Program utilities
Variadic functions
Date and time
Function objects
initializer_list (C++11)
bitset
hash (C++11)
Relational operators
rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=
Pairs and tuples
pair
tuple (C++11)
piecewise_construct_t (C++11)
piecewise_construct (C++11)
integer_sequence (C++14)
Swap, forward and move
swap
exchange (C++14)
forward (C++11)
move (C++11)
move_if_noexcept (C++11)
Type operations
declval (C++11)
as_const (C++17)

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

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)

std::common_type

Contents

[edit] Member types

[edit] Helper types

[edit] Specializations

[edit] Possible implementation

[edit] Notes

[edit] Examples

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