std:: common_reference

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 beträgt (d.h. T... enthält nur einen Typ T0 ), bezeichnet der Member type denselben Typ wie T0 .
• Wenn sizeof... ( T ) zwei beträgt (d.h. T... enthält zwei Typen T1 und T2 ):
  • Sei Typ S der einfache gemeinsame Referenztyp von T1 und T2 (wie unten definiert). Der Member-Typ type bezeichnet S , wenn alle folgenden Bedingungen erfüllt sind:
    • T1 und T2 sind beide Referenztypen
    • S ist wohlgeformt

• Andernfalls, falls std :: basic_common_reference < std:: remove_cvref_t < T1 > , std:: remove_cvref_t < T2 > , T1Q, T2Q > :: type existiert, wobei TiQ ein unäres Alias-Template ist, sodass TiQ < U > U mit den zusätzlichen CV- und Referenzqualifizierern von Ti ist, dann benennt der Member-Typ type diesen Typ;

• • Andernfalls, falls decltype ( false ? val < T1 > ( ) : val < T2 > ( ) ) , wobei val ein Funktions-Template template < class T > T val ( ) ; ist, ein gültiger Typ ist, dann bezeichnet der Member-Typ type diesen Typ;
  • Andernfalls, falls std:: common_type_t < T1, T2 > ein gültiger Typ ist, dann bezeichnet der Member-Typ type diesen Typ;
  • Andernfalls existiert kein Member type .
• Falls sizeof... ( T ) größer als zwei ist (d.h., T... besteht aus den Typen T1, T2, R... ), dann bezeichnet der Member type std :: common_reference_t < std :: 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 Punkt) existiert, dann sei C der entsprechende Rvalue-Referenztyp dieses Typs. Wenn std:: is_convertible_v < T1, C > und std:: is_convertible_v < T2, C > 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_v < B && , D > true ist, dann ist der einfache gemeinsame Referenztyp D ;
• Andernfalls gibt es keinen einfachen gemeinsamen Referenztyp.

Siehe Bedingter Operator für die Definition des Typs von Ausdrücken false ? X : Y wie die oben verwendeten.

Mitgliedertypen

Hilfstypen

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 std :: basic_common_reference < T, U, TQual, UQual > für die ersten beiden Parameter T und U spezialisieren, falls std:: is_same_v < T, std:: decay_t < T >> und std:: is_same_v < U, std:: decay_t < U >> beide true sind und mindestens einer von ihnen von einem programmdefinierten Typ abhängt.

Falls eine solche Spezialisierung ein Mitglied namens type besitzt, muss es ein öffentliches und eindeutiges Mitglied sein, das einen Typ benennt, in den sowohl TQual < T > als auch UQual < U > konvertierbar sind. Zusätzlich müssen std :: basic_common_reference < T, U, TQual, UQual > :: type und std :: 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 Spezialisierungen entgegen diesen Regeln hinzufügt, hat undefiniertes Verhalten.

Die Standardbibliothek bietet folgende Spezialisierungen von basic_common_reference an:

Hinweise

Beispiele

#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() {}

Siehe auch