std::experimental::ranges:: common_reference

Definiert im Header <experimental/ranges/type_traits>
template < class ... T > struct common_reference ;		(ranges TS)

Bestimmt den gemeinsamen Referenztyp der Typen T... , also den Typ, zu dem alle Typen in T... konvertiert oder gebunden werden können. Falls ein solcher Typ existiert (gemäß den nachfolgenden Regeln bestimmt), benennt das Mitglied type diesen Typ. Andernfalls existiert kein Mitglied type . Das Verhalten ist undefiniert, falls einer der Typen in T... ein unvollständiger Typ ist, außer (möglicherweise cv-qualifiziertem) void .

Wenn Referenztypen gegeben sind, common_reference versucht, einen Referenztyp zu finden, an den die gelieferten Referenztypen alle gebunden werden können, kann aber einen Nicht-Referenztyp zurückgeben, falls es keinen solchen Referenztyp finden kann.

• Wenn sizeof... ( T ) null ist, existiert kein Member type .
• Wenn sizeof... ( T ) eins ist (d.h. T... enthält nur einen Typ T0 ), bezeichnet der Member type denselben Typ wie T0 .
• Wenn sizeof... ( T ) zwei ist (d.h. T... enthält zwei Typen T1 und T2 ):
  • Wenn T1 und T2 beide Referenztypen sind und der einfache gemeinsame Referenztyp S von T1 und T2 (wie unten definiert) existiert, dann bezeichnet der Member-Typ type den Typ S ;
  • Andernfalls, wenn basic_common_reference < T1R, T2R, T1Q, T2Q > :: type existiert, wobei TiR für std:: remove_cv_t < std:: remove_reference_t < Ti >> steht und TiQ ein Alias-Template ist, sodass TiQ < TiR > gleich Ti ist, dann bezeichnet der Member-Typ type diesen Typ;
  • Andernfalls, wenn decltype ( false ? val < T1 > ( ) : val < T2 > ( ) ) , wobei val ein Funktions-Template template < class T > T val ( ) ; ist, einen gültigen Typ bezeichnet, dann bezeichnet der Member-Typ type diesen Typ;
  • Andernfalls, wenn ranges:: common_type_t < T1, T2 > ein gültiger Typ ist, dann bezeichnet der Member-Typ type diesen Typ;
  • Andernfalls existiert kein Member-Typ.
• Wenn sizeof... ( T ) größer als zwei ist (d.h. T... besteht aus den Typen T1, T2, R... ), dann bezeichnet der Member type den Typ ranges :: common_reference_t < ranges :: common_reference_t < T1, T2 > , R... > , falls ein solcher Typ existiert. In allen anderen Fällen existiert kein Member type .

Der einfache gemeinsame Referenztyp von zwei Referenztypen T1 und T2 wird wie folgt definiert:

• Wenn T1 cv1 X & und T2 cv2 Y & ist (d.h. beide sind Lvalue-Referenztypen): ihr einfacher gemeinsamer Referenztyp ist decltype ( false ? std:: declval < cv12 X & > ( ) : std:: declval < cv12 Y & > ( ) ) , wobei cv12 die Vereinigung von cv1 und cv2 ist, falls dieser Typ existiert und ein Referenztyp ist.
• Wenn T1 und T2 beide Rvalue-Referenztypen sind: falls der einfache gemeinsame Referenztyp von T1 & und T2 & (bestimmt gemäß vorherigem Aufzählungspunkt) existiert, dann sei C der entsprechende Rvalue-Referenztyp dieses Typs. Wenn std:: is_convertible < T1, C > :: value und std:: is_convertible < T2, C > :: value beide true sind, dann ist der einfache gemeinsame Referenztyp von T1 und T2 C .
• Andernfalls muss einer der beiden Typen ein Lvalue-Referenztyp A & und der andere ein Rvalue-Referenztyp B && sein ( A und B könnten CV-qualifiziert sein). Sei D der einfache gemeinsame Referenztyp von A & und B const & , falls vorhanden. Wenn D existiert und std:: is_convertible < B && , D > :: value true ist, dann ist der einfache gemeinsame Referenztyp D .
• Andernfalls gibt es keinen einfachen gemeinsamen Referenztyp.

Inhaltsverzeichnis 1 Membertypen 2 Hilfstypen 3 Spezialisierungen 4 Anmerkungen 5 Beispiel 6 Siehe auch

Mitgliedertypen

Name	Definition
type	der gemeinsame Referenztyp für alle T...

Hilfstypen

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

Die Klassenvorlage basic_common_reference ist ein Anpassungspunkt, der es Benutzern ermöglicht, das Ergebnis von common_reference für benutzerdefinierte Typen (typischerweise Proxy-Referenzen) zu beeinflussen. Die primäre Vorlage ist leer.

Spezialisierungen

Ein Programm kann basic_common_reference<T, U, TQual, UQual> für die ersten beiden Parameter T und U spezialisieren, falls std:: is_same < T, std:: decay_t < T >> und std:: is_same < U, std:: decay_t < U >> beide wahr sind und mindestens einer von ihnen von einem programmdefinierten Typ abhängt.

Falls eine solche Spezialisierung ein Mitglied namens type besitzt, muss es ein öffentlicher und eindeutiger Mitgliedstyp sein, der einen Typ bezeichnet, in den sowohl TQual < T > als auch UQual < U > konvertierbar sind. Zusätzlich müssen ranges :: basic_common_reference < T, U, TQual, UQual > :: type und ranges :: basic_common_reference < U, T, UQual, TQual > :: type denselben Typ bezeichnen.

Ein Programm darf basic_common_reference nicht für den dritten oder vierten Parameter spezialisieren, noch darf es common_reference selbst spezialisieren. Ein Programm, das entgegen diesen Regeln Spezialisierungen hinzufügt, hat undefiniertes Verhalten.

Hinweise

Dieser Abschnitt ist unvollständig

Beispiel

Dieser Abschnitt ist unvollständig Grund: Kein Beispiel

Siehe auch

common_type (C++11)	bestimmt den gemeinsamen Typ einer Gruppe von Typen (Klassen-Template)
common_type	bestimmt den gemeinsamen Typ einer Menge von Typen (Klassen-Template)
CommonReference	spezifiziert, dass zwei Typen einen gemeinsamen Referenztyp teilen (Konzept)