Namespaces
Variants

Feature testing (since C++20)

From cppreference.net
C++
Feature testing

Der Standard definiert eine Reihe von Präprozessor-Makros entsprechend den C++-Sprach- und Bibliotheksfunktionen, die in C++11 oder später eingeführt wurden. Sie sind als einfache und portable Methode gedacht, um das Vorhandensein besagter Funktionen zu erkennen.

Inhaltsverzeichnis

Attribute

__has_cpp_attribute( Attribut-Token )

Prüft die Unterstützung eines Attributs mit dem Namen attribute-token (nach Makroexpansion).

Für jedes Standardattribut ist implementierungsdefiniert, ob __has_cpp_attribute zu dem in der folgenden Tabelle angegebenen Wert expandiert (welches das Jahr und den Monat angibt, in dem das Attribut zum Arbeitsentwurf hinzugefügt wurde) oder zu ​ 0 ​ . Es wird genau dann zu dem in der Tabelle angegebenen Wert expandieren, wenn das Standardattribut dazu führt, dass die Implementierung sich wie empfohlen verhält (Ausgabe von Diagnosemeldungen, Beeinflussung des Klassenlayouts, etc.).

Das Vorhandensein von herstellerspezifischen Attributen wird durch einen Wert ungleich Null bestimmt.

__has_cpp_attribute kann in den Ausdrücken von #if und #elif expandiert werden. Es wird als definiertes Makro behandelt von #ifdef , #ifndef , #elifdef , #elifndef (seit C++23) und defined , kann aber nirgendwo anders verwendet werden.

attribute-token Attribut Wert Std Papier(e)
assume [[ assume ]] 202207L (C++23) P1774R8
carries_dependency [[ carries_dependency ]] 200809L (C++11)
(bis C++26) 		N2556
N2643
P3475R2
deprecated [[ deprecated ]] 201309L (C++14) N3760
fallthrough [[ fallthrough ]] 201603L (C++17) P0188R1
indeterminate [[ indeterminate ]] 202403L (C++26) P2795R5
likely [[ likely ]] 201803L (C++20) P0479R5
maybe_unused [[ maybe_unused ]] 201603L (C++17) P0212R1
no_unique_address [[ no_unique_address ]] 201803L (C++20) P0840R2
nodiscard [[ nodiscard ]] 201603L (C++17) P0189R1
[[ nodiscard ]] mit Grund 201907L (C++20) P1301R4
noreturn [[ noreturn ]] 200809L (C++11) N2761
unlikely [[ unlikely ]] 201803L (C++20) P0479R5
Gesamtzahl der Attribute: 11

Sprachmerkmale

Die folgenden Makros können verwendet werden, um zu erkennen, ob ein Sprachfeature von der aktuellen Implementierung unterstützt wird. Sie sind vordefiniert in jeder Übersetzungseinheit.

Jedes Makro expandiert zu einem ganzzahligen Literal, das dem Jahr und Monat entspricht, in dem das entsprechende Feature in den Arbeitsentwurf aufgenommen wurde. Wenn ein Feature signifikant geändert wird, wird das Makro entsprechend aktualisiert.

**Übersetzungsdetails:** - `ref-qualifiers` wurde als `Referenzqualifizierer` übersetzt (standarddeutscher Fachbegriff in der C++-Programmierung) - HTML-Tags, Attribute und Werte wurden unverändert beibehalten - Text innerhalb der ` `-Tags wurde nicht übersetzt - C++-spezifische Begriffe wie `__cpp_ref_qualifiers` und `200710L` wurden nicht übersetzt - Die Formatierung und Struktur der HTML-Tabelle wurde vollständig erhalten
Makroname Funktion Wert Std Dokument(e)
__cpp_aggregate_ bases Aggregatklassen mit Basisklassen 201603L (C++17) P0017R1
__cpp_aggregate_ nsdmi Aggregatklassen mit Standard-Memberinitialisierern 201304L (C++14) N3653
__cpp_aggregate_ paren_init Aggregat-Initialisierung in Form von Direktinitialisierung 201902L (C++20) P0960R3
__cpp_alias_templates Alias-Vorlagen 200704L (C++11) N2258
__cpp_aligned_new Dynamische Speicherallokation für überausgerichtete Daten 201606L (C++17) P0035R4
__cpp_attributes Attribute 200809L (C++11) N2761
__cpp_auto_cast auto ( x ) und auto { x } 202110L (C++23) P0849R8
__cpp_binary_literals Binäre Literale 201304L (C++14) N3472
__cpp_capture_star_ this Erfassung von * this durch Wert als [ = , * this ] 201603L (C++17) P0018R3
__cpp_char8_t char8_t 201811L (C++20) P0482R6
char8_t Kompatibilitäts- und Portabilitätskorrektur (ermöglicht Initialisierung von (unsigned) char-Arrays aus UTF-8 String-Literalen ) 202207L (C++23)
(DR20) 		P2513R4
__cpp_concepts Konzepte 201907L (C++20) P0734R0
P1084R2
P1452R2
Bedingte triviale spezielle Elementfunktionen 202002L P0848R3
P2493R0
__cpp_conditional_ explicit explicit(bool) 201806L (C++20) P0892R2
__cpp_consteval Unmittelbare Funktionen 201811L (C++20) P1073R3
Lässt consteval nach oben propagieren 202211L (C++23)
(DR20) 		P2564R3
__cpp_constexpr constexpr 200704L (C++11) N2235
Gelockerte constexpr , nicht- const constexpr Methoden 201304L (C++14) N3652
Constexpr-Lambda 201603L (C++17) P0170R1
Virtuelle Funktionsaufrufe in konstanten Ausdrücken; try Blöcke in constexpr Funktionen, dynamic_cast und polymorphe typeid in konstanten Ausdrücken; triviale Standardinitialisierung und Asm-Deklaration in constexpr Funktionen 201907L (C++20) P1064R0
P1002R1
P1327R1
P1331R2
P1668R1
Ändern des aktiven Members einer Union in konstanter Auswertung 202002L P1330R0
P2493R0
Nicht- Literal Variablen, Labels und goto Anweisungen in constexpr Funktionen 202110L (C++23) P2242R3
Lockerung einiger Einschränkungen für constexpr Funktionen und Funktionsvorlagen 202207L P2448R2
Zulassung statischer constexpr Variablen in constexpr Funktionen 202211L P2647R1
Constexpr-Umwandlung von void * : hin zu constexpr Type Erasure 202306L (C++26) P2738R1
constexpr Placement new 202406L P2747R2
__cpp_constexpr_ dynamic_alloc Operationen für dynamische Speicherdauer in constexpr Funktionen 201907L (C++20) P0784R7
__cpp_constexpr_ exceptions constexpr Ausnahmen: [1] , [2] 202411L (C++26) P3068R6
__cpp_constexpr_ in_decltype Erzeugung von Funktions- und Variablendefinitionen, wenn für konstante Auswertung benötigt 201711L (C++20)
(DR11) 		P0859R0
__cpp_constinit constinit 201907L (C++20) P1143R2
__cpp_contracts Verträge 202502L (C++26) P2900R14
__cpp_decltype decltype 200707L (C++11) N2343
__cpp_decltype_auto Rückgabetyp-Deduktion für normale Funktionen 201304L (C++14) N3638
__cpp_deduction_ guides Template-Argument-Deduktion für Klassentemplates (CTAD) 201703L (C++17) P0091R3
P0512R0
P0620R0
CTAD für Aggregate und Aliase 201907L (C++20) P1814R0
P1816R0
__cpp_delegating_ constructors Delegierende Konstruktoren 200604L (C++11) N1986
__cpp_deleted_function Gelöschte Funktionsdefinitionen mit Nachrichten ( = delete ( "should have a reason" ) ; ) 202403L (C++26) P2573R2
__cpp_designated_ initializers Designierte Initialisierer 201707L (C++20) P0329R4
__cpp_enumerator_ attributes Attribute für Enumeratoren 201411L (C++17) N4266
__cpp_explicit_this_ parameter Expliziter Objektparameter 202110L (C++23) P0847R7
__cpp_fold_expressions Fold-Ausdrücke 201603L (C++17) N4295
P0036R0
Reihenfolge von Constraints mit Fold-Ausdrücken 202406L (C++26) P2963R3
__cpp_generic_lambdas Generische Lambda-Ausdrücke 201304L (C++14) N3649
Explizite Template-Parameterliste für generische Lambdas 201707L (C++20) P0428R2
__cpp_guaranteed_ copy_elision Garantierte Kopierauslassung durch vereinfachte Wertkategorien 201606L (C++17) P0135R1
__cpp_hex_float Hexadezimale Gleitkommaliterale 201603L (C++17) P0245R1
__cpp_if_consteval if consteval 202106L (C++23) P1938R3
__cpp_if_constexpr if constexpr 201606L (C++17) P0292R2
__cpp_impl_coroutine Coroutinen (Compiler-Unterstützung) 201902L (C++20) P0912R5
LWG3393
__cpp_impl_destroying_ delete Zerstörender operator delete (Compiler-Unterstützung) 201806L (C++20) P0722R3
__cpp_impl_three_ way_comparison Dreifachvergleich (Compilerunterstützung) 201907L (C++20) P0515R3
P0768R1
P1185R2
P1630R1
__cpp_implicit_move Vereinfachtes Implicit Move 202207L (C++23) P2266R3
__cpp_inheriting_ constructors Vererbende Konstruktoren 200802L (C++11) N2540
Umformulierung vererbter Konstruktoren: Neue Spezifikation für vererbte Konstruktoren ( DR1941 et al) 201511L (C++17)
(DR11) 		P0136R1
__cpp_init_captures Lambda-Initialisierungs-Capture 201304L (C++14) N3648
Erlaube Pack-Erweiterung in lambda Init-Capture 201803L (C++20) P0780R2
__cpp_initializer_ lists Listeninitialisierung und std::initializer_list 200806L (C++11) N2672
__cpp_inline_variables Inline-Variablen 201606L (C++17) P0386R2
__cpp_lambdas Lambda-Ausdrücke 200907L (C++11) N2927
__cpp_modules Module 201907L (C++20) P1103R3
P1811R0
__cpp_multidimensional_ subscript Mehrdimensionaler Subskript-Operator 202110L (C++23) P2128R6
Static operator[] 202211L P2589R1
__cpp_named_character_ escapes Benannte universelle Zeichenescapes 202207L (C++23) P2071R2
__cpp_namespace_ attributes Attribute für Namespaces 201411L (C++17) N4266
__cpp_noexcept_function_ type Machen Sie Ausnahmespezifikationen Teil des Typsystems 201510L (C++17) P0012R1
__cpp_nontype_template_ args Erlaubt konstante Auswertung für alle konstanten Template-Argumente 201411L (C++17) N4268
Klassentypen und Gleitkommatypen in konstanten Template-Parametern 201911L (C++20) P1907R1
__cpp_nontype_template_ parameter_auto Deklaration von konstanten Template-Parametern mit auto 201606L (C++17) P0127R2
__cpp_nsdmi Nicht-statische Datenelement-Initialisierer 200809L (C++11) N2756
__cpp_pack_indexing Pack-Indexierung 202311L (C++26) P2662R3
__cpp_placeholder_ variables Ein schöner Platzhalter ohne Namen 202306L (C++26) P2169R4
__cpp_pp_embed #embed 202502L (C++26) P1967R14
__cpp_range_based_ for Bereichsbasierte for Schleife 200907L (C++11) N2930
Bereichsbasierte for -Schleife mit unterschiedlichen begin / end -Typen 201603L (C++17) P0184R0
Lebensdauerverlängerung in bereichsbasierten for 202211L (C++23) P2644R1
P2718R0
CWG2659
__cpp_raw_strings Raw-String-Literale 200710L (C++11) N2442
__cpp_ref_qualifiers Referenzqualifizierer 200710L (C++11) N2439
__cpp_return_type_ deduction Rückgabetyp-Deduktion für normale Funktionen 201304L (C++14) N3638
__cpp_rvalue_references Rvalue-Referenz 200610L (C++11) N2118
__cpp_size_t_suffix Literalsuffixe für std::size_t und dessen vorzeichenbehaftete Version 202011L (C++23) P0330R8
__cpp_sized_deallocation Sized deallocation 201309L (C++14) N3778
__cpp_static_assert static_assert 200410L (C++11) N1720
Einzelargument- static_assert 201411L (C++17) N3928
Benutzerdefinierte static_assert -Meldungen 202306L (C++26) P2741R3
__cpp_static_call_ operator Statischer operator() 202207L (C++23) P1169R4
__cpp_structured_ bindings Strukturierte Bindungen 201606L (C++17) P0217R3
Attribute für strukturierte Bindungen 202403L (C++26) P0609R3
Strukturierte Bindungen Deklaration als Bedingung 202406L P0963R3
Strukturierte Bindungen können einen Pack einführen 202411L P1061R10
__cpp_template_parameters Konzepte und Variablen-Template Template-Parameter 202502L (C++26) P2841R7
__cpp_template_template_ args Abgleich von Template-Template-Argumenten 201611L (C++17) P0522R0
__cpp_threadsafe_ static_init Dynamische Initialisierung und Destruktion mit Nebenläufigkeit 200806L (C++11) N2660
__cpp_trivial_relocatability Triviale Relokierbarkeit 202502L (C++26) P2786R13
__cpp_trivial_union Triviale Unions 202502L (C++26) P3074R7
__cpp_unicode_characters Neue Zeichentypen ( char16_t und char32_t ) 200704L (C++11) N2249
__cpp_unicode_literals Unicode-Zeichenkettenliterale 200710L (C++11) N2442
__cpp_user_defined_ literals Benutzerdefinierte Literale 200809L (C++11) N2765
__cpp_using_enum using enum 201907L (C++20) P1099R5
__cpp_variable_templates Variablen-Templates 201304L (C++14) N3651
__cpp_variadic_friend Variadische Friend-Deklarationen 202403L (C++26) P2893R3
__cpp_variadic_templates Variadische Templates 200704L (C++11) N2242
__cpp_variadic_using Pack-Erweiterungen in using -Deklarationen 201611L (C++17) P0195R2
Gesamtzahl der Makros: 76

Bibliotheksfunktionen

Die folgenden Makros können verwendet werden, um zu erkennen, ob eine Standardbibliothek-Funktionalität von der aktuellen Implementierung bereitgestellt wird. Im Gegensatz zu den Sprach-Feature-Test-Makros sind sie nicht vordefiniert. Stattdessen werden sie durch den Header <version> bereitgestellt.

Für jedes Bibliotheks-Feature-Test-Makro wird es auch von den Headern bereitgestellt, die die relevanten Standardbibliothekskomponenten bereitstellen. Siehe library feature test macros für eine vollständige Liste der Header, die diese Makros bereitstellen.

Jedes Makro expandiert zu einem ganzzahligen Literal, das dem Jahr und Monat entspricht, in dem das entsprechende Feature in den Arbeitsentwurf aufgenommen wurde. Wenn ein Feature signifikant geändert wird, wird das Makro entsprechend aktualisiert.

**Erklärung der Übersetzung:** - Alle HTML-Tags, Attribute und Code-Blöcke wurden unverändert belassen - C++-spezifische Begriffe wie `atomic_ref` wurden nicht übersetzt - Numerische Werte und Links wurden beibehalten - Die Struktur und Formatierung entspricht exakt dem Original **Übersetzungsdetails:** - "Integer comparison functions" wurde zu "Integer-Vergleichsfunktionen" übersetzt - Alle HTML-Tags, Attribute und Formatierung wurden beibehalten - Text innerhalb von ` `-Tags wurde nicht übersetzt - C++-spezifische Begriffe wurden nicht übersetzt - Die P0586R2-Referenz und Versionsnummern bleiben unverändert
Makroname Funktion Wert Std Dokument(e)
__cpp_lib_adaptor_ iterator_pair_constructor Iterator-Paar-Konstruktoren für std::stack und std::queue 202106L (C++23) P1425R4
__cpp_lib_addressof_ constexpr Konstante Ausdrücke std::addressof 201603L (C++17) LWG2296
__cpp_lib_algorithm_ default_value_type Ermöglicht Listeninitialisierung für Algorithmen 202403L (C++26) P2248R8
P3217R0
__cpp_lib_algorithm_ iterator_requirements Ranges-Iteratoren als Eingaben für Nicht-Ranges- Algorithmen 202207L (C++23) P2408R5
__cpp_lib_aligned_ accessor std::aligned_accessor : ein std::mdspan Accessor, der Zeiger-Überausrichtung ausdrückt 202411L (C++26) P2897R7
__cpp_lib_allocate_ at_least Größenrückmeldung in der Allokator-Schnittstelle, z.B.: std::allocator::allocate_at_least , std::allocator_traits::allocate_at_least 202302L (C++23) P0401R6
P2652R2
LWG3887
__cpp_lib_allocator_ traits_is_always_equal std::allocator_traits::is_always_equal , noexcept Bereinigungen 201411L (C++17) N4258
__cpp_lib_any std::any 201606L (C++17) P0220R1
P0032R3
__cpp_lib_apply std::apply 201603L (C++17) P0220R1
__cpp_lib_array_ constexpr Constexpr für std::reverse_iterator , std::move_iterator , std::array und Bereichszugriff 201603L (C++17) P0031R0
ConstexprIterator ; constexpr Vergleich für std::array ; diverse constexpr Bits ( std::array::fill u.a.) 201811L (C++20) P0858R0
LWG3257
P1023R0
P1032R1
__cpp_lib_as_const std::as_const 201510L (C++17) P0007R1
__cpp_lib_associative_ heterogeneous_erasure Heterogenes Löschen in assoziativen Containern und ungeordneten assoziativen Containern 202110L (C++23) P2077R3
__cpp_lib_associative_ heterogeneous_insertion Heterogene Überladungen für die verbleibenden Memberfunktionen in geordneten und ungeordneten assoziativen Containern 202306L (C++26) P2363R5
__cpp_lib_assume_ aligned std::assume_aligned 201811L (C++20) P1007R3
__cpp_lib_atomic_ flag_test std::atomic_flag::test 201907L (C++20) P1135R6
__cpp_lib_atomic_ float Gleitkomma-Atomare Operationen 201711L (C++20) P0020R6
__cpp_lib_atomic_ is_always_lock_free Constexpr std::atomic<T>::is_always_lock_free 201603L (C++17) P0152R1
__cpp_lib_atomic_ lock_free_type_aliases Atomare lockfreie Ganzzahltypen ( std::atomic_signed_lock_free , std::atomic_unsigned_lock_free ) 201907L (C++20) P1135R6
__cpp_lib_atomic_ min_max Atomare Minimum-/Maximum-Operationen ( std::atomic::fetch_min , std::atomic::fetch_max , etc.) 202403L (C++26) P0493R5
__cpp_lib_atomic_ ref std::atomic_ref 201806L (C++20) P0019R8
std::atomic_ref::address() 202411L (C++26) P2835R7
__cpp_lib_atomic_ shared_ptr std::atomic<std::shared_ptr> 201711L (C++20) P0718R2
__cpp_lib_atomic_ value_initialization Behebung der atomaren Initialisierung (Standardmäßige Wertinitialisierung von std::atomic ) 201911L (C++20) P0883R2
__cpp_lib_atomic_ wait Effizientes std::atomic Warten 201907L (C++20) P1135R6
__cpp_lib_barrier std::barrier 201907L (C++20) P1135R6
std::barrier Phasenabschlussgarantien 202302L (C++23) P2588R3
__cpp_lib_bind_back std::bind_back 202202L (C++23) P2387R3
Ermöglicht das Übergeben von aufrufbaren Objekten als konstante Template-Argumente an std::bind_back 202306L (C++26) P2714R1
__cpp_lib_bind_front std::bind_front 201907L (C++20) P0356R5
P1651R0
Ermöglicht das Übergeben von aufrufbaren Objekten als konstante Template-Argumente an std::bind_front 202306L (C++26) P2714R1
__cpp_lib_bit_cast std::bit_cast 201806L (C++20) P0476R2
__cpp_lib_bitops Bitoperationen 201907L (C++20) P0553R4
__cpp_lib_bitset Verbindung von std::bitset mit std::string_view 202306L (C++26) P2697R1
__cpp_lib_bool_constant std::bool_constant 201505L (C++17) N4389
__cpp_lib_bounded_ array_traits std::is_bounded_array , std::is_unbounded_array 201902L (C++20) P1357R1
__cpp_lib_boyer_ moore_searcher Searcher 201603L (C++17) P0220R1
__cpp_lib_byte std::byte 201603L (C++17) P0298R3
__cpp_lib_byteswap std::byteswap 202110L (C++23) P1272R4
__cpp_lib_char8_ t Bibliotheksunterstützung für char8_t 201907L (C++20) P0482R6
P1423R3
__cpp_lib_chrono Rundungsfunktionen für std::chrono::duration und std::chrono::time_point 201510L (C++17) P0092R1
Constexpr für alle Memberfunktionen von std::chrono::duration und std::chrono::time_point 201611L P0505R0
Kalender und Zeitzonen 201907L (C++20) P0355R7
P1466R3
Hash-Unterstützung für std::chrono Wertklassen 202306L (C++26) P2592R3
__cpp_lib_chrono_ udls Benutzerdefinierte Literale für Zeittypen 201304L (C++14) N3642
__cpp_lib_clamp std::clamp 201603L (C++17) P0025R1
__cpp_lib_common_ reference Mache std::common_reference_t von std::reference_wrapper zu einem Referenztyp 202302L (C++23) P2655R3
__cpp_lib_common_ reference_wrapper Mache std::common_reference_t von std::reference_wrapper zu einem Referenztyp 202302L (C++23) P2655R3
__cpp_lib_complex_ udls Benutzerdefinierte Literale für std::complex 201309L (C++14) N3779
__cpp_lib_concepts Standardbibliothek-Konzepte 202002L (C++20) P0898R3
P1754R1
P1964R2
Nur-verschiebbare Typen für equality_comparable_with , totally_ordered_with , und three_way_comparable_with 202207L (C++23) P2404R3
__cpp_lib_constexpr_ algorithms Constexpr für Algorithmen 201806L (C++20) P0202R3
P0879R0
LWG3256
LWG3792
Constexpr stabile Sortierung 202306L (C++26) P2562R1
__cpp_lib_constexpr_ atomic constexpr std::atomic und std::atomic_ref 202411L (C++26) P3309R3
__cpp_lib_constexpr_ bitset Ein stärker constexpr std::bitset 202207L (C++23) P2417R2
__cpp_lib_constexpr_ charconv Constexpr für std::to_chars und std::from_chars für Ganzzahltypen 202207L (C++23) P2291R3
__cpp_lib_constexpr_ cmath Konstante Ausdrücke für mathematische Funktionen in <cmath> und <cstdlib> 202202L (C++23) P0533R9
Mehr constexpr für <cmath> 202306L (C++26) P1383R2
__cpp_lib_constexpr_ complex Constexpr für std::complex 201711L (C++20) P0415R1
Mehr constexpr für <complex> 202306L (C++26) P1383R2
__cpp_lib_constexpr_ deque constexpr std::deque 202502L (C++26) P3372R3
__cpp_lib_constexpr_ dynamic_alloc Konstexpr für std::allocator und zugehörige Utilities 201907L (C++20) P0784R7
__cpp_lib_constexpr_ exceptions constexpr für Ausnahmetypen, z.B. std::bad_alloc , std::bad_cast usw. 202411L (C++26) P3068R6
Mehr constexpr für Ausnahmetypen 202502L P3378R2
__cpp_lib_constexpr_ flat_map constexpr std::flat_map und std::flat_multimap 202502L (C++26) P3372R3
__cpp_lib_constexpr_ flat_set constexpr std::flat_set und std::flat_multiset 202502L (C++26) P3372R3
__cpp_lib_constexpr_ forward_list constexpr std::forward_list 202502L (C++26) P3372R3
__cpp_lib_constexpr_ functional Verschiedene constexpr Teile ( std::default_searcher ); constexpr INVOKE 201907L (C++20) P1032R1
P1065R2
__cpp_lib_constexpr_ inplace_vector constexpr std::inplace_vector für nicht-triviale Typen 202502L (C++26) P3074R7
__cpp_lib_constexpr_ iterator Sonstiges constexpr Bits ( std::insert_iterator u.a.) 201811L (C++20) P1032R1
__cpp_lib_constexpr_ list constexpr std::list 202502L (C++26) P3372R3
__cpp_lib_constexpr_ map constexpr std::map und std::multimap 202502L (C++26) P3372R3
__cpp_lib_constexpr_ memory Konstante Ausdrücke in std::pointer_traits 201811L (C++20) P1006R1
Constexpr std::unique_ptr 202202L (C++23) P2273R3
__cpp_lib_constexpr_ new Konstante Ausdrücke Placement new 202406L (C++26) P2747R2
__cpp_lib_constexpr_ numeric Constexpr für Algorithmen in <numeric> 201911L (C++20) P1645R1
__cpp_lib_constexpr_ queue constexpr std::queue 202502L (C++26) P3372R3
__cpp_lib_constexpr_ set constexpr std::set und std::multiset 202502L (C++26) P3372R3
__cpp_lib_constexpr_ stack constexpr std::stack 202502L (C++26) P3372R3
__cpp_lib_constexpr_ string constexpr std::char_traits 201611L (C++17) P0426R1
constexpr std::string 201907L (C++20) P0980R1
__cpp_lib_constexpr_ string_view Verschiedene constexpr -Funktionen ( std::string_view::copy ) 201811L (C++20) P1032R1
__cpp_lib_constexpr_ tuple Verschiedenes constexpr Bits ( std::tuple::operator= usw.) 201811L (C++20) P1032R1
__cpp_lib_constexpr_ typeinfo Konstexpr für std::type_info::operator== 202106L (C++23) P1328R1
__cpp_lib_constexpr_ unordered_map constexpr std::unordered_map und std::unordered_multimap 202502L (C++26) P3372R3
__cpp_lib_constexpr_ unordered_set constexpr std::unordered_set und std::unordered_multiset 202502L (C++26) P3372R3
__cpp_lib_constexpr_ utility Verschiedene constexpr -Funktionen ( std::pair::operator= u.a.) 201811L (C++20) P1032R1
__cpp_lib_constexpr_ vector Konstante Ausdrücke für std::vector 201907L (C++20) P1004R2
__cpp_lib_constrained_ equality Eingeschränkte relationale Operatoren für std::pair , std::tuple , std::optional , und std::variant 202403L (C++26) P2944R3
Einschränkung der std::expected Gleichheitsoperatoren 202411L P3379R0
__cpp_lib_containers_ ranges Ranges-bewusste Konstruktion und Einfügung für Container und Strings 202202L (C++23) P1206R7
__cpp_lib_contracts <contracts> : Vertragsunterstützung 202502L (C++26) P2900R14
__cpp_lib_copyable_ function std::copyable_function 202306L (C++26) P2548R6
__cpp_lib_coroutine Coroutinen (Bibliotheksunterstützung) 201902L (C++20) P0912R5
LWG3393
__cpp_lib_debugging <debugging> : Debugging-Unterstützung 202311L (C++26) P2546R5
Ersetzbar std::is_debugger_present 202403L P2810R4
__cpp_lib_destroying_ delete Zerstörender operator delete (Bibliotheksunterstützung) 201806L (C++20) P0722R3
__cpp_lib_enable_ shared_from_this std::enable_shared_from_this::weak_from_this 201603L (C++17) P0033R1
__cpp_lib_endian std::endian 201907L (C++20) P0463R1
P1612R1
__cpp_lib_erase_ if Einheitliche Container-Löschung 202002L (C++20) P1209R0
P1115R3
__cpp_lib_exchange_ function std::exchange 201304L (C++14) N3668
__cpp_lib_execution Ausführungsrichtlinien 201603L (C++17) P0024R2
std::execution::unsequenced_policy 201902L (C++20) P1001R2
__cpp_lib_expected Klassentemplate std::expected 202202L (C++23) P0323R12
Monadische Funktionen für std::expected 202211L P2505R5
__cpp_lib_filesystem Dateisystem-Bibliothek 201703L (C++17) P0218R1
P0219R1
P0392R0
P0317R1
__cpp_lib_flat_map std::flat_map und std::flat_multimap 202207L (C++23) P0429R9
__cpp_lib_flat_set std::flat_set und std::flat_multiset 202207L (C++23) P1222R4
LWG3751
__cpp_lib_format Textformatierung 201907L (C++20) P0645R10
P1361R2
P1652R1
Compile-time Format-String-Prüfungen; Reduzierung der Parametrisierung von std::vformat_to 202106L (C++23)
(DR20) 		P2216R3
Behebung der Locale-Behandlung in Chrono-Formatierern; Unterstützung nicht-konstanter formatierbarer Typen 202110L P2372R3
P2418R2
Verfügbarmachen von std::basic_format_string ; Klärung der Behandlung von Kodierungen bei lokalisierten Formatierungen von Chrono-Typen 202207L (C++23) P2419R2
P2508R1
Formatierung von Zeigern 202304L (C++26) P2510R3
Type-checking von Format-Argumenten 202305L P2757R3
Member visit 202306L P2637R3
Laufzeit-Formatzeichenfolgen 202311L P2918R2
__cpp_lib_format_ path Formatierung von std::filesystem::path 202403L (C++26) P2845R8
__cpp_lib_format_ ranges Formatierung von Bereichen 202207L (C++23) P2286R8
P2585R1
LWG3750
__cpp_lib_format_ uchar Korrektur der Formatierung von Codeeinheiten als Ganzzahlen 202311L (C++26) P2909R4
__cpp_lib_formatters Formatierung von std::thread::id und std::stacktrace 202302L (C++23) P2693R1
__cpp_lib_forward_ like std::forward_like 202207L (C++23) P2445R1
__cpp_lib_freestanding_ algorithm Freestanding-Einrichtungen in <algorithm> 202311L (C++26) P2407R5
Freestanding-Bibliothek: <algorithm> 202502L P2976R1
__cpp_lib_freestanding_ array Teile von std::array freestanding machen 202311L (C++26) P2407R5
__cpp_lib_freestanding_ char_traits Freestanding std::char_traits 202306L (C++26) P2338R4
__cpp_lib_freestanding_ charconv Freestandende Einrichtungen in <charconv> 202306L (C++26) P2338R4
__cpp_lib_freestanding_ cstdlib Freestandende Einrichtungen in <cstdlib> 202306L (C++26) P2338R4
__cpp_lib_freestanding_ cstring Freestanding-Einrichtungen in <cstring> 202306L (C++26) P2338R4
Entfernung std::strtok aus freistehenden Einrichtungen 202311L P2937R0
__cpp_lib_freestanding_ cwchar Freestanding-Einrichtungen in <cwchar> 202306L (C++26) P2338R4
__cpp_lib_freestanding_ errc Freestanding std::errc 202306L (C++26) P2338R4
__cpp_lib_freestanding_ execution Freestanding-Bibliothek: <execution> 202502L (C++26) P2976R1
__cpp_lib_freestanding_ expected Teile von std::expected freestanding machen 202311L (C++26) P2833R2
__cpp_lib_freestanding_ feature_test_macros Unterstützung für freestanding Feature-Test-Makros 202306L (C++26) P2198R7
__cpp_lib_freestanding_ functional Freestandende Funktionalitäten in <functional> 202306L (C++26) P2198R7
__cpp_lib_freestanding_ iterator Freestandende Einrichtungen in <iterator> 202306L (C++26) P2198R7
__cpp_lib_freestanding_ mdspan Freistehend std::mdspan 202311L (C++26) P2833R2
__cpp_lib_freestanding_ memory Freestanding-Einrichtungen in <memory> 202306L (C++26) P2198R7
Freestanding Library: <memory> 202502L P2976R1
__cpp_lib_freestanding_ numeric Freestanding-Einrichtungen in <numeric> (Sättigungsarithmetik) 202311L (C++26) P0543R3
Freestanding-Bibliothek: <numeric> 202502L P2976R1
__cpp_lib_freestanding_ operator_new Definition von operator new (optional in freestanding Implementierungen) 202306L (C++26) P2198R7
__cpp_lib_freestanding_ optional Teile von std::optional freestanding machen 202311L (C++26) P2407R5
__cpp_lib_freestanding_ random Freestandende Bibliothek: <random> 202502L (C++26) P2976R1
__cpp_lib_freestanding_ ranges Freestandende Einrichtungen in <ranges> 202306L (C++26) P2198R7
__cpp_lib_freestanding_ ratio Freestanding-Einrichtungen in <ratio> 202306L (C++26) P2198R7
__cpp_lib_freestanding_ string_view Teile von std::string_view freestanding machen 202311L (C++26) P2407R5
__cpp_lib_freestanding_ tuple Freestandende Funktionen in <tuple> 202306L (C++26) P2198R7
__cpp_lib_freestanding_ utility Freestandende Funktionen in <utility> 202306L (C++26) P2198R7
__cpp_lib_freestanding_ variant Teile von std::variant freestanding machen 202311L (C++26) P2407R5
__cpp_lib_fstream_ native_handle Erhalten nativer Handles von Dateistreams 202306L (C++26) P1759R6
__cpp_lib_function_ ref std::function_ref : Eine typerodierte aufrufbare Referenz 202306L (C++26) P0792R14
__cpp_lib_gcd_lcm std::gcd , std::lcm 201606L (C++17) P0295R0
__cpp_lib_generator std::generator : Synchrone Koroutinen-Generator für Bereiche 202207L (C++23) P2502R2
__cpp_lib_generic_ associative_lookup Heterogener Vergleichslookup in assoziativen Containern 201304L (C++14) N3657
__cpp_lib_generic_ unordered_lookup Heterogener Vergleichslookup in ungeordneten assoziativen Containern 201811L (C++20) P0919R3
__cpp_lib_hardened_ array Standardbibliothek-Härtung (nur in gehärteter Implementierung vorhanden) 202502L (C++26) P3471R4
__cpp_lib_hardened_ basic_string Standardbibliothek-Härtung (nur in gehärteter Implementierung vorhanden) 202502L (C++26) P3471R4
__cpp_lib_hardened_ basic_string_view Standardbibliothek-Härtung (nur in gehärteter Implementierung vorhanden) 202502L (C++26) P3471R4
__cpp_lib_hardened_ bitset Standardbibliothek-Härtung (nur in gehärteter Implementierung vorhanden) 202502L (C++26) P3471R4
__cpp_lib_hardened_ deque Standardbibliothek-Härtung (nur in gehärteter Implementierung vorhanden) 202502L (C++26) P3471R4
__cpp_lib_hardened_ expected Standardbibliothek-Härtung (nur in gehärteter Implementierung vorhanden) 202502L (C++26) P3471R4
__cpp_lib_hardened_ forward_list Standardbibliothek-Härtung (nur in gehärteter Implementierung vorhanden) 202502L (C++26) P3471R4
__cpp_lib_hardened_ inplace_vector Standardbibliothek-Härtung (nur in gehärteter Implementierung vorhanden) 202502L (C++26) P3471R4
__cpp_lib_hardened_ list Standardbibliothek-Härtung (nur in gehärteter Implementierung vorhanden) 202502L (C++26) P3471R4
__cpp_lib_hardened_ mdspan Standardbibliothek-Härtung (nur in gehärteter Implementierung vorhanden) 202502L (C++26) P3471R4
__cpp_lib_hardened_ optional Standardbibliothek-Härtung (nur in gehärteten Implementierungen vorhanden) 202502L (C++26) P3471R4
__cpp_lib_hardened_ span Standardbibliothek-Härtung (nur in gehärteter Implementierung vorhanden) 202502L (C++26) P3471R4
__cpp_lib_hardened_ valarray Standardbibliothek-Härtung (nur in gehärteter Implementierung vorhanden) 202502L (C++26) P3471R4
__cpp_lib_hardened_ vector Standardbibliothek-Härtung (nur in gehärteter Implementierung vorhanden) 202502L (C++26) P3471R4
__cpp_lib_hardware_ interference_size Constexpr std::hardware_{constructive, destructive}_interference_size 201703L (C++17) P0154R1
__cpp_lib_hive <hive> : ein Container auf Basis von Buckets, der Speicherorte gelöschter Elemente wiederverwendet 202502L (C++26) P0447R28
__cpp_lib_has_unique_ object_representations std::has_unique_object_representations 201606L (C++17) P0258R2
__cpp_lib_hazard_ pointer <hazard_pointer> : Hazard-Pointer 202306L (C++26) P2530R3
__cpp_lib_hypot 3-Argument-Überladung von std::hypot 201603L (C++17) P0030R1
__cpp_lib_incomplete_ container_elements Minimale Unterstützung für unvollständige Typen für std::forward_list , std::list und std::vector 201505L (C++17) N4510
__cpp_lib_indirect std::indirect 202502L (C++26) P3019R13
__cpp_lib_inplace_ vector std::inplace_vector : Dynamisch anpassbarer Vektor mit fester Kapazität (Inplace-Speicherung) 202406L (C++26) P0843R14
__cpp_lib_int_pow2 Ganzzahlige Zweierpotenz- 2 Operationen ( std::has_single_bit , std::bit_ceil , std::bit_floor , std::bit_width ) 202002L (C++20) P0556R3
P1956R1
__cpp_lib_integer_ comparison_functions Integer-Vergleichsfunktionen 202002L (C++20) P0586R2
__cpp_lib_integer_ sequence Kompilierzeit-Ganzzahlfolgen 201304L (C++14) N3658
__cpp_lib_integral_ constant_callable std::integral_constant::operator() 201304L (C++14) N3545
__cpp_lib_interpolate std::lerp , std::midpoint 201902L (C++20) P0811R3
__cpp_lib_invoke std::invoke 201411L (C++17) N4169
__cpp_lib_invoke_ r std::invoke_r 202106L (C++23) P2136R3
__cpp_lib_ios_noreplace Unterstützung des exklusiven Modus für fstreams 202207L (C++23) P2467R1
__cpp_lib_is_aggregate std::is_aggregate 201703L (C++17) LWG2911
__cpp_lib_is_constant_ evaluated std::is_constant_evaluated 201811L (C++20) P0595R2
__cpp_lib_is_final std::is_final 201402L (C++14) LWG2112
__cpp_lib_is_implicit_ lifetime std::is_implicit_lifetime 202302L (C++23) P2674R1
__cpp_lib_is_invocable std::is_invocable , std::invoke_result 201703L (C++17) P0604R0
__cpp_lib_is_layout_ compatible std::is_layout_compatible 201907L (C++20) P0466R5
__cpp_lib_is_nothrow_ convertible std::is_convertible 201806L (C++20) P0758R1
LWG3356
__cpp_lib_is_null_ pointer std::is_null_pointer 201309L (C++14)
(DR11) 		LWG2247
__cpp_lib_is_pointer_ interconvertible Zeiger-Interkonvertierbarkeits-Merkmale: std::is_pointer_interconvertible_with_class , std::is_pointer_interconvertible_base_of 201907L (C++20) P0466R5
__cpp_lib_is_scoped_ enum std::is_scoped_enum 202011L (C++23) P1048R1
__cpp_lib_is_sufficiently_ aligned std::is_sufficiently_aligned : prüft die Ausrichtungsvorbedingung eines Zeigers 202411L (C++26) P2897R7
__cpp_lib_is_swappable (nothrow-)swappable Eigenschaften 201603L (C++17) P0185R1
__cpp_lib_is_virtual_ base_of std::is_virtual_base_of : Typmerkmal zur Erkennung virtueller Basisklassen 202406L (C++26) P2985R0
__cpp_lib_is_within_ lifetime Prüfung, ob eine Union-Alternative aktiv ist ( std::is_within_lifetime ) 202306L (C++26) P2641R4
__cpp_lib_jthread Stop-Token und Join-Thread 201911L (C++20) P0660R10
P1869R1
__cpp_lib_latch std::latch 201907L (C++20) P1135R6
__cpp_lib_launder CWG Issue 1776 : Ersetzung von Klassenobjekten mit Referenzmitgliedern ( std::launder ) 201606L (C++17) P0137R1
__cpp_lib_linalg Eine freie Funktionsschnittstelle für lineare Algebra basierend auf dem BLAS 202311L (C++26) P1673R13
__cpp_lib_list_remove_ return_type Ändern des Rückgabetyps von remove() , remove_if() und unique() für std::forward_list und std::list 201806L (C++20) P0646R1
__cpp_lib_logical_ traits Logische Operationen auf Typmerkmalen 201510L (C++17) P0013R1
__cpp_lib_make_from_ tuple std::make_from_tuple 201606L (C++17) P0209R2
__cpp_lib_make_reverse_ iterator std::make_reverse_iterator 201402L (C++14) LWG2285
__cpp_lib_make_unique std::make_unique 201304L (C++14) N3656
__cpp_lib_map_try_ emplace std::map::try_emplace , std::map::insert_or_assign 201411L (C++17) N4279
__cpp_lib_math_constants Mathematische Konstanten 201907L (C++20) P0631R8
__cpp_lib_math_special_ functions Mathematische Spezialfunktionen 201603L (C++17) P0226R1
__cpp_lib_mdspan std::mdspan 202207L (C++23) P0009R18
P2599R2
P2604R0
P2613R1
std::dims für std::mdspan 202406L (C++26) P2389R2
__cpp_lib_memory_ resource std::pmr::memory_resource 201603L (C++17) P0220R1
__cpp_lib_modules Standardbibliothek-Module std und std.compat 202207L (C++23) P2465R3
__cpp_lib_move_iterator_ concept Mache std::move_iterator<T*> einen wahlfreien Zugriffsiterator 202207L (C++23) P2520R0
__cpp_lib_move_only_ function std::move_only_function 202110L (C++23) P0288R9
__cpp_lib_node_extract Verknüpfung von Maps und Sets ( std::map::extract , std::map::merge , insert(node_type) , etc) 201606L (C++17) P0083R3
__cpp_lib_nonmember_ container_access std::size , std::data und std::empty 201411L (C++17) N4280
__cpp_lib_not_fn std::not_fn 201603L (C++17) P0005R4
Ermöglicht das Übergeben von aufrufbaren Objekten als konstante Template-Argumente an std::not_fn 202306L (C++26) P2714R1
__cpp_lib_null_iterators Null LegacyForwardIterator s 201304L (C++14) N3644
__cpp_lib_optional std::optional 201606L (C++17) P0220R1
P0032R3
P0307R2
Vollständig constexpr std::optional 202106L (C++23)
(DR20) 		P2231R1
Monadische Operationen in std::optional 202110L (C++23) P0798R8
LWG3621
__cpp_lib_optional_ range_support std::optional Bereichsunterstützung 202406L (C++26) P3168R2
__cpp_lib_out_ptr std::out_ptr , std::inout_ptr 202106L (C++23) P1132R8
Freestanding std::out_ptr , std::inout_ptr 202311L (C++26) P2833R2
__cpp_lib_parallel_ algorithm Parallele Algorithmen 201603L (C++17) P0024R2
__cpp_lib_polymorphic std::polymorphic 202502L (C++26) P3019R13
__cpp_lib_polymorphic_ allocator std::pmr::polymorphic_allocator<> als Vokabular-Typ 201902L (C++20) P0339R6
LWG3437
__cpp_lib_print Formatierte Ausgabe 202207L (C++23) P2093R14
Ermöglicht eine effiziente Implementierung von std::print 202403L (C++26)
(DR23) 		P3107R5
P3235R3
Drucken von Leerzeilen mit std::println 202403L (C++26) P3142R0
__cpp_lib_quoted_ string_io std::quoted 201304L (C++14) N3654
__cpp_lib_philox_ engine std::philox_engine : Zählerbasierte Zufallszahlengenerator-Engine 202406L (C++26) P2075R6
__cpp_lib_ranges Ranges-Bibliothek und eingeschränkte Algorithmen 201911L (C++20) P0896R4
P1035R7
P1716R3
Nicht- default-initialisierbare Views 202106L (C++23)
(DR20) 		P2325R3
Views mit Besitz 202110L P2415R2
std::ranges::range_adaptor_closure 202202L (C++23) P2387R3
Lockerung der range adaptors zur Unterstützung von move-only Typen 202207L P2494R2
Entfernung der „Poison Pill“-Überladungen in ranges::begin , ranges::end , ranges::rbegin , ranges::rend , und ranges::size 202211L P2602R2
Erweiterung von Ranges zur Zulassung bestimmter Projektionen 202302L P2609R3
Entfernen der gemeinsamen Referenzanforderung von den indirekt aufrufbaren Konzepten 202406L (C++26)
(DR20) 		P2997R1
__cpp_lib_ranges_ as_const std::const_iterator , std::ranges::as_const_view 202207L (C++23) P2278R4
Sicherstellen, dass std::basic_const_iterator die Konvertierbarkeit seines zugrundeliegenden Typs befolgt 202311L (C++26) P2836R1
__cpp_lib_ranges_ as_rvalue std::ranges::as_rvalue_view 202207L (C++23) P2446R2
__cpp_lib_ranges_ cache_latest std::ranges::cache_latest_view 202411L (C++26) P3138R5
__cpp_lib_ranges_ cartesian_product std::ranges::cartesian_product_view 202207L (C++23) P2374R4
P2540R1
__cpp_lib_ranges_ chunk std::ranges::chunk_view 202202L (C++23) P2442R1
__cpp_lib_ranges_ chunk_by std::ranges::chunk_by_view 202202L (C++23) P2443R1
__cpp_lib_ranges_ concat std::ranges::concat_view 202403L (C++26) P2542R8
__cpp_lib_ranges_ contains std::ranges::contains 202207L (C++23) P2302R4
__cpp_lib_ranges_ enumerate std::ranges::enumerate_view 202302L (C++23) P2164R9
__cpp_lib_ranges_ find_last std::ranges::find_last , std::ranges::find_last_if , und std::ranges::find_last_if_not 202207L (C++23) P1223R5
LWG3807
__cpp_lib_ranges_ fold std::ranges Fold-Algorithmen 202207L (C++23) P2322R6
__cpp_lib_ranges_ generate_random Vektor-API für Zufallszahlengenerierung ( std::ranges::generate_random ) 202403L (C++26) P1068R11
__cpp_lib_ranges_ iota std::ranges::iota 202202L (C++23) P2440R1
__cpp_lib_ranges_ join_with std::ranges::join_with_view 202202L (C++23) P2441R2
__cpp_lib_ranges_ repeat std::ranges::repeat_view 202207L (C++23) P2474R2
__cpp_lib_ranges_ reserve_hint std::ranges::approximately_sized_range und std::ranges::reserve_hint 202502L (C++26) P2846R6
__cpp_lib_ranges_ slide std::ranges::slide_view 202202L (C++23) P2442R1
__cpp_lib_ranges_ starts_ends_with std::ranges::starts_with , std::ranges::ends_with 202106L (C++23) P1659R3
__cpp_lib_ranges_ stride std::ranges::stride_view 202207L (C++23) P1899R3
__cpp_lib_ranges_ to_container std::ranges::to 202202L (C++23) P1206R7
__cpp_lib_ranges_ to_input std::ranges::to_input_view 202502L (C++26) P3137R3
__cpp_lib_ranges_ zip std::ranges::zip_view , std::ranges::zip_transform_view , std::ranges::adjacent_view , std::ranges::adjacent_transform_view 202110L (C++23) P2321R2
__cpp_lib_ratio Hinzufügen der neuen SI-Präfixe von 2022 202306L (C++26) P2734R0
__cpp_lib_raw_memory_ algorithms Erweiterung der Speicherverwaltungswerkzeuge 201606L (C++17) P0040R3
constexpr für spezialisierte Speicheralgorithmen 202411L (C++26) P3508R0
P3369R0
__cpp_lib_rcu <rcu> : Read-Copy Update (RCU) 202306L (C++26) P2545R4
__cpp_lib_reference_ from_temporary std::reference_constructs_from_temporary und std::reference_converts_from_temporary 202202L (C++23) P2255R2
__cpp_lib_reference_ wrapper Vergleiche für std::reference_wrapper 202403L (C++26) P2944R3
__cpp_lib_remove_ cvref std::remove_cvref 201711L (C++20) P0550R2
__cpp_lib_result_ of_sfinae std::result_of und SFINAE 201210L (C++14) N3462
__cpp_lib_robust_ nonmodifying_seq_ops Nicht-modifizierende Sequenzoperationen robuster gestalten (Zwei-Bereich-Überladungen für std::mismatch , std::equal und std::is_permutation ) 201304L (C++14) N3671
__cpp_lib_sample std::sample 201603L (C++17) P0220R1
__cpp_lib_saturation_ arithmetic Sättigungsarithmetik 202311L (C++26) P0543R3
__cpp_lib_scoped_ lock std::scoped_lock 201703L (C++17) P0156R2
__cpp_lib_semaphore std::counting_semaphore , std::binary_semaphore 201907L (C++20) P1135R6
__cpp_lib_senders std::execution : Sender-Empfänger-Modell der Ausführungssteuerung 202406L (C++26) P2300R10
__cpp_lib_shared_ mutex std::shared_mutex (untimed) 201505L (C++17) N4508
__cpp_lib_shared_ ptr_arrays std::shared_ptr<T[]> 201611L (C++17) P0497R0
Array-Unterstützung von std::make_shared 201707L (C++20) P0674R1
__cpp_lib_shared_ ptr_weak_type shared_ptr::weak_type 201606L (C++17) P0163R0
__cpp_lib_shared_ timed_mutex std::shared_timed_mutex 201402L (C++14) N3891
__cpp_lib_shift std::shift_left und std::shift_right 201806L (C++20) P0769R2
std::ranges::shift_left und std::ranges::shift_right 202202L (C++23) P2440R1
__cpp_lib_simd <simd> : Datenparallele Typen 202411L (C++26) P1928R15
P3430R3
P3441R2
P3287R3
P2933R4
__cpp_lib_simd_complex Unterstützung von verschachtelten komplexen Werten in std::datapar::simd 202502L (C++26) P2663R7
__cpp_lib_smart_ ptr_for_overwrite Erstellung intelligenter Zeiger mit Standardinitialisierung ( std::allocate_shared_for_overwrite , std::make_shared_for_overwrite , std::make_unique_for_overwrite ) 202002L (C++20) P1020R1
P1973R1
__cpp_lib_smart_ ptr_owner_equality Ermöglicht die Verwendung von std::weak_ptr als Schlüssel in ungeordneten assoziativen Containern 202306L (C++26) P1901R2
__cpp_lib_source_ location Erfassung von Quellcode-Informationen ( std::source_location ) 201907L (C++20) P1208R6
__cpp_lib_span std::span 202002L (C++20) P0122R7
LWG3274
P1024R3
P1976R2
Teile von std::span freistehend machen 202311L (C++26) P2821R5
P2833R2
__cpp_lib_span_initializer_ list Konstruieren eines std::span aus einer Initialisierungsliste 202311L (C++26) P2447R6
__cpp_lib_spanstream std::spanbuf , std::spanstream 202106L (C++23) P0448R4
__cpp_lib_ssize std::ssize und vorzeichenlos std::span::size 201902L (C++20) P1227R2
__cpp_lib_sstream_ from_string_view Verbindung von std::stringstream mit std::string_view 202306L (C++26) P2495R3
__cpp_lib_stacktrace Stacktrace-Bibliothek 202011L (C++23) P0881R7
__cpp_lib_start_ lifetime_as Explizite Lebensdauerverwaltung ( std::start_lifetime_as ) 202207L (C++23) P2590R2
__cpp_lib_starts_ ends_with String-Präfix- und -Suffix-Prüfung ( starts_with() und ends_with() für std::string und std::string_view ) 201711L (C++20) P0457R2
__cpp_lib_stdatomic_ h Kompatibilitätsheader für C-Atomoperationen 202011L (C++23) P0943R6
__cpp_lib_string_ contains contains() für std::basic_string und std::basic_string_view 202011L (C++23) P1679R3
__cpp_lib_string_ resize_and_overwrite std::basic_string::resize_and_overwrite 202110L (C++23) P1072R10
__cpp_lib_string_ udls Benutzerdefinierte Literale für String-Typen 201304L (C++14) N3642
__cpp_lib_string_ view std::string_view 201606L (C++17) P0220R1
P0254R2
ConstexprIterator 201803L (C++20) P0858R0
LWG3257
Verkettung von std::string s und std::string_view s 202403L (C++26) P2591R5
__cpp_lib_submdspan std::submdspan 202306L (C++26) P2630R4
Gepolsterte mdspan-Layouts 202403L P2642R6
__cpp_lib_syncbuf Synchronisierter gepufferter Ostream ( std::syncbuf , std::osyncstream ) und Manipulatoren 201803L (C++20) P0053R7
P0753R2
__cpp_lib_text_encoding std::text_encoding 202306L (C++26) P1885R12
__cpp_lib_three_ way_comparison Dreiweg-Vergleich (Bibliotheksunterstützung); Hinzufügen des Dreiweg-Vergleichs zur Bibliothek 201907L (C++20) P0768R1
P1614R2
__cpp_lib_to_address Hilfsmittel zur Konvertierung eines Zeigers in einen Rohzeiger ( std::to_address ) 201711L (C++20) P0653R2
__cpp_lib_to_array std::to_array 201907L (C++20) P0325R4
__cpp_lib_to_chars Elementare String-Konvertierungen ( std::to_chars , std::from_chars ) 201611L (C++17) P0067R5
P0682R1
LWG3137
Testen auf Erfolg oder Misserfolg von <charconv> Funktionen 202306L (C++26) P2497R0
__cpp_lib_to_string Neudefinition von std::to_string in Bezug auf std::format 202306L (C++26) P2587R3
__cpp_lib_to_underlying std::to_underlying 202102L (C++23) P1682R3
__cpp_lib_transformation_ trait_aliases Alias-Vorlagen für Transformationstraits 201304L (C++14) N3655
__cpp_lib_transparent_ operators Transparente Operator-Funktoren ( std::less<> et al) 201210L (C++14) N3421
Transparent std::owner_less ( std::owner_less<void> ) 201510L (C++17) P0074R0
__cpp_lib_trivially_ relocatable Triviale Relokationsmerkmale und Operationen 202502L (C++26) P2786R13
__cpp_lib_tuple_ element_t std::tuple_element_t 201402L (C++14) N3887
__cpp_lib_tuple_ like Kompatibilität zwischen std::tuple und tuple-ähnlichen Objekten ( std::pair , std::array , std::subrange ) 202207L (C++23) P2165R4
Tupel-Protokoll zu std::complex hinzufügen 202311L (C++26) P2819R2
__cpp_lib_tuples_ by_type Zugriff auf Tupel nach Typ 201304L (C++14) N3670
__cpp_lib_type_identity std::type_identity 201806L (C++20) P0887R1
__cpp_lib_type_trait_ variable_templates Type-Traits-Variablenvorlagen ( std::is_void_v , etc.) 201510L (C++17) P0006R0
__cpp_lib_uncaught_ exceptions std::uncaught_exceptions 201411L (C++17) N4259
__cpp_lib_unordered_ map_try_emplace std::unordered_map::try_emplace , std::unordered_map::insert_or_assign 201411L (C++17) N4279
__cpp_lib_unreachable std::unreachable 202202L (C++23) P0627R6
__cpp_lib_unwrap_ ref std::unwrap_ref_decay und std::unwrap_reference 201811L (C++20) P0318R1
LWG3348
__cpp_lib_variant std::variant : Eine typsichere Union für C++17 201606L (C++17) P0088R3
P0393R3
P0032R3
std::visit für Klassen abgeleitet von std::variant 202102L (C++23)
(DR17) 		P2162R2
Vollständig constexpr std::variant 202106L (C++23)
(DR20) 		P2231R1
Member visit 202306L (C++26) P2637R3
__cpp_lib_void_t std::void_t 201411L (C++17) N3911
Gesamtzahl der Makros: 282

Beispiel

Normale Verwendung

Diesen Code ausführen 
#ifdef __has_include                           // Prüfe ob __has_include vorhanden ist
#  if __has_include(<optional>)                // Prüfe auf eine Standardbibliothek
#    include <optional>
#  elif __has_include(<experimental/optional>) // Prüfe auf eine experimentelle Version
#    include <experimental/optional>
#  elif __has_include(<boost/optional.hpp>)    // Versuche mit einer externen Bibliothek
#    include <boost/optional.hpp>
#  else                                        // Überhaupt nicht gefunden
#     error "Missing <optional>"
#  endif
#endif
#ifdef __has_cpp_attribute                      // Prüfe ob __has_cpp_attribute vorhanden ist
#  if __has_cpp_attribute(deprecated)           // Prüfe auf ein Attribut
#    define DEPRECATED(msg) [[deprecated(msg)]]
#  endif
#endif
#ifndef DEPRECATED
#    define DEPRECATED(msg)
#endif
DEPRECATED("foo() has been deprecated") void foo();
#if __cpp_constexpr >= 201304                // Prüfe auf eine spezifische Version eines Features
#  define CONSTEXPR constexpr
#else
#  define CONSTEXPR inline
#endif
CONSTEXPR int bar(unsigned i)
{
#if __cpp_binary_literals                    // Prüfe auf das Vorhandensein eines Features
    unsigned mask1 = 0b11000000;
    unsigned mask2 = 0b00000111;
#else
    unsigned mask1 = 0xC0;
    unsigned mask2 = 0x07;
#endif
    if (i & mask1)
        return 1;
    if (i & mask2)
        return 2;
    return 0;
}
int main() {}

Compiler-Funktionen-Ausgabe

Das folgende (C++11-kompatible) Programm gibt C++-Compiler-Features und Attribute aus. Beachten Sie, dass die Verwendung von __has_cpp_attribute ( ) nicht konform ist und von der gcc/clang-Implementierung abhängt.

Diesen Code ausführen 
static constexpr struct choose_what_and_how_to_print
{
    constexpr static int longest_macro_name { 45 };
    constexpr static bool titles               = 1;
    constexpr static bool counters             = 1;
    constexpr static bool attributes           = 1;
    constexpr static bool standard_values      = 1;
    constexpr static bool compiler_specific    = 1;
    constexpr static bool core_features        = 1;
    constexpr static bool lib_features         = 1;
    constexpr static bool supported_features   = 1;
    constexpr static bool unsupported_features = 1;
    constexpr static bool sort_by_date         = 0;
    constexpr static bool separate_year_month  = 1;
    constexpr static bool separated_revisions  = 1;
    constexpr static bool latest_revisions     = 1;
    constexpr static bool cxx98                = 0;
    constexpr static bool cxx11                = 1;
    constexpr static bool cxx14                = 1;
    constexpr static bool cxx17                = 1;
    constexpr static bool cxx20                = 1;
    constexpr static bool cxx23                = 1;
    constexpr static bool cxx26                = 1;
    constexpr static bool cxx29                = 0;
} print;
#if __cplusplus < 201100
#  error "C++11 oder höher wird benötigt"
#endif
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <utility>
#include <vector>
#ifdef __has_include
# if __has_include(<version>)
#   include <version>
# endif
# if __has_include(<stdfloat>)
#   include <stdfloat>
# endif
#endif
// Erwarte einen String, der mit 6 Dezimalziffern beginnt oder mit '_' (falls nicht unterstützt)
#define COMPILER_VALUE_INT(n) #n [0] == '_' ? 0 : \
    (#n[5] - '0') + (#n[4] - '0') * 10 + (#n[3] - '0') * 100 + \
    (#n[2] - '0') * 1000 + (#n[1] - '0') * 10000 + (#n[0] - '0') * 100000
#define COMPILER_FEATURE_ENTRY(expect, name) { #name, COMPILER_VALUE_INT(name), expect },
#if defined(__has_cpp_attribute) && defined(__GNUG__)
# define COMPILER_ATTRIBUTE(expect, name) { #name, __has_cpp_attribute(name), expect },
#else
# define COMPILER_ATTRIBUTE(expect, name) { #name, COMPILER_VALUE_INT(name), expect },
#endif
#define COMPILER_SPECIFIC_STRING(value) #value
#define COMPILER_SPECIFIC_ENTRY(name) { #name, COMPILER_SPECIFIC_STRING(name) },
class CompilerFeature
{
    char const* name_; long data_; long std_;
public:
    constexpr CompilerFeature(char const* name, long data, long std)
        : name_(name), data_(data), std_(std) {}
    constexpr CompilerFeature(CompilerFeature const&) = default;
    CompilerFeature& operator=(CompilerFeature const&) = default;
    bool operator<(CompilerFeature const& rhs) const
        { return std::strcmp(name_, rhs.name_) < 0; }
    bool operator==(CompilerFeature const& rhs) const
        { return std::strcmp(name_, rhs.name_) == 0; }
    constexpr bool supported() const { return data_ >= std_; }
    constexpr bool maybe() const { return data_ > 0; }
    constexpr char const* name() const { return name_; }
    constexpr long std() const { return std_; }
    constexpr long data() const { return data_; }
    void data(long x) { data_ = x; }
};
// Nicht-FTM-Makros, einschließlich implementierungsspezifischer:
static /*constexpr*/ std::pair<const char*, const char*> compiler[] = {
    COMPILER_SPECIFIC_ENTRY(__cplusplus)
    COMPILER_SPECIFIC_ENTRY(__clang_major__)
    COMPILER_SPECIFIC_ENTRY(__clang_minor__)
    COMPILER_SPECIFIC_ENTRY(__clang_patchlevel__)
    COMPILER_SPECIFIC_ENTRY(__GNUG__)
    COMPILER_SPECIFIC_ENTRY(__GNUC_MINOR__)
    COMPILER_SPECIFIC_ENTRY(__GNUC_PATCHLEVEL__)
    // Optionale <stdfloat> Festbreiten-Gleitkommatypen (C++23)
    COMPILER_SPECIFIC_ENTRY(__STDCPP_FLOAT16_T__)
    COMPILER_SPECIFIC_ENTRY(__STDCPP_FLOAT32_T__)
    COMPILER_SPECIFIC_ENTRY(__STDCPP_FLOAT64_T__)
    COMPILER_SPECIFIC_ENTRY(__STDCPP_FLOAT128_T__)
    COMPILER_SPECIFIC_ENTRY(__STDCPP_BFLOAT16_T__)
    // C23 => C++26
    COMPILER_SPECIFIC_ENTRY(__STDC_ENDIAN_BIG__)
    COMPILER_SPECIFIC_ENTRY(__STDC_ENDIAN_LITTLE__)
    COMPILER_SPECIFIC_ENTRY(__STDC_ENDIAN_NATIVE__)
    COMPILER_SPECIFIC_ENTRY(__STDC_VERSION_STDBIT_H__)
    COMPILER_SPECIFIC_ENTRY(__STDC_VERSION_STDCKDINT_H__)
    // Fügen Sie hier Ihre bevorzugten implementierungsspezifischen Makros hinzu...
    COMPILER_SPECIFIC_ENTRY(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
    COMPILER_SPECIFIC_ENTRY(__STDCPP_THREADS__)
    COMPILER_SPECIFIC_ENTRY(__STDCPP_STRICT_POINTER_SAFETY__)
    COMPILER_SPECIFIC_ENTRY(__STDC_EMBED_NOT_FOUND__)
    COMPILER_SPECIFIC_ENTRY(__STDC_EMBED_FOUND__)
    COMPILER_SPECIFIC_ENTRY(__STDC_EMBED_EMPTY__)
    COMPILER_SPECIFIC_ENTRY(__STDC__)
    COMPILER_SPECIFIC_ENTRY(__STDC_VERSION__)
    COMPILER_SPECIFIC_ENTRY(__STDC_HOSTED__)
    COMPILER_SPECIFIC_ENTRY(__STDC_ISO_10646__)
    COMPILER_SPECIFIC_ENTRY(__STDC_MB_MIGHT_NEQ_WC__)
    COMPILER_SPECIFIC_ENTRY(__DATE__)
    COMPILER_SPECIFIC_ENTRY(__TIME__)
};
static constexpr CompilerFeature cxx98_core[] = {
    COMPILER_FEATURE_ENTRY(199711L, __cpp_exceptions)
    COMPILER_FEATURE_ENTRY(199711L, __cpp_rtti)
};
static constexpr CompilerFeature cxx11_core[] = {
    COMPILER_FEATURE_ENTRY(200704L, __cpp_alias_templates)
    COMPILER_FEATURE_ENTRY(200809L, __cpp_attributes)
    COMPILER_FEATURE_ENTRY(200704L, __cpp_constexpr)
    COMPILER_FEATURE_ENTRY(201711L, __cpp_constexpr_in_decltype)
    COMPILER_FEATURE_ENTRY(200707L, __cpp_decltype)
    COMPILER_FEATURE_ENTRY(200604L, __cpp_delegating_constructors)
    COMPILER_FEATURE_ENTRY(201511L, __cpp_inheriting_constructors)
    COMPILER_FEATURE_ENTRY(200806L, __cpp_initializer_lists)
    COMPILER_FEATURE_ENTRY(200907L, __cpp_lambdas)
    COMPILER_FEATURE_ENTRY(200809L, __cpp_nsdmi)
    COMPILER_FEATURE_ENTRY(200907L, __cpp_range_based_for)
    COMPILER_FEATURE_ENTRY(200710L, __cpp_raw_strings)
    COMPILER_FEATURE_ENTRY(200710L, __cpp_ref_qualifiers)
    COMPILER_FEATURE_ENTRY(200610L, __cpp_rvalue_references)
    COMPILER_FEATURE_ENTRY(200410L, __cpp_static_assert)
    COMPILER_FEATURE_ENTRY(200806L, __cpp_threadsafe_static_init)
    COMPILER_FEATURE_ENTRY(200704L, __cpp_unicode_characters)
    COMPILER_FEATURE_ENTRY(200710L, __cpp_unicode_literals)
    COMPILER_FEATURE_ENTRY(200809L, __cpp_user_defined_literals)
    COMPILER_FEATURE_ENTRY(200704L, __cpp_variadic_templates)
};
static constexpr CompilerFeature cxx14_core[] = {
    COMPILER_FEATURE_ENTRY(201304L, __cpp_aggregate_nsdmi)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_binary_literals)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_constexpr)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_decltype_auto)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_generic_lambdas)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_init_captures)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_return_type_deduction)
    COMPILER_FEATURE_ENTRY(201309L, __cpp_sized_deallocation)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_variable_templates)
};
static constexpr CompilerFeature cxx14_lib[] = {
    COMPILER_FEATURE_ENTRY(201304L, __cpp_lib_chrono_udls)
    COMPILER_FEATURE_ENTRY(201309L, __cpp_lib_complex_udls)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_lib_exchange_function)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_lib_generic_associative_lookup)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_lib_integer_sequence)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_lib_integral_constant_callable)
    COMPILER_FEATURE_ENTRY(201402L, __cpp_lib_is_final)
    COMPILER_FEATURE_ENTRY(201309L, __cpp_lib_is_null_pointer)
    COMPILER_FEATURE_ENTRY(201402L, __cpp_lib_make_reverse_iterator)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_lib_make_unique)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_lib_null_iterators)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_lib_quoted_string_io)
    COMPILER_FEATURE_ENTRY(201210L, __cpp_lib_result_of_sfinae)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_lib_robust_nonmodifying_seq_ops)
    COMPILER_FEATURE_ENTRY(201402L, __cpp_lib_shared_timed_mutex)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_lib_string_udls)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_lib_transformation_trait_aliases)
    COMPILER_FEATURE_ENTRY(201210L, __cpp_lib_transparent_operators)
    COMPILER_FEATURE_ENTRY(201402L, __cpp_lib_tuple_element_t)
    COMPILER_FEATURE_ENTRY(201304L, __cpp_lib_tuples_by_type)
};
static constexpr CompilerFeature cxx17_core[] = {
    COMPILER_FEATURE_ENTRY(201603L, __cpp_aggregate_bases)
    COMPILER_FEATURE_ENTRY(201606L, __cpp_aligned_new)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_capture_star_this)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_constexpr)
    COMPILER_FEATURE_ENTRY(201703L, __cpp_deduction_guides)
    COMPILER_FEATURE_ENTRY(201411L, __cpp_enumerator_attributes)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_fold_expressions)
    COMPILER_FEATURE_ENTRY(201606L, __cpp_guaranteed_copy_elision)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_hex_float)
    COMPILER_FEATURE_ENTRY(201606L, __cpp_if_constexpr)
    COMPILER_FEATURE_ENTRY(201606L, __cpp_inline_variables)
    COMPILER_FEATURE_ENTRY(201411L, __cpp_namespace_attributes)
    COMPILER_FEATURE_ENTRY(201510L, __cpp_noexcept_function_type)
    COMPILER_FEATURE_ENTRY(201411L, __cpp_nontype_template_args)
    COMPILER_FEATURE_ENTRY(201606L, __cpp_nontype_template_parameter_auto)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_range_based_for)
    COMPILER_FEATURE_ENTRY(201411L, __cpp_static_assert)
    COMPILER_FEATURE_ENTRY(201606L, __cpp_structured_bindings)
    COMPILER_FEATURE_ENTRY(201611L, __cpp_template_template_args)
    COMPILER_FEATURE_ENTRY(201611L, __cpp_variadic_using)
};
static constexpr CompilerFeature cxx17_lib[] = {
    COMPILER_FEATURE_ENTRY(201603L, __cpp_lib_addressof_constexpr)
    COMPILER_FEATURE_ENTRY(201411L, __cpp_lib_allocator_traits_is_always_equal)
    COMPILER_FEATURE_ENTRY(201606L, __cpp_lib_any)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_lib_apply)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_lib_array_constexpr)
    COMPILER_FEATURE_ENTRY(201510L, __cpp_lib_as_const)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_lib_atomic_is_always_lock_free)
    COMPILER_FEATURE_ENTRY(201505L, __cpp_lib_bool_constant)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_lib_boyer_moore_searcher)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_lib_byte)
    COMPILER_FEATURE_ENTRY(201611L, __cpp_lib_chrono)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_lib_clamp)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_lib_enable_shared_from_this)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_lib_execution)
    COMPILER_FEATURE_ENTRY(201703L, __cpp_lib_filesystem)
    COMPILER_FEATURE_ENTRY(201606L, __cpp_lib_gcd_lcm)
    COMPILER_FEATURE_ENTRY(201703L, __cpp_lib_hardware_interference_size)
    COMPILER_FEATURE_ENTRY(201606L, __cpp_lib_has_unique_object_representations)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_lib_hypot)
    COMPILER_FEATURE_ENTRY(201505L, __cpp_lib_incomplete_container_elements)
    COMPILER_FEATURE_ENTRY(201411L, __cpp_lib_invoke)
    COMPILER_FEATURE_ENTRY(201703L, __cpp_lib_is_aggregate)
    COMPILER_FEATURE_ENTRY(201703L, __cpp_lib_is_invocable)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_lib_is_swappable)
    COMPILER_FEATURE_ENTRY(201606L, __cpp_lib_launder)
    COMPILER_FEATURE_ENTRY(201510L, __cpp_lib_logical_traits)
    COMPILER_FEATURE_ENTRY(201606L, __cpp_lib_make_from_tuple)
    COMPILER_FEATURE_ENTRY(201411L, __cpp_lib_map_try_emplace)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_lib_math_special_functions)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_lib_memory_resource)
    COMPILER_FEATURE_ENTRY(201606L, __cpp_lib_node_extract)
    COMPILER_FEATURE_ENTRY(201411L, __cpp_lib_nonmember_container_access)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_lib_not_fn)
    COMPILER_FEATURE_ENTRY(201606L, __cpp_lib_optional)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_lib_parallel_algorithm)
    COMPILER_FEATURE_ENTRY(201606L, __cpp_lib_raw_memory_algorithms)
    COMPILER_FEATURE_ENTRY(201603L, __cpp_lib_sample)
    COMPILER_FEATURE_ENTRY(201703L, __cpp_lib_scoped_lock)
    COMPILER_FEATURE_ENTRY(201505L, __cpp_lib_shared_mutex)
    COMPILER_FEATURE_ENTRY(201611L, __cpp_lib_shared_ptr_arrays)
    COMPILER_FEATURE_ENTRY(201606L, __cpp_lib_shared_ptr_weak_type)
    COMPILER_FEATURE_ENTRY(201606L, __cpp_lib_string_view)
    COMPILER_FEATURE_ENTRY(201611L, __cpp_lib_to_chars)
    COMPILER_FEATURE_ENTRY(201510L, __cpp_lib_transparent_operators)
    COMPILER_FEATURE_ENTRY(201510L, __cpp_lib_type_trait_variable_templates)
    COMPILER_FEATURE_ENTRY(201411L, __cpp_lib_uncaught_exceptions)
    COMPILER_FEATURE_ENTRY(201411L, __cpp_lib_unordered_map_try_emplace)
    COMPILER_FEATURE_ENTRY(202102L, __cpp_lib_variant)
    COMPILER_FEATURE_ENTRY(201411L, __cpp_lib_void_t)
};
static constexpr CompilerFeature cxx20_core[] = {
    COMPILER_FEATURE_ENTRY(201902L, __cpp_aggregate_paren_init)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_char8_t)
    COMPILER_FEATURE_ENTRY(202002L, __cpp_concepts)
    COMPILER_FEATURE_ENTRY(201806L, __cpp_conditional_explicit)
    COMPILER_FEATURE_ENTRY(202211L, __cpp_consteval)
    COMPILER_FEATURE_ENTRY(202002L, __cpp_constexpr)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_constexpr_dynamic_alloc)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_constinit)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_deduction_guides)
    COMPILER_FEATURE_ENTRY(201707L, __cpp_designated_initializers)
    COMPILER_FEATURE_ENTRY(201707L, __cpp_generic_lambdas)
    COMPILER_FEATURE_ENTRY(201902L, __cpp_impl_coroutine)
    COMPILER_FEATURE_ENTRY(201806L, __cpp_impl_destroying_delete)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_impl_three_way_comparison)
    COMPILER_FEATURE_ENTRY(201803L, __cpp_init_captures)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_modules)
    COMPILER_FEATURE_ENTRY(201911L, __cpp_nontype_template_args)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_using_enum)
};
static constexpr CompilerFeature cxx20_lib[] = {
    COMPILER_FEATURE_ENTRY(201811L, __cpp_lib_array_constexpr)
    COMPILER_FEATURE_ENTRY(201811L, __cpp_lib_assume_aligned)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_atomic_flag_test)
    COMPILER_FEATURE_ENTRY(201711L, __cpp_lib_atomic_float)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_atomic_lock_free_type_aliases)
    COMPILER_FEATURE_ENTRY(201806L, __cpp_lib_atomic_ref)
    COMPILER_FEATURE_ENTRY(201711L, __cpp_lib_atomic_shared_ptr)
    COMPILER_FEATURE_ENTRY(201911L, __cpp_lib_atomic_value_initialization)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_atomic_wait)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_barrier)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_bind_front)
    COMPILER_FEATURE_ENTRY(201806L, __cpp_lib_bit_cast)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_bitops)
    COMPILER_FEATURE_ENTRY(201902L, __cpp_lib_bounded_array_traits)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_char8_t)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_chrono)
    COMPILER_FEATURE_ENTRY(202002L, __cpp_lib_concepts)
    COMPILER_FEATURE_ENTRY(201806L, __cpp_lib_constexpr_algorithms)
    COMPILER_FEATURE_ENTRY(201711L, __cpp_lib_constexpr_complex)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_constexpr_dynamic_alloc)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_constexpr_functional)
    COMPILER_FEATURE_ENTRY(201811L, __cpp_lib_constexpr_iterator)
    COMPILER_FEATURE_ENTRY(201811L, __cpp_lib_constexpr_memory)
    COMPILER_FEATURE_ENTRY(201911L, __cpp_lib_constexpr_numeric)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_constexpr_string)
    COMPILER_FEATURE_ENTRY(201811L, __cpp_lib_constexpr_string_view)
    COMPILER_FEATURE_ENTRY(201811L, __cpp_lib_constexpr_tuple)
    COMPILER_FEATURE_ENTRY(201811L, __cpp_lib_constexpr_utility)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_constexpr_vector)
    COMPILER_FEATURE_ENTRY(201902L, __cpp_lib_coroutine)
    COMPILER_FEATURE_ENTRY(201806L, __cpp_lib_destroying_delete)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_endian)
    COMPILER_FEATURE_ENTRY(202002L, __cpp_lib_erase_if)
    COMPILER_FEATURE_ENTRY(201902L, __cpp_lib_execution)
    COMPILER_FEATURE_ENTRY(202110L, __cpp_lib_format)
    COMPILER_FEATURE_ENTRY(201811L, __cpp_lib_generic_unordered_lookup)
    COMPILER_FEATURE_ENTRY(202002L, __cpp_lib_int_pow2)
    COMPILER_FEATURE_ENTRY(202002L, __cpp_lib_integer_comparison_functions)
    COMPILER_FEATURE_ENTRY(201902L, __cpp_lib_interpolate)
    COMPILER_FEATURE_ENTRY(201811L, __cpp_lib_is_constant_evaluated)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_is_layout_compatible)
    COMPILER_FEATURE_ENTRY(201806L, __cpp_lib_is_nothrow_convertible)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_is_pointer_interconvertible)
    COMPILER_FEATURE_ENTRY(201911L, __cpp_lib_jthread)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_latch)
    COMPILER_FEATURE_ENTRY(201806L, __cpp_lib_list_remove_return_type)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_math_constants)
    COMPILER_FEATURE_ENTRY(202106L, __cpp_lib_optional)
    COMPILER_FEATURE_ENTRY(201902L, __cpp_lib_polymorphic_allocator)
    COMPILER_FEATURE_ENTRY(202110L, __cpp_lib_ranges)
    COMPILER_FEATURE_ENTRY(201711L, __cpp_lib_remove_cvref)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_semaphore)
    COMPILER_FEATURE_ENTRY(201707L, __cpp_lib_shared_ptr_arrays)
    COMPILER_FEATURE_ENTRY(201806L, __cpp_lib_shift)
    COMPILER_FEATURE_ENTRY(202002L, __cpp_lib_smart_ptr_for_overwrite)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_source_location)
    COMPILER_FEATURE_ENTRY(202002L, __cpp_lib_span)
    COMPILER_FEATURE_ENTRY(201902L, __cpp_lib_ssize)
    COMPILER_FEATURE_ENTRY(201711L, __cpp_lib_starts_ends_with)
    COMPILER_FEATURE_ENTRY(201803L, __cpp_lib_string_view)
    COMPILER_FEATURE_ENTRY(201803L, __cpp_lib_syncbuf)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_three_way_comparison)
    COMPILER_FEATURE_ENTRY(201711L, __cpp_lib_to_address)
    COMPILER_FEATURE_ENTRY(201907L, __cpp_lib_to_array)
    COMPILER_FEATURE_ENTRY(201806L, __cpp_lib_type_identity)
    COMPILER_FEATURE_ENTRY(201811L, __cpp_lib_unwrap_ref)
    COMPILER_FEATURE_ENTRY(202106L, __cpp_lib_variant)
};
static constexpr CompilerFeature cxx23_core[] = {
    COMPILER_FEATURE_ENTRY(202110L, __cpp_auto_cast)
    COMPILER_FEATURE_ENTRY(202211L, __cpp_constexpr)
    COMPILER_FEATURE_ENTRY(202110L, __cpp_explicit_this_parameter)
    COMPILER_FEATURE_ENTRY(202106L, __cpp_if_consteval)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_implicit_move)
    COMPILER_FEATURE_ENTRY(202211L, __cpp_multidimensional_subscript)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_named_character_escapes)
    COMPILER_FEATURE_ENTRY(202211L, __cpp_range_based_for)
    COMPILER_FEATURE_ENTRY(202011L, __cpp_size_t_suffix)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_static_call_operator)
};
static constexpr CompilerFeature cxx23_lib[] = {
    COMPILER_FEATURE_ENTRY(202106L, __cpp_lib_adaptor_iterator_pair_constructor)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_algorithm_iterator_requirements)
    COMPILER_FEATURE_ENTRY(202302L, __cpp_lib_allocate_at_least)
    COMPILER_FEATURE_ENTRY(202110L, __cpp_lib_associative_heterogeneous_erasure)
    COMPILER_FEATURE_ENTRY(202302L, __cpp_lib_barrier)
    COMPILER_FEATURE_ENTRY(202202L, __cpp_lib_bind_back)
    COMPILER_FEATURE_ENTRY(202110L, __cpp_lib_byteswap)
    COMPILER_FEATURE_ENTRY(202302L, __cpp_lib_common_reference)
    COMPILER_FEATURE_ENTRY(202302L, __cpp_lib_common_reference_wrapper)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_concepts)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_constexpr_bitset)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_constexpr_charconv)
    COMPILER_FEATURE_ENTRY(202202L, __cpp_lib_constexpr_cmath)
    COMPILER_FEATURE_ENTRY(202202L, __cpp_lib_constexpr_memory)
    COMPILER_FEATURE_ENTRY(202106L, __cpp_lib_constexpr_typeinfo)
    COMPILER_FEATURE_ENTRY(202202L, __cpp_lib_containers_ranges)
    COMPILER_FEATURE_ENTRY(202211L, __cpp_lib_expected)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_flat_map)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_flat_set)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_format)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_format_ranges)
    COMPILER_FEATURE_ENTRY(202302L, __cpp_lib_formatters)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_forward_like)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_generator)
    COMPILER_FEATURE_ENTRY(202106L, __cpp_lib_invoke_r)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_ios_noreplace)
    COMPILER_FEATURE_ENTRY(202302L, __cpp_lib_is_implicit_lifetime)
    COMPILER_FEATURE_ENTRY(202011L, __cpp_lib_is_scoped_enum)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_mdspan)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_modules)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_move_iterator_concept)
    COMPILER_FEATURE_ENTRY(202110L, __cpp_lib_move_only_function)
    COMPILER_FEATURE_ENTRY(202110L, __cpp_lib_optional)
    COMPILER_FEATURE_ENTRY(202106L, __cpp_lib_out_ptr)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_print)
    COMPILER_FEATURE_ENTRY(202302L, __cpp_lib_ranges)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_ranges_as_const)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_ranges_as_rvalue)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_ranges_cartesian_product)
    COMPILER_FEATURE_ENTRY(202202L, __cpp_lib_ranges_chunk)
    COMPILER_FEATURE_ENTRY(202202L, __cpp_lib_ranges_chunk_by)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_ranges_contains)
    COMPILER_FEATURE_ENTRY(202302L, __cpp_lib_ranges_enumerate)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_ranges_find_last)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_ranges_fold)
    COMPILER_FEATURE_ENTRY(202202L, __cpp_lib_ranges_iota)
    COMPILER_FEATURE_ENTRY(202202L, __cpp_lib_ranges_join_with)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_ranges_repeat)
    COMPILER_FEATURE_ENTRY(202202L, __cpp_lib_ranges_slide)
    COMPILER_FEATURE_ENTRY(202106L, __cpp_lib_ranges_starts_ends_with)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_ranges_stride)
    COMPILER_FEATURE_ENTRY(202202L, __cpp_lib_ranges_to_container)
    COMPILER_FEATURE_ENTRY(202110L, __cpp_lib_ranges_zip)
    COMPILER_FEATURE_ENTRY(202202L, __cpp_lib_reference_from_temporary)
    COMPILER_FEATURE_ENTRY(202202L, __cpp_lib_shift)
    COMPILER_FEATURE_ENTRY(202106L, __cpp_lib_spanstream)
    COMPILER_FEATURE_ENTRY(202011L, __cpp_lib_stacktrace)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_start_lifetime_as)
    COMPILER_FEATURE_ENTRY(202011L, __cpp_lib_stdatomic_h)
    COMPILER_FEATURE_ENTRY(202011L, __cpp_lib_string_contains)
    COMPILER_FEATURE_ENTRY(202110L, __cpp_lib_string_resize_and_overwrite)
    COMPILER_FEATURE_ENTRY(202102L, __cpp_lib_to_underlying)
    COMPILER_FEATURE_ENTRY(202207L, __cpp_lib_tuple_like)
    COMPILER_FEATURE_ENTRY(202202L, __cpp_lib_unreachable)
};
static constexpr CompilerFeature cxx26_core[] = {
    //< Weiterhin Auffüllen
    COMPILER_FEATURE_ENTRY(202406L, __cpp_constexpr)
    COMPILER_FEATURE_ENTRY(202411L, __cpp_constexpr_exceptions)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_contracts)
    COMPILER_FEATURE_ENTRY(202403L, __cpp_deleted_function)
    COMPILER_FEATURE_ENTRY(202406L, __cpp_fold_expressions)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_pack_indexing)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_placeholder_variables)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_pp_embed)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_static_assert)
    COMPILER_FEATURE_ENTRY(202411L, __cpp_structured_bindings)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_template_parameters)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_trivial_relocatability)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_trivial_union)
    COMPILER_FEATURE_ENTRY(202403L, __cpp_variadic_friend)
};
static constexpr CompilerFeature cxx26_lib[] = {
    //< Weiterhin Auffüllen
    COMPILER_FEATURE_ENTRY(202403L, __cpp_lib_algorithm_default_value_type)
    COMPILER_FEATURE_ENTRY(202411L, __cpp_lib_aligned_accessor)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_associative_heterogeneous_insertion)
    COMPILER_FEATURE_ENTRY(202403L, __cpp_lib_atomic_min_max)
    COMPILER_FEATURE_ENTRY(202411L, __cpp_lib_atomic_ref)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_bind_back)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_bind_front)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_bitset)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_chrono)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_constexpr_algorithms)
    COMPILER_FEATURE_ENTRY(202411L, __cpp_lib_constexpr_atomic)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_constexpr_cmath)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_constexpr_complex)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_constexpr_deque)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_constexpr_exceptions)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_constexpr_flat_map)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_constexpr_flat_set)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_constexpr_forward_list)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_constexpr_inplace_vector)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_constexpr_list)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_constexpr_map)
    COMPILER_FEATURE_ENTRY(202406L, __cpp_lib_constexpr_new)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_constexpr_queue)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_constexpr_set)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_constexpr_stack)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_constexpr_unordered_map)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_constexpr_unordered_set)
    COMPILER_FEATURE_ENTRY(202411L, __cpp_lib_constrained_equality)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_contracts)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_copyable_function)
    COMPILER_FEATURE_ENTRY(202403L, __cpp_lib_debugging)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_format)
    COMPILER_FEATURE_ENTRY(202403L, __cpp_lib_format_path)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_format_uchar)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_freestanding_algorithm)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_freestanding_array)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_freestanding_char_traits)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_freestanding_charconv)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_freestanding_cstdlib)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_freestanding_cstring)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_freestanding_cwchar)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_freestanding_errc)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_freestanding_execution)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_freestanding_expected)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_freestanding_feature_test_macros)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_freestanding_functional)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_freestanding_iterator)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_freestanding_mdspan)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_freestanding_memory)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_freestanding_numeric)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_freestanding_operator_new)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_freestanding_optional)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_freestanding_random)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_freestanding_ranges)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_freestanding_ratio)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_freestanding_string_view)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_freestanding_tuple)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_freestanding_utility)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_freestanding_variant)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_fstream_native_handle)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_function_ref)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_hardened_array)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_hardened_basic_string)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_hardened_basic_string_view)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_hardened_bitset)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_hardened_deque)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_hardened_expected)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_hardened_forward_list)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_hardened_inplace_vector)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_hardened_list)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_hardened_mdspan)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_hardened_optional)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_hardened_span)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_hardened_valarray)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_hardened_vector)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_hazard_pointer)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_hive)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_indirect)
    COMPILER_FEATURE_ENTRY(202406L, __cpp_lib_inplace_vector)
    COMPILER_FEATURE_ENTRY(202411L, __cpp_lib_is_sufficiently_aligned)
    COMPILER_FEATURE_ENTRY(202406L, __cpp_lib_is_virtual_base_of)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_is_within_lifetime)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_linalg)
    COMPILER_FEATURE_ENTRY(202406L, __cpp_lib_mdspan)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_not_fn)
    COMPILER_FEATURE_ENTRY(202406L, __cpp_lib_optional_range_support)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_out_ptr)
    COMPILER_FEATURE_ENTRY(202406L, __cpp_lib_philox_engine)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_polymorphic)
    COMPILER_FEATURE_ENTRY(202403L, __cpp_lib_print)
    COMPILER_FEATURE_ENTRY(202406L, __cpp_lib_ranges)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_ranges_as_const)
    COMPILER_FEATURE_ENTRY(202411L, __cpp_lib_ranges_cache_latest)
    COMPILER_FEATURE_ENTRY(202403L, __cpp_lib_ranges_concat)
    COMPILER_FEATURE_ENTRY(202403L, __cpp_lib_ranges_generate_random)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_ranges_reserve_hint)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_ranges_to_input)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_ratio)
    COMPILER_FEATURE_ENTRY(202411L, __cpp_lib_raw_memory_algorithms)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_rcu)
    COMPILER_FEATURE_ENTRY(202403L, __cpp_lib_reference_wrapper)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_saturation_arithmetic)
    COMPILER_FEATURE_ENTRY(202406L, __cpp_lib_senders)
    COMPILER_FEATURE_ENTRY(202411L, __cpp_lib_simd)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_simd_complex)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_smart_ptr_owner_equality)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_span)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_span_initializer_list)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_sstream_from_string_view)
    COMPILER_FEATURE_ENTRY(202403L, __cpp_lib_string_view)
    COMPILER_FEATURE_ENTRY(202403L, __cpp_lib_submdspan)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_text_encoding)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_to_chars)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_to_string)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_trivially_relocatable)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_tuple_like)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_variant)
};
static constexpr CompilerFeature cxx29_core[] = {
    //< Weiterhin Auffüllen
    COMPILER_FEATURE_ENTRY(202604L, __cpp_core_TODO)
};
static constexpr CompilerFeature cxx29_lib[] = {
    //< Weiterhin Auffüllen
    COMPILER_FEATURE_ENTRY(202604L, __cpp_lib_TODO)
};
static constexpr CompilerFeature attributes[] = {
    COMPILER_ATTRIBUTE(202207L, assume)
    COMPILER_ATTRIBUTE(200809L, carries_dependency)
    COMPILER_ATTRIBUTE(201309L, deprecated)
    COMPILER_ATTRIBUTE(201603L, fallthrough)
    COMPILER_ATTRIBUTE(202403L, indeterminate)
    COMPILER_ATTRIBUTE(201803L, likely)
    COMPILER_ATTRIBUTE(201603L, maybe_unused)
    COMPILER_ATTRIBUTE(201803L, no_unique_address)
    COMPILER_ATTRIBUTE(201907L, nodiscard)
    COMPILER_ATTRIBUTE(200809L, noreturn)
    COMPILER_ATTRIBUTE(201803L, unlikely)
};
inline void show_compiler_specific_info()
{
    std::printf("ANDERE MAKROS:\n");
    for (auto co : compiler)
        if (std::strcmp(co.first, co.second))
            std::printf("%*s %s\n", -print.longest_macro_name, co.first, co.second);
}
inline void print_compiler_feature(const CompilerFeature& x)
{
    if (not ((print.supported_features and x.vielleicht()) or
            (print.unsupported_features and not x.vielleicht())))
        return;
    auto print_year_month = [](long n)
    {
        return std::printf("%ld%s%02ld",
            n / 100, print.separate_year_month ? "-" : "", n % 100);
    };
    std::printf("%*s ", -print.longest_macro_name, x.name());
    x.vielleicht() ? print_year_month(x.data()) :
                    std::printf("------%s", print.separate_year_month ? "-" : "");
    if (print.standard_values)
        std::printf("  %c  ", (x.supported() ? (x.data() > x.std() ? '>' : '=') : '<')),
            print_year_month(x.std());
    std::puts("");
}
template<class Container>
inline void show(char const* const title, Container const& co)
{
    if (print.Titel)
    {
        std::printf("%-s (", title);
        if (print.counters)
        {
            std::printf("%zd/", std::count_if(std::begin(co), std::end(co),
                [](CompilerFeature x)
                {
                    return x.supported();
                }));
        }
        std::printf("%td)\n", std::distance(std::begin(co), std::end(co)));
    }
    if (print.sort_by_date)
    {
        std::vector<CompilerFeature> v(std::begin(co), std::end(co));
        std::stable_sort(v.begin(), v.end(),
            [](CompilerFeature const& lhs, CompilerFeature const& rhs)
            {
                return lhs.data() < rhs.data();
            });
        std::for_each(v.cbegin(), v.cend(), print_compiler_feature);
    }
    else
        std::for_each(std::begin(co), std::end(co), print_compiler_feature);
    std::puts("");
}
inline void show_latest()
{
    auto latest_rev = []() -> int
    {
        return print.cxx29 ? 29 : print.cxx26 ? 26 : print.cxx23 ? 23 : print.cxx20 ? 20 :
               print.cxx17 ? 17 : print.cxx14 ? 14 : print.cxx11 ? 11 : 98;
    };
    std::vector<CompilerFeature> latest;
    auto add = [&latest](CompilerFeature x)
    {
        auto i = std::lower_bound(latest.begin(), latest.end(), x);
        if (i == latest.end() or not (*i == x))
            latest.insert(i, x);
        else if (i->data() < x.data())
            i->data(x.data());
    };
    char text[64];
    latest.reserve(512); // max-Makros
    if (print.core_features)
    {   // Erhalte die umgekehrte Revisions-Einfügereihenfolge!
        if (print.cxx29) std::for_each(std::begin(cxx29_core), std::end(cxx29_core), add);
        if (print.cxx26) std::for_each(std::begin(cxx26_core), std::end(cxx26_core), add);
        if (print.cxx23) std::for_each(std::begin(cxx23_core), std::end(cxx23_core), add);
        if (print.cxx20) std::for_each(std::begin(cxx20_core), std::end(cxx20_core), add);
        if (print.cxx17) std::for_each(std::begin(cxx17_core), std::end(cxx17_core), add);
        if (print.cxx14) std::for_each(std::begin(cxx14_core), std::end(cxx14_core), add);
        if (print.cxx11) std::for_each(std::begin(cxx11_core), std::end(cxx11_core), add);
        if (print.cxx98) std::for_each(std::begin(cxx98_core), std::end(cxx98_core), add);
        std::snprintf(text, sizeof text, "ALLE KERN-MAKROS BIS C++%02i", latest_rev());
        show(text, latest);
    }
    latest.clear();
    if (print.lib_features)
    {   // Erhalte die umgekehrte Revisions-Einfügereihenfolge!
        if (print.cxx29) std::for_each(std::begin(cxx29_lib), std::end(cxx29_lib), add);
        if (print.cxx26) std::for_each(std::begin(cxx26_lib), std::end(cxx26_lib), add);
        if (print.cxx23) std::for_each(std::begin(cxx23_lib), std::end(cxx23_lib), add);
        if (print.cxx20) std::for_each(std::begin(cxx20_lib), std::end(cxx20_lib), add);
        if (print.cxx17) std::for_each(std::begin(cxx17_lib), std::end(cxx17_lib), add);
        if (print.cxx14) std::for_each(std::begin(cxx14_lib), std::end(cxx14_lib), add);
        std::snprintf(text, sizeof text, "ALLE LIB-MAKROS BIS C++%02i", latest_rev());
        show(text, latest);
    }
}
int main()
{
    if (print.getrennte_Revisionen)
    {
        if (print.cxx98 and print.core_features) show("C++98 CORE", cxx98_core);
        if (print.cxx11 and print.core_features) show("C++11 CORE", cxx11_core);
        if (print.cxx14 and print.core_features) show("C++14 CORE", cxx14_core);
        if (print.cxx14 and print.lib_features ) show("C++14 LIB" , cxx14_lib);
        if (print.cxx17 and print.core_features) show("C++17 CORE", cxx17_core);
        if (print.cxx17 and print.lib_features ) show("C++17 BIBLIOTHEK" , cxx17_lib);
        if (print.cxx20 and print.core_features) show("C++20 CORE", cxx20_core);
        if (print.cxx20 and print.lib_features ) show("C++20 BIBLIOTHEK" , cxx20_lib);
        if (print.cxx23 and print.core_features) show("C++23 CORE", cxx23_core);
        if (print.cxx23 and print.lib_features ) show("C++23 LIB" , cxx23_lib);
        if (print.cxx26 and print.core_features) show("C++26 CORE", cxx26_core);
        if (print.cxx26 and print.lib_features ) show("C++26 LIB" , cxx26_lib);
        if (print.cxx29 and print.core_features) show("C++29 CORE", cxx29_core);
        if (print.cxx29 and print.lib_features ) show("C++29 LIB" , cxx29_lib);
    }
    if (print.latest_revisions) show_latest();
    if (print.attributes) show("ATTRIBUTE", attributes);
    if (print.compiler_specific) show_compiler_specific_info();
}

Mögliche Ausgabe: 

C++11 KERN (20/20)
__cpp_alias_templates                         2007-04  =  2007-04
__cpp_attributes                              2008-09  =  2008-09
__cpp_constexpr                               2022-11  >  2007-04
__cpp_constexpr_in_decltype                   2017-11  =  2017-11
... gekürzt ...
C++14 KERN (9/9)
__cpp_aggregate_nsdmi                         2013-04  =  2013-04
__cpp_binary_literals                         2013-04  =  2013-04
__cpp_constexpr                               2022-11  >  2013-04
... gekürzt ...
C++14 BIBLIOTHEK (20/20)
__cpp_lib_chrono_udls                         2013-04  =  2013-04
__cpp_lib_complex_udls                        2013-09  =  2013-09
__cpp_lib_exchange_function                   2013-04  =  2013-04
... gekürzt ...
... gekürzt ...
C++23 BIBLIOTHEK (43/64)
__cpp_lib_adaptor_iterator_pair_constructor   2021-06  =  2021-06
__cpp_lib_algorithm_iterator_requirements     -------  <  2022-07
__cpp_lib_allocate_at_least                   -------  <  2023-02
__cpp_lib_associative_heterogeneous_erasure   -------  <  2021-10
__cpp_lib_barrier                             2019-07  <  2023-02
... gekürzt ...
ALLE KERN-MAKROS BIS C++26 (60/76)
__cpp_aggregate_bases                         2016-03  =  2016-03
__cpp_aggregate_nsdmi                         2013-04  =  2013-04
__cpp_aggregate_paren_init                    2019-02  =  2019-02
__cpp_alias_templates                         2007-04  =  2007-04
... gekürzt ...
ALLE BIBLIOTHEKS-MAKROS BIS C++26 (158/282)
__cpp_lib_adaptor_iterator_pair_constructor   2021-06  =  2021-06
__cpp_lib_addressof_constexpr                 2016-03  =  2016-03
__cpp_lib_algorithm_iterator_requirements     -------  <  2022-07
__cpp_lib_allocate_at_least                   -------  <  2023-02
__cpp_lib_allocator_traits_is_always_equal    2014-11  =  2014-11
... gekürzt ...
ATTRIBUTE (9/11)
assume                                        2022-07  =  2022-07
carries_dependency                            -------  <  2008-09
deprecated                                    2013-09  =  2013-09
fallthrough                                   2016-03  =  2016-03
... gekürzt ...
ANDERE MAKROS:
__cplusplus                                   202302L
__GNUG__                                      14
__GNUC_MINOR__                                2
__GNUC_PATCHLEVEL__                           0
__STDCPP_FLOAT16_T__                          1
__STDCPP_FLOAT32_T__                          1
... gekürzt ...

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
P2552R3 C++20 __has_cpp_attribute muss für Standardattribute auf einen Wert ungleich Null expandieren kann auf ​ 0 ​ expandieren

Siehe auch

Bibliothek-Feature-Test-Makros (C++20) definiert im Header <version>
Vordefinierte Makro-Symbole
Makro-Symbol-Index

Externe Links

1. Das offizielle Dokument zu Feature-Test-Empfehlungen
2. Quellcode zum Ausgeben von Compiler-Features