Namespaces
Variants
Views
Actions

std::common_type

From cppreference.com
< cpp‎ | types
Revision as of 15:02, 12 January 2013 by SuperBoi45 (Talk | contribs)

 
 
 
Type support
Basic types
Fundamental types
Fixed width integer types (C++11)
Numeric limits
C numeric limits interface
Runtime type information
Type traits
Primary type categories
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Type properties
(C++11)
(C++11)
(C++11)
(C++14)
Supported operations
Relationships and property queries
(C++11)
(C++11)
(C++11)
(C++11)
Type modifications
(C++11)(C++11)(C++11)
Type transformations
(C++11)
(C++11)
common_type
(C++11)
(C++11)
Type trait constants
 

Template:ddcl list begin <tr class="t-dsc-header">

<td>
Defined in header <type_traits>
</td>

<td></td> <td></td> <tr class="t-dcl-sep"><td></td><td></td><td></td></tr>

<tr class="t-dcl ">

<td >
template< class... T >
struct common_type;
</td>

<td class="t-dcl-nopad"> </td> <td > (since C++11) </td> </tr> Template:ddcl list end

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

Contents

Member types

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

Specializations

Custom specializations of the type trait std::common_type are allowed. The following specializations are already provided by the standard library:

Template:cpp/chrono/duration/dcl list common typeTemplate:cpp/chrono/time point/dcl list common type

Notes

With a single template argument, std::common_type<T>::type is exactly T, which makes it the C++ equivalent of boost::identity<T>

Possible implementation

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

Examples

Demonstrates mixed-mode arithmetic on a user-defined class

#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

Demonstrates the use as the identity template

#include <type_traits>
#include <vector>
#include <iostream>
 
template <size_t N>
void fun(const int (&a)[N])
{
    std::cout << "Array overload: ";
    for (int n: a)
        std::cout << n << ' ';
    std::cout << '\n';
}
 
void fun(const std::vector<int>& v)
{
    std::cout << "Vector overload: ";
    for (int n: v)
        std::cout << n << ' ';
    std::cout << '\n';
}
 
int main()
{
    fun( {1, 2, 3} ); // calls the vector overload
    fun( std::common_type<int[]>::type {1, 2, 3} ); // calls the array overload
}

Output:

Vector overload: 1 2 3 
Array overload: 1 2 3