std::experimental::ranges::common_type

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Experimentell

Technische Spezifikation

Dateisystembibliothek (Filesystem TS)

Grundlagen der Bibliothek (Library Fundamentals TS)

Grundlagen der Bibliothek 2 (Library Fundamentals TS v2)

Grundlagen der Bibliothek 3 (Library Fundamentals TS v3)

Erweiterungen für Parallelität (Parallelism TS)

Erweiterungen für Parallelität 2 (Parallelism TS v2)

Erweiterungen für Nebenläufigkeit (Concurrency TS)

Erweiterungen für Nebenläufigkeit 2 (Concurrency TS v2)

Konzepte (Concepts TS)

Bereiche (Ranges TS)

Reflektion (Reflection TS)

Mathematische Spezialfunktionen (Special Functions TR)

Experimentell Nicht-TS

Pattern Matching

Lineare Algebra

std::execution

Verträge

2D-Grafik

 

Bereiche (Ranges)

Konzepte

Allgemeine Hilfsmittel

Iteratoren

Bereiche (Ranges)

Algorithmen

 

Allgemeine Dienstprogramme-Bibliothek

Hilfskomponenten
swap	exchange
Funktionsobjekte
invoke identity	equal_to not_equal_to	greater less	greater_equal less_equal
Metaprogrammierung und Typ-Traits
is_swappable_withis_swappable	is_nothrow_swappable_withis_nothrow_swappable	common_reference common_type
Getaggte Paare und Tupel
TagSpecifier TaggedType	tagged Tag-Spezifizierer	tagged_pair make_tagged_pair	tagged_tuple make_tagged_tuple

 

Definiert in Header <experimental/ranges/type_traits>
template< class... T > struct common_type;		(Ranges TS)

Bestimmt den gemeinsamen Typ aller Typen T..., d.h. den Typ, zu dem alle T... implizit konvertiert werden können. Wenn ein solcher Typ existiert (wie nach den folgenden Regeln bestimmt), benennt das Member type diesen Typ. Andernfalls gibt es kein Member type. Das Verhalten ist undefiniert, wenn einer der Typen in T... ein unvollständiger Typ ist, außer (möglicherweise cv-qualifiziert) void.

• Wenn sizeof...(T) null ist, gibt es kein Element type.
• Wenn sizeof...(T) eins ist (d.h. T... enthält nur einen Typ T0), benennt das Member type denselben Typ wie std::decay_t<T0>.
• Wenn sizeof...(T) zwei ist (d.h. T... enthält genau zwei Typen T1 und T2),

• Wenn die Anwendung von std::decay auf mindestens einen der Typen T1 und T2 einen anderen Typ ergibt, benennt das Member type denselben Typ wie ranges::common_type_t<std::decay_t<T1>, std::decay_t<T2>>, falls dieser existiert; andernfalls gibt es kein Member type;
• Andernfalls (und es sei denn, es gibt eine Benutzerspezialisierung für ranges::common_type<T1, T2>), wenn std::common_type_t<T1, T2> gut geformt ist, dann bezeichnet das Member type diesen Typ;
• Andernfalls bezeichnet das Member type den Typ std::decay_t<decltype(false ? std::declval<const T1&>() : std::declval<const T2&>())>, wenn dieser bedingte Ausdruck gut geformt ist; andernfalls gibt es kein Member type.

• Wenn sizeof...(T) größer als zwei ist (d.h. T... besteht aus den Typen T1, T2, R...), dann, wenn ranges::common_type_t<T1, T2> existiert, bezeichnet das Member type ranges::common_type_t<ranges::common_type_t<T1, T2>, R...>, falls ein solcher Typ existiert. In allen anderen Fällen gibt es kein Member type.

Member types

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

Helper types

template< class... T > using common_type_t = typename common_type<T...>::type;

Specializations

Benutzer können common_type für die Typen T1 und T2 spezialisieren, wenn

• Mindestens einer der Typen T1 und T2 von einem benutzerdefinierten Typ abhängt und
• std::decay für beide Typen T1 und T2 eine Identitätstransformation ist.

Wenn eine solche Spezialisierung ein Member namens type hat, muss dieser ein öffentlicher und eindeutiger Member-Typ sein, der einen cv-unqualifizierten Nicht-Referenztyp benennt, zu dem sowohl T1 als auch T2 explizit konvertierbar sind. Zusätzlich müssen ranges::common_type_t<T1, T2> und ranges::common_type_t<T2, T1> denselben Typ bezeichnen.

Ein Programm, das common_type-Spezialisierungen unter Verstoß gegen diese Regeln hinzufügt, hat undefiniertes Verhalten.

Notes

Für arithmetische Typen, die keiner Promotion unterliegen, kann der gemeinsame Typ als der Typ des (möglicherweise gemischten) arithmetischen Ausdrucks wie z. B. T0() + T1() + ... + Tn() angesehen werden.

See also

common_type (C++11)	ermittelt den gemeinsamen Typ einer Gruppe von Typen (Klassenvorlage)
common_reference	ermittelt den gemeinsamen Referenztyp einer Menge von Typen (class template)