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 peut être spécialisé pour les types personnalisés, par exemple 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.
• Pour les non-spécialisée std::common_type, les règles de détermination du type commun entre chaque paire T1, T2 sont exactement les règles servant à déterminer le type de retour de la opérateur conditionnel ternaire où T1 et T2 sont les types de son deuxième et les opérandes tiers .

  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 opérateur conditionnel ternaire 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.
• Pour les types arithmétiques, le type commun peut aussi être considéré comme le type de l'expression arithmétique (éventuellement en mode mixte) tels que 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.

[modifier] Types de membres

[modifier] Spécialisations

[modifier] Notes

[modifier] Mise en œuvre possible

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

[modifier] Exemple

#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