std::common_type — cppreference.com

De cppreference.com

Déclaré dans l'en-tête `<type_traits>`
`template< class... T > struct common_type;`		(depuis C++11)

Détermine le type commun entre tous les types T..., qui est du type tout T... peut être implicitement converti à .

Original:

Determines the common type among all types T..., that is the type all T... can be implicitly converted to.

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

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.

Types de membres


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

`type`	le type commun à tous `T...` Original: the common type for all `T...` The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Spécialisations

Spécialisations personnalisés de ce trait de type std::common_type sont autorisés. Les spécialisations suivantes sont déjà fournis par la bibliothèque standard:

Original:

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

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

Notes

Avec un argument de modèle unique, std::common_type<T>::type est exactement T, ce qui rend le C + + équivalent de boost::identity<T>

Original:

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

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

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

Exemple

Démontre en mode mixte arithmétique sur une classe définie par l'utilisateur

Original:

Demonstrates mixed-mode arithmetic on a user-defined class

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

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

Résultat :

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