std::common_type

This page has been machine-translated from the English version of the wiki using Google Translate. The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here. Click here for the English version of this page

• std::common_type pode ser especializado para tipos personalizados, por exemplo, std::chrono::time_point.

  Original:

  std::common_type may be specialized for custom types, e.g. std::chrono::time_point.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Para os não-especializado std::common_type, as regras para determinar o tipo comum entre cada par T1, T2 são exatamente as regras para determinar o tipo de retorno do operador ternário condicional onde T1 e T2 são os tipos de seu segundo e terceiro os operandos.

  Original:

  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 operador ternário condicional where T1 and T2 are the types of its second and the third operands.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Para os tipos de aritmética, do tipo comum também pode ser visto como o tipo da expressão aritmética (possivelmente de modo misto) como T0() + T1() + ... + Tn().

  Original:

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

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

[editar] Tipos de membro

[editar] Especializações

[editar] Notas

[editar] Possível implementação

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;
};

[editar] Exemplo

#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';
}

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