std:: common_reference

Détermine le type de référence commun des types T... , c'est-à-dire le type vers lequel tous les types dans T... peuvent être convertis ou liés. Si un tel type existe (tel que déterminé selon les règles ci-dessous), le membre type nomme ce type. Sinon, il n'y a pas de membre type . Le comportement est indéfini si l'un des types dans T... est un type incomplet autre que (éventuellement qualifié cv) void .

Lorsqu'on lui donne des types référence, common_reference tente de trouver un type référence auquel tous les types référence fournis peuvent être liés, mais peut retourner un type non-référence s'il ne parvient pas à trouver un tel type référence.

• Si sizeof... ( T ) est zéro, il n'y a pas de membre type .
• Si sizeof... ( T ) est un (c'est-à-dire que T... contient seulement un type T0 ), le membre type désigne le même type que T0 .
• Si sizeof... ( T ) est deux (c'est-à-dire que T... contient deux types T1 et T2 ):
  • Soit le type S le type de référence commun simple de T1 et T2 (tel que défini ci-dessous). Le type membre type désigne S si toutes les conditions suivantes sont satisfaites :
    • T1 et T2 sont tous deux des types référence
    • S est bien formé

• Sinon, si std :: basic_common_reference < std:: remove_cvref_t < T1 > , std:: remove_cvref_t < T2 > , T1Q, T2Q > :: type existe, où TiQ est un alias template unaire tel que TiQ < U > est U avec l'ajout des qualificateurs cv et de référence de Ti , alors le type membre type désigne ce type ;

• • Sinon, si decltype ( false ? val < T1 > ( ) : val < T2 > ( ) ) , où val est un modèle de fonction template < class T > T val ( ) ; , est un type valide, alors le type membre type désigne ce type ;
  • Sinon, si std:: common_type_t < T1, T2 > est un type valide, alors le type membre type désigne ce type ;
  • Sinon, il n'y a pas de membre type .
• Si sizeof... ( T ) est supérieur à deux (c'est-à-dire, T... contient les types T1, T2, R... ), alors si std :: common_reference_t < T1, T2 > existe, le membre type dénote std :: common_reference_t < std :: common_reference_t < T1, T2 > , R... > si un tel type existe. Dans tous les autres cas, il n'y a pas de membre type .

Le type de référence commun simple de deux types de référence T1 et T2 est défini comme suit :

• Si T1 est cv1 X& et T2 est cv2 Y& (c'est-à-dire que les deux sont des types de référence lvalue) : leur type de référence commun simple est decltype ( false ? std:: declval < cv12 X & > ( ) : std:: declval < cv12 Y & > ( ) ) , où cv12 est l'union de cv1 et cv2 , si ce type existe et est un type de référence ;
• Si T1 et T2 sont tous deux des types de référence rvalue : si le type de référence commun simple de T1& et T2& (déterminé selon le point précédent) existe, alors soit C le type de référence rvalue correspondant à ce type. Si std:: is_convertible_v < T1, C > et std:: is_convertible_v < T2, C > sont tous deux true , alors le type de référence commun simple de T1 et T2 est C ;
• Sinon, l'un des deux types doit être un type de référence lvalue A& et l'autre doit être un type de référence rvalue B&& ( A et B peuvent être qualifiés cv). Soit D le type de référence commun simple de A & et B const & , s'il existe. Si D existe et std:: is_convertible_v < B && , D > est true , alors le type de référence commun simple est D ;
• Sinon, il n'y a pas de type de référence commun simple.

Voir Opérateur conditionnel pour la définition du type d'expression false ? X : Y comme celles utilisées ci-dessus.

Types membres

Types auxiliaires

Le modèle de classe basic_common_reference est un point de personnalisation qui permet aux utilisateurs d'influencer le résultat de common_reference pour les types définis par l'utilisateur (généralement des références proxy). Le modèle principal est vide.

Spécialisations

Un programme peut spécialiser std :: basic_common_reference < T, U, TQual, UQual > sur les deux premiers paramètres T et U si std:: is_same_v < T, std:: decay_t < T >> et std:: is_same_v < U, std:: decay_t < U >> sont tous deux true et au moins l'un d'entre eux dépend d'un type défini par le programme.

Si une telle spécialisation possède un membre nommé type , celui-ci doit être un membre public et non ambigu désignant un type vers lequel TQual < T > et UQual < U > sont convertibles. De plus, std :: basic_common_reference < T, U, TQual, UQual > :: type et std :: basic_common_reference < U, T, UQual, TQual > :: type doivent désigner le même type.

Un programme ne peut pas spécialiser basic_common_reference sur le troisième ou quatrième paramètre, ni spécialiser common_reference lui-même. Un programme qui ajoute des spécialisations en violation de ces règles a un comportement indéfini.

La bibliothèque standard fournit les spécialisations suivantes de basic_common_reference :

Notes

Exemples

#include <concepts>
#include <type_traits>
static_assert(
    std::same_as<
        int&,
        std::common_reference_t<
            std::add_lvalue_reference_t<int>,
            std::add_lvalue_reference_t<int>&,
            std::add_lvalue_reference_t<int>&&,
            std::add_lvalue_reference_t<int>const,
            std::add_lvalue_reference_t<int>const&
        >
    >
);
int main() {}

Voir aussi