Namensräume
Varianten
Aktionen

std::experimental::ranges::common_reference

Von cppreference.com
< cpp‎ | experimental‎ | ranges
 
C++
 
Experimentell
 
Bereiche (Ranges)
 
Allgemeine Dienstprogramme-Bibliothek
Hilfskomponenten
Funktionsobjekte
Metaprogrammierung und Typ-Traits
common_reference
Getaggte Paare und Tupel
                          
Tag-Spezifizierer
                                      
                          
 
template< class... T >
struct common_reference;
 (Ranges TS)

Bestimmt den gemeinsamen Referenztyp der Typen T..., d. h. den Typ, in den alle Typen in T... konvertiert oder an den sie gebunden werden können. Wenn ein solcher Typ existiert (wie nach den untenstehenden Regeln bestimmt), benennt das Mitglied type diesen Typ. Andernfalls gibt es kein Mitglied type. Das Verhalten ist undefiniert, wenn einer der Typen in T... ein unvollständiger Typ ist, außer (möglicherweise cv-qualifiziertes) void.

Wenn Referenztypen gegeben sind, versucht common_reference, einen Referenztyp zu finden, an den alle gegebenen Referenztypen gebunden werden können, kann aber einen Nicht-Referenztyp zurückgeben, wenn kein solcher Referenztyp gefunden werden kann.

  • Wenn sizeof...(T) null ist, gibt es kein Element type.
  • Wenn sizeof...(T) eins ist (d. h. T... enthält nur einen Typ T0), dann benennt das Mitglied 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 benennt der Mitgliedstyp type S;
    • Andernfalls, wenn basic_common_reference<T1R, T2R, T1Q, T2Q>::type existiert, wobei TiR std::remove_cv_t<std::remove_reference_t<Ti>> ist und TiQ eine Alias-Vorlage ist, so dass TiQ<TiR> gleich Ti ist, dann benennt der Mitgliedstyp type diesen Typ;
    • Andernfalls, wenn decltype(false? val<T1>() : val<T2>()), wobei val eine Funktionenschablone ist template<class T> T val();, einen gültigen Typ bezeichnet, dann benennt der Mitgliedstyp type diesen Typ;
    • Andernfalls, wenn ranges::common_type_t<T1, T2> ein gültiger Typ ist, dann benennt der Mitgliedstyp type diesen Typ;
    • Andernfalls gibt es keinen Mitgliedstyp.
  • Wenn sizeof...(T) größer als zwei ist (d. h. T... besteht aus den Typen T1, T2, R...), dann, wenn ranges::common_reference_t<T1, T2> existiert, bezeichnet das Mitglied type ranges::common_reference_t<ranges::common_reference_t<T1, T2>, R...>, falls ein solcher Typ existiert. In allen anderen Fällen gibt es kein Mitglied type.

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

  • Wenn T1 cv1 X & ist 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: wenn der einfache gemeinsame Referenztyp von T1 & und T2 & (bestimmt gemäß dem vorherigen Punkt) 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önnen 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.

Inhalt

[bearbeiten] Mitgliedstypen

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

[bearbeiten] 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 Klassenschablone 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ärschablone ist leer.

[bearbeiten] Spezialisierungen

Ein Programm kann basic_common_reference<T, U, TQual, UQual> auf die ersten beiden Parameter T und U spezialisieren, wenn std::is_same<T, std::decay_t<T>> und std::is_same<U, std::decay_t<U>> beide true sind und mindestens einer von ihnen von einem programmintern definierten Typ abhängt.

Wenn eine solche Spezialisierung ein Mitglied namens type hat, muss es ein öffentliches und eindeutiges Mitglied sein, das einen Typ benennt, zu dem 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 auf den dritten oder vierten Parametern spezialisieren, noch darf es common_reference selbst spezialisieren. Ein Programm, das Spezialisierungen unter Verstoß gegen diese Regeln hinzufügt, hat undefiniertes Verhalten.

[bearbeiten] Anmerkungen

Dieser Abschnitt ist unvollständig

[bearbeiten] Beispiel

Dieser Abschnitt ist unvollständig
Grund: kein Beispiel

[bearbeiten] Siehe auch

(C++11)
 ermittelt den gemeinsamen Typ einer Gruppe von Typen
(Klassenvorlage) [bearbeiten]
 ermittelt den gemeinsamen Typ einer Menge von Typen
(class template) [bearbeiten]
 gibt an, dass zwei Typen einen gemeinsamen Referenztyp haben
(concept) [bearbeiten]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/experimental/ranges/type_traits/common_reference&oldid=159307"