std::experimental::ranges:: common_reference

Défini dans l'en-tête <experimental/ranges/type_traits>
template < class ... T > struct common_reference ;		(ranges TS)

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, 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, T... contient deux types T1 et T2 ):
  • Si T1 et T2 sont tous deux des types référence, et que le type référence commun simple S de T1 et T2 (tel que défini ci-dessous) existe, alors le membre type type désigne S ;
  • Sinon, si basic_common_reference < T1R, T2R, T1Q, T2Q > :: type existe, où TiR est std:: remove_cv_t < std:: remove_reference_t < Ti >> et TiQ est un alias template tel que TiQ < TiR > est Ti , alors le membre type type désigne ce type ;
  • Sinon, si decltype ( false ? val < T1 > ( ) : val < T2 > ( ) ) , où val est un template de fonction template < class T > T val ( ) ; , dénote un type valide, alors le membre type type désigne ce type ;
  • Sinon, si ranges:: common_type_t < T1, T2 > est un type valide, alors le membre type 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... est constitué des types T1, T2, R... ), alors si ranges :: common_reference_t < T1, T2 > existe, le membre type dénote ranges :: common_reference_t < ranges :: 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 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 < T1, C > :: value et std:: is_convertible < T2, C > :: value 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 < B && , D > :: value 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.

Table des matières 1 Types membres 2 Types auxiliaires 3 Spécialisations 4 Notes 5 Exemple 6 Voir aussi

Types membres

Nom	Définition
type	le type de référence commun pour tous les T...

Types auxiliaires

template < class ... T > using common_reference_t = typename common_reference < T... > :: type ;
template < class T, class U, template < class > class TQual, template < class > class UQual > struct basic_common_reference { } ;

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 basic_common_reference<T, U, TQual, UQual> sur les deux premiers paramètres T et U si std:: is_same < T, std:: decay_t < T >> et std:: is_same < U, std:: decay_t < U >> sont tous deux vrais et qu'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 , il doit s'agir d'un type de membre public et non ambigu qui désigne un type vers lequel TQual < T > et UQual < U > sont convertibles. De plus, ranges :: basic_common_reference < T, U, TQual, UQual > :: type et ranges :: 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 les troisième ou quatrième paramètres, 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.

Notes

Cette section est incomplète

Exemple

Cette section est incomplète Raison : aucun exemple

Voir aussi

common_type (C++11)	détermine le type commun d'un groupe de types (modèle de classe)
common_type	détermine le type commun d'un ensemble de types (modèle de classe)
CommonReference	spécifie que deux types partagent un type de référence commun (concept)