Feature-Tests (seit C++20)

 

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

 

Feature-Tests

 

Der Standard definiert eine Reihe von Präprozessor-Makros, die C++-Sprach- und Bibliotheksfeatures entsprechen, die in C++11 oder später eingeführt wurden. Sie sind als einfache und portable Möglichkeit gedacht, die Anwesenheit dieser Features zu erkennen.

Attribute

__has_cpp_attribute( attribut-token )

Prüft auf die Unterstützung eines durch attribut-token (nach Makroexpansion) benannten Attributs.

Für jedes Standardattribut ist es implementierungsabhängig, ob __has_cpp_attribute zu dem unten in der Tabelle angegebenen Wert (dem Jahr und Monat, in dem das Attribut zum Arbeitsentwurf hinzugefügt wurde) oder zu ​0​ expandiert. Es expandiert nur dann zu dem in der Tabelle angegebenen Wert, wenn das Standardattribut die Implementierung dazu veranlasst, sich wie empfohlen zu verhalten (Diagnosemeldungen auszugeben, das Klassenschema zu beeinflussen usw.).

Die Anwesenheit herstellerspezifischer Attribute wird durch einen von Null verschiedenen Wert bestimmt.

__has_cpp_attribute kann im Ausdruck von #if und #elif expandiert werden. Es wird von #ifdef, #ifndef, #elifdef, #elifndef(seit C++23) und defined als definiertes Makro behandelt, kann aber nirgendwo sonst verwendet werden.

attribut-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 Begründung	201907L	(C++20)	P1301R4
noreturn	[[noreturn]]	200809L	(C++11)	N2761
unlikely	[[unlikely]]	201803L	(C++20)	P0479R5
Gesamtzahl der Attribute: 11

Sprachfeatures

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

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

Makroname	Feature	Wert	Std	Papier(e)
__cpp_aggregate_bases	Aggregatklassen mit Basisklassen	201603L	(C++17)	P0017R1
__cpp_aggregate_nsdmi	Aggregatklassen mit Standard-Member-Initialisierern	201304L	(C++14)	N3653
__cpp_aggregate_paren_init	Aggregatinitialisierung in Form der direkten Initialisierung	201902L	(C++20)	P0960R3
__cpp_alias_templates	Alias-Templates	200704L	(C++11)	N2258
__cpp_aligned_new	Dynamische Speicherzuweisung für übermäßig ausgerichtete 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	Lambda-Erfassung von *this per Wert als [=,*this]	201603L	(C++17)	P0018R3
__cpp_char8_t	char8_t	201811L	(C++20)	P0482R6
	char8_t Kompatibilität und Portabilitätskorrektur (Zulassung der Initialisierung von (unsigned) char-Arrays aus UTF-8-Zeichenkettenliteralen)	202207L	(C++23) (DR20)	P2513R4
__cpp_concepts	Konzepte	201907L	(C++20)	P0734R0 P1084R2 P1452R2
	Bedingte triviale spezielle Memberfunktionen	202002L		P0848R3 P2493R0
__cpp_conditional_explicit	explicit(bool)	201806L	(C++20)	P0892R2
__cpp_consteval	Sofortfunktionen	201811L	(C++20)	P1073R3
	Weitergabe von consteval nach oben	202211L	(C++23) (DR20)	P2564R3
__cpp_constexpr	constexpr	200704L	(C++11)	N2235
	Entspannte 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-Deklarationen in constexpr-Funktionen	201907L	(C++20)	P1064R0 P1002R1 P1327R1 P1331R2 P1668R1
	Änderung des aktiven Mitglieds einer Union in konstanter Auswertung	202002L		P1330R0 P2493R0
	Nicht-Literaltypen-Variablen, Sprungmarken und goto-Anweisungen in constexpr-Funktionen	202110L	(C++23)	P2242R3
	Lockerung einiger Beschränkungen für constexpr-Funktionen und Funktionstemplates	202207L		P2448R2
	Zulassung von statischen constexpr-Variablen in constexpr-Funktionen	202211L		P2647R1
	Constexpr-Cast von void*: Richtung constexpr Type-Erasure	202306L	(C++26)	P2738R1
	constexpr Placement new	202406L		P2747R2
__cpp_constexpr_dynamic_alloc	Operationen für dynamische Speicherverwaltung in constexpr-Funktionen	201907L	(C++20)	P0784R7
__cpp_constexpr_exceptions	constexpr Ausnahmen	202411L	(C++26)	P3068R6
__cpp_constexpr_in_decltype	Generierung von Funktions- und Variablendefinitionen, wenn für die 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("sollte einen Grund haben");)	202403L	(C++26)	P2573R2
__cpp_designated_initializers	Bezeichner-Initialisierer	201707L	(C++20)	P0329R4
__cpp_enumerator_attributes	Attribute für Aufzählungswerte	201411L	(C++17)	N4266
__cpp_explicit_this_parameter	Expliziter Objektparameter	202110L	(C++23)	P0847R7
__cpp_fold_expressions	Falt-Ausdrücke	201603L	(C++17)	N4295 P0036R0
	Reihenfolge von Bedingungen, die Falt-Ausdrücke beinhalten	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 Kopierelision durch vereinfachte Wertkategorien	201606L	(C++17)	P0135R1
__cpp_hex_float	Hexadezimale Gleitkommazahlenliterale	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örendes operator delete (Compiler-Unterstützung)	201806L	(C++20)	P0722R3
__cpp_impl_three_way_comparison	Drei-Wege-Vergleich (Compiler-Unterstützung)	201907L	(C++20)	P0515R3 P0768R1 P1185R2 P1630R1
__cpp_implicit_move	Einfacheres implizites Verschieben	202207L	(C++23)	P2266R3
__cpp_inheriting_constructors	Erbende Konstruktoren	200802L	(C++11)	N2540
	Umschreibung erbender Konstruktoren: Neue Spezifikation für erbende Konstruktoren (DR1941 et al)	201511L	(C++17) (DR11)	P0136R1
__cpp_init_captures	Lambda-Init-Capture	201304L	(C++14)	N3648
	Paketexpansion in der Lambda-Init-Capture zulassen	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	Mehrdimensionierter Subscript-Operator	202110L	(C++23)	P2128R6
	Statisches operator[]	202211L		P2589R1
__cpp_named_character_escapes	Benannte universelle Zeichen-Escapes	202207L	(C++23)	P2071R2
__cpp_namespace_attributes	Attribute für Namensräume	201411L	(C++17)	N4266
__cpp_noexcept_function_type	Ausnahmespezifikationen als Teil des Typsystems machen	201510L	(C++17)	P0012R1
__cpp_nontype_template_args	Konstante Auswertung für alle Nicht-Typ-Template-Argumente zulassen	201411L	(C++17)	N4268
	Klassentypen und Gleitkommatypen in Nicht-Typ-Template-Parametern	201911L	(C++20)	P1907R1
__cpp_nontype_template_parameter_auto	Deklaration eines Nicht-Typ-Template-Parameters mit auto	201606L	(C++17)	P0127R2
__cpp_nsdmi	Nicht-statische Member-Initialisierer	200809L	(C++11)	N2756
__cpp_pack_indexing	Paketindizierung	202311L	(C++26)	P2662R3
__cpp_placeholder_variables	Ein schönes 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-Schleifen	202211L	(C++23)	P2644R1 P2718R0 CWG2659
__cpp_raw_strings	Rohe Zeichenkettenliterale	200710L	(C++11)	N2442
__cpp_ref_qualifiers	Referenz-Qualifizierer	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	Literal-Suffixe für std::size_t und seine vorzeichenbehaftete Version	202011L	(C++23)	P0330R8
__cpp_sized_deallocation	Größenabhängige Deallokation	201309L	(C++14)	N3778
__cpp_static_assert	static_assert	200410L	(C++11)	N1720
	static_assert mit einem Argument	201411L	(C++17)	N3928
	Vom Benutzer generierte static_assert-Nachrichten	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 als Bedingung in Deklarationen einführen	202406L		P0963R3
	Strukturierte Bindungen können ein Paket einführen	202411L		P1061R10
__cpp_template_parameters	Konzepte und Variablentemplate-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 Zerstörung mit Nebenläufigkeit	200806L	(C++11)	N2660
__cpp_trivial_relocatability	Triviale Verlagerbarkeit	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-String-Literale	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	Variablentemplates	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	Paketexpansion in using-Deklarationen	201611L	(C++17)	P0195R2
Gesamtzahl der Makros: 76

Bibliotheksfeatures

Die folgenden Makros können verwendet werden, um zu erkennen, ob ein Standardbibliotheksfeature von der aktuellen Implementierung unterstützt wird. Im Gegensatz zu den Sprachfeature-Testmakros sind sie nicht vordefiniert. Stattdessen werden sie vom Header <version> bereitgestellt.

Für jedes Bibliotheksfeature-Testmakro wird es auch von den Headern bereitgestellt, die die entsprechenden Standardbibliothekskomponenten enthalten. Eine vollständige Liste der Header, die diese Makros bereitstellen, finden Sie unter Bibliotheksfeature-Testmakros.

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

Makroname	Feature	Wert	Std	Papier(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	Constexpr std::addressof	201603L	(C++17)	LWG2296
__cpp_lib_algorithm_default_value_type	Aktivierung von 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 Pointer-Über-Ausrichtung ausdrückt	202411L	(C++26)	P2897R7
__cpp_lib_allocate_at_least	Größenrückmeldung in der Allocator-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 usw.)	201811L	(C++20)	P0858R0 LWG3257 P1023R0 P1032R1
__cpp_lib_as_const	std::as_const	201510L	(C++17)	P0007R1
__cpp_lib_associative_heterogeneous_erasure	Heterogene Löschung 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	Atomare Gleitkommazahlen	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 lock-free ganzzahlige Typen (std::atomic_signed_lock_free, std::atomic_unsigned_lock_free)	201907L	(C++20)	P1135R6
__cpp_lib_atomic_min_max	Atomares Minimum/Maximum (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	Korrektur der atomaren Initialisierung (standardmäßig Werteinitialisierung von std::atomic)	201911L	(C++20)	P0883R2
__cpp_lib_atomic_wait	Effizientes Warten auf std::atomic	201907L	(C++20)	P1135R6
__cpp_lib_barrier	std::barrier	201907L	(C++20)	P1135R6
	std::barrier's Garantien für Phasenabschluss	202302L	(C++23)	P2588R3
__cpp_lib_bind_back	std::bind_back	202202L	(C++23)	P2387R3
	Zulassung der Übergabe von aufrufbaren Objekten als Nicht-Typ-Template-Argumente an std::bind_back	202306L	(C++26)	P2714R1
__cpp_lib_bind_front	std::bind_front	201907L	(C++20)	P0356R5 P1651R0
	Zulassung der Übergabe von aufrufbaren Objekten als Nicht-Typ-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	Schnittstelle 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	Sucher	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
	Hashing-Unterstützung für std::chrono-Wertklassen	202306L	(C++26)	P2592R3
__cpp_lib_chrono_udls	Benutzerdefinierte Literale für Zeit-Typen	201304L	(C++14)	N3642
__cpp_lib_clamp	std::clamp	201603L	(C++17)	P0025R1
__cpp_lib_common_reference	std::common_reference_t von std::reference_wrapper zu einem Referenztyp machen	202302L	(C++23)	P2655R3
__cpp_lib_common_reference_wrapper	std::common_reference_t von std::reference_wrapper zu einem Referenztyp machen	202302L	(C++23)	P2655R3
__cpp_lib_complex_udls	Benutzerdefinierte Literale für std::complex	201309L	(C++14)	N3779
__cpp_lib_concepts	Standardbibliothekskonzepte	202002L	(C++20)	P0898R3 P1754R1 P1964R2
	Nur-verschieb-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 noch mehr constexpres std::bitset	202207L	(C++23)	P2417R2
__cpp_lib_constexpr_charconv	Constexpr für std::to_chars und std::from_chars für ganzzahlige Typen	202207L	(C++23)	P2291R3
__cpp_lib_constexpr_cmath	Constexpr 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_containers	Mehr constexpr Container und Adaptoren	202502L	(C++26)	P3372R2
__cpp_lib_constexpr_dynamic_alloc	Constexpr für std::allocator und verwandte Dienstprogramme	201907L	(C++20)	P0784R7
__cpp_lib_constexpr_exceptions	constexpr für Ausnahmetypen, z.B. std::bad_alloc, std::bad_cast etc.	202411L	(C++26)	P3068R6
	Mehr constexpr für Ausnahmetypen	202502L		P3378R2
__cpp_lib_constexpr_functional	Diverse constexpr Bits (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	Diverse constexpr Bits (std::insert_iterator usw.)	201811L	(C++20)	P1032R1
__cpp_lib_constexpr_memory	Constexpr in std::pointer_traits	201811L	(C++20)	P1006R1
	Constexpr std::unique_ptr	202202L	(C++23)	P2273R3
__cpp_lib_constexpr_new	Constexpr Placement new	202406L	(C++26)	P2747R2
__cpp_lib_constexpr_numeric	Constexpr für Algorithmen in <numeric>	201911L	(C++20)	P1645R1
__cpp_lib_constexpr_string	constexpr std::char_traits	201611L	(C++17)	P0426R1
	constexpr std::string	201907L	(C++20)	P0980R1
__cpp_lib_constexpr_string_view	Diverse constexpr Bits (std::string_view::copy)	201811L	(C++20)	P1032R1
__cpp_lib_constexpr_tuple	Diverse constexpr Bits (std::tuple::operator= usw.)	201811L	(C++20)	P1032R1
__cpp_lib_constexpr_typeinfo	Constexpr für std::type_info::operator==	202106L	(C++23)	P1328R1
__cpp_lib_constexpr_utility	Diverse constexpr Bits (std::pair::operator= usw.)	201811L	(C++20)	P1032R1
__cpp_lib_constexpr_vector	Constexpr für std::vector	201907L	(C++20)	P1004R2
__cpp_lib_constrained_equality	Beschränkte relationale Operatoren für std::pair, std::tuple, std::optional und std::variant	202403L	(C++26)	P2944R3
	Beschränkung der Gleichheitsoperatoren von std::expected	202411L		P3379R0
__cpp_lib_containers_ranges	Ranges-fähige Konstruktion und Einfügung für Container und Strings	202202L	(C++23)	P1206R7
__cpp_lib_contracts	<contracts>: Contracts-Unterstü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
	Ersetzbares std::is_debugger_present	202403L		P2810R4
__cpp_lib_destroying_delete	Zerstörendes 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 Containerlö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-Zeit-Prüfung von Format-Strings; Reduzierung der Parametrisierung von std::vformat_to	202106L	(C++23) (DR20)	P2216R3
	Behebung der Locale-Behandlung bei Chrono-Formatierern; Unterstützung von nicht-konstant-formatierbaren Typen	202110L		P2372R3 P2418R2
	Offenlegung von std::basic_format_string; Klärung der Handhabung von Encodings bei lokalisierter Formatierung von Chrono-Typen	202207L	(C++23)	P2419R2 P2508R1
	Formatierung von Zeigern	202304L	(C++26)	P2510R3
	Typ-Prüfung von Format-Argumenten	202305L		P2757R3
	Member visit	202306L		P2637R3
	Laufzeit-Format-Strings	202311L		P2918R2
__cpp_lib_format_path	Formatierung von std::filesystem::path	202403L	(C++26)	P2845R8
__cpp_lib_format_ranges	Formatierung von Bereichen (Ranges)	202207L	(C++23)	P2286R8 P2585R1 LWG3750
__cpp_lib_format_uchar	Korrektur der Formatierung von Code-Einheiten 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	Freistehende Einrichtungen in <algorithm>	202311L	(C++26)	P2407R5
__cpp_lib_freestanding_array	Machen Sie Teile von std::array "freestanding"	202311L	(C++26)	P2407R5
__cpp_lib_freestanding_char_traits	Freestanding std::char_traits	202306L	(C++26)	P2338R4
__cpp_lib_freestanding_charconv	Freestanding-Funktionen in <charconv>	202306L	(C++26)	P2338R4
__cpp_lib_freestanding_cstdlib	Freestanding-Funktionen in <cstdlib>	202306L	(C++26)	P2338R4
__cpp_lib_freestanding_cstring	Freestanding-Funktionen in <cstring>	202306L	(C++26)	P2338R4
	Entfernen von std::strtok aus Freestanding-Funktionen	202311L		P2937R0
__cpp_lib_freestanding_cwchar	Freestanding-Funktionen in <cwchar>	202306L	(C++26)	P2338R4
__cpp_lib_freestanding_errc	Freestanding std::errc	202306L	(C++26)	P2338R4
__cpp_lib_freestanding_expected	Machen Sie Teile von std::expected "freestanding"	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	Freestanding-Funktionen in <functional>	202306L	(C++26)	P2198R7
__cpp_lib_freestanding_iterator	Freestanding-Funktionen in <iterator>	202306L	(C++26)	P2198R7
__cpp_lib_freestanding_mdspan	Freestanding std::mdspan	202311L	(C++26)	P2833R2
__cpp_lib_freestanding_memory	Freestanding-Funktionen in <memory>	202306L	(C++26)	P2198R7
__cpp_lib_freestanding_numeric	Freestanding-Funktionen in <numeric> (Sättigungsarithmetik)	202311L	(C++26)	P0543R3
__cpp_lib_freestanding_operator_new	Definition von operator new (optional in "freestanding" Implementierungen)	202306L	(C++26)	P2198R7
__cpp_lib_freestanding_optional	Machen Sie Teile von std::optional "freestanding"	202311L	(C++26)	P2407R5
__cpp_lib_freestanding_ranges	Freestanding-Funktionen in <ranges>	202306L	(C++26)	P2198R7
__cpp_lib_freestanding_ratio	Freestanding-Funktionen in <ratio>	202306L	(C++26)	P2198R7
__cpp_lib_freestanding_string_view	Machen Sie Teile von std::string_view "freestanding"	202311L	(C++26)	P2407R5
__cpp_lib_freestanding_tuple	Freestanding-Funktionen in <tuple>	202306L	(C++26)	P2198R7
__cpp_lib_freestanding_utility	Freestanding-Funktionen in <utility>	202306L	(C++26)	P2198R7
__cpp_lib_freestanding_variant	Machen Sie Teile von std::variant "freestanding"	202311L	(C++26)	P2407R5
__cpp_lib_fstream_native_handle	Ermittlung nativer Handles von Dateiströmen	202306L	(C++26)	P1759R6
__cpp_lib_function_ref	std::function_ref: Ein typ-erased callable Referenz	202306L	(C++26)	P0792R14
__cpp_lib_gcd_lcm	std::gcd, std::lcm	201606L	(C++17)	P0295R0
__cpp_lib_generator	std::generator: Synchroner Coroutine-Generator für Ranges	202207L	(C++23)	P2502R2
__cpp_lib_generic_associative_lookup	Heterogene Vergleiche in assoziativen Containern	201304L	(C++14)	N3657
__cpp_lib_generic_unordered_lookup	Heterogene Vergleiche in ungeordneten assoziativen Containern	201811L	(C++20)	P0919R3
__cpp_lib_hardware_interference_size	Constexpr std::hardware_{constructive, destructive}_interference_size	201703L	(C++17)	P0154R1
__cpp_lib_hive	<hive>: Ein bucket-basierter Container, der Speicherorte von gelöschten Elementen 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 größenveränderbarer Vektor mit fester Kapazität (Inplace-Speicherung)	202406L	(C++26)	P0843R14
__cpp_lib_int_pow2	Ganzzahlige Potenz-von-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	Ganzzahl-Vergleichsfunktionen	202002L	(C++20)	P0586R2
__cpp_lib_integer_sequence	Ganzzahlsequenzen zur Compilezeit	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 für 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	Pointer-Interkonvertierbarkeits-Traits: 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 Alignment-Vorbedingung eines Zeigers	202411L	(C++26)	P2897R7
__cpp_lib_is_swappable	(nothrow-)swappable Traits	201603L	(C++17)	P0185R1
__cpp_lib_is_virtual_base_of	std::is_virtual_base_of: Type-Trait zur Erkennung virtueller Basisklassen	202406L	(C++26)	P2985R0
__cpp_lib_is_within_lifetime	Prüfen, ob eine Union-Alternative aktiv ist (std::is_within_lifetime)	202306L	(C++26)	P2641R4
__cpp_lib_jthread	Stop-Token und joining 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 BLAS	202311L	(C++26)	P1673R13
__cpp_lib_list_remove_return_type	Ändern des Rückgabetyps von remove(), remove_if() und unique() von std::forward_list und std::list	201806L	(C++20)	P0646R1
__cpp_lib_logical_traits	Logische Operationen auf Typ-Traits	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	Standardbibliotheksmodule std und std.compat	202207L	(C++23)	P2465R3
__cpp_lib_move_iterator_concept	Machen Sie std::move_iterator<T*> zu einem Random-Access-Iterator	202207L	(C++23)	P2520R0
__cpp_lib_move_only_function	std::move_only_function	202110L	(C++23)	P0288R9
__cpp_lib_node_extract	Splicing 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
	Erlauben Sie die Übergabe von aufrufbaren Objekten als Nicht-Typ-Template-Argumente an std::not_fn	202306L	(C++26)	P2714R1
__cpp_lib_null_iterators	Null LegacyForwardIterator	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 Range-Unterstü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 Vokabulartyp	201902L	(C++20)	P0339R6 LWG3437
__cpp_lib_print	Formatierte Ausgabe	202207L	(C++23)	P2093R14
	Erlauben einer effizienten 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 Zufallszahl-Engine	202406L	(C++26)	P2075R6
__cpp_lib_ranges	Ranges-Bibliothek und eingeschränkte Algorithmen	201911L	(C++20)	P0896R4 P1035R7 P1716R3
	Nicht standardmäßig initialisierbare Views	202106L	(C++23) (DR20)	P2325R3
	Views mit Besitz	202110L		P2415R2
	std::ranges::range_adaptor_closure	202202L	(C++23)	P2387R3
	Lockerung von Range-Adaptoren, um move-only Typen zuzulassen	202207L		P2494R2
	Entfernen von "poison pill"-Überladungen in ranges::begin, ranges::end, ranges::rbegin, ranges::rend und ranges::size	202211L		P2602R2
	Lockerung von Ranges, um bestimmte Projektionen zuzulassen	202302L		P2609R3
	Entfernen der gemeinsamen Referenzanforderung aus 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
	Machen Sie std::basic_const_iterator konvertierbar entsprechend seines zugrundeliegenden Typs	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 von Werkzeugen zur Speicherverwaltung	201606L	(C++17)	P0040R3
	Constexpr für spezialisierte Speicher-Algorithmen	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	Robustere nicht-modifizierende Sequenzoperationen (Zwei-Range-Ü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-Receiver-Modell der Ausführungskontrolle	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
__cpp_lib_smart_ptr_for_overwrite	Erstellung von Smart Pointern 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 Quellcodeinformationen (std::source_location)	201907L	(C++20)	P1208R6
__cpp_lib_span	std::span	202002L	(C++20)	P0122R7 LWG3274 P1024R3 P1976R2
	Machen Sie Teile von std::span "freestanding"	202311L	(C++26)	P2821R5 P2833R2
__cpp_lib_span_initializer_list	Konstruktion von 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 unsigniertes std::span::size	201902L	(C++20)	P1227R2
__cpp_lib_sstream_from_string_view	Schnittstellen 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	Explizites Lebensdauer-Management (std::start_lifetime_as)	202207L	(C++23)	P2590R2
__cpp_lib_starts_ends_with	String-Präfix- und Suffixprü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-atomare Operationen	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 und std::string_view	202403L	(C++26)	P2591R5
__cpp_lib_submdspan	std::submdspan	202306L	(C++26)	P2630R4
	Gepufferte 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	Drei-Wege-Vergleich (Bibliotheksunterstützung); Hinzufügen des Drei-Wege-Vergleichs zur Bibliothek	201907L	(C++20)	P0768R1 P1614R2
__cpp_lib_to_address	Dienstprogramm zur Konvertierung eines Zeigers in einen rohen Zeiger (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 des Erfolgs oder Misserfolgs 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-Templates für Transformations-Traits	201304L	(C++14)	N3655
__cpp_lib_transparent_operators	Transparente Operator-Funktoren (std::less<> et al)	201210L	(C++14)	N3421
	Transparente std::owner_less (std::owner_less<void>)	201510L	(C++17)	P0074R0
__cpp_lib_trivially_relocatable	Traits und Operationen für triviale Verlagerbarkeit	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
	Hinzufügen des Tuple-Protokolls zu std::complex	202311L	(C++26)	P2819R2
__cpp_lib_tuples_by_type	Adressierung von Tupeln nach Typ	201304L	(C++14)	N3670
__cpp_lib_type_identity	std::type_identity	201806L	(C++20)	P0887R1
__cpp_lib_type_trait_variable_templates	Variablentemplates für Typ-Traits (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 von std::variant abgeleitete Klassen	202102L	(C++23) (DR17)	P2162R2
	Vollständig constexpr std::variant	202106L	(C++23) (DR20)	P2231R1
	Mitglied visit	202306L	(C++26)	P2637R3
__cpp_lib_void_t	std::void_t	201411L	(C++17)	N3911
Gesamtzahl der Makros: 255

Beispiel

Normale Verwendung

Führen Sie diesen Code aus

#ifdef __has_include                           // Check if __has_include is present
#  if __has_include(<optional>)                // Check for a standard library
#    include <optional>
#  elif __has_include(<experimental/optional>) // Check for an experimental version
#    include <experimental/optional>
#  elif __has_include(<boost/optional.hpp>)    // Try with an external library
#    include <boost/optional.hpp>
#  else                                        // Not found at all
#     error "Missing <optional>"
#  endif
#endif
 
#ifdef __has_cpp_attribute                      // Check if __has_cpp_attribute is present
#  if __has_cpp_attribute(deprecated)           // Check for an attribute
#    define DEPRECATED(msg) [[deprecated(msg)]]
#  endif
#endif
#ifndef DEPRECATED
#    define DEPRECATED(msg)
#endif
 
DEPRECATED("foo() has been deprecated") void foo();
 
#if __cpp_constexpr >= 201304                // Check for a specific version of a feature
#  define CONSTEXPR constexpr
#else
#  define CONSTEXPR inline
#endif
 
CONSTEXPR int bar(unsigned i)
{
#if __cpp_binary_literals                    // Check for the presence of a feature
    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 Features Dump

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.

Führen Sie diesen Code aus

static constexpr struct change_these_options_to_select_what_will_be_printed
{
    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 or better is required"
#endif
 
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <utility>
#include <vector>
 
#ifdef __has_include
# if __has_include(<version>)
#   include <version>
# endif
#endif
 
// Expect a string that starts with 6-decimal-digits or with '_' (if unsupported)
#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; }
};
 
static /*constexpr*/ std::pair<const char*, const char*> compiler[] = {
    COMPILER_SPECIFIC_ENTRY(__cplusplus) //< not compiler specific, but useful :)
    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__)
    // Add your favorite compiler specific macros. Undefined ones will not be printed.
};
 
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[] = {
    //< Continue to Populate
    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[] = {
    //< Continue to Populate
    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_containers)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_constexpr_exceptions)
    COMPILER_FEATURE_ENTRY(202411L, __cpp_lib_constexpr_exceptions)
    COMPILER_FEATURE_ENTRY(202502L, __cpp_lib_constexpr_inplace_vector)
    COMPILER_FEATURE_ENTRY(202406L, __cpp_lib_constexpr_new)
    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(202311L, __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(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(202306L, __cpp_lib_freestanding_memory)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_freestanding_numeric)
    COMPILER_FEATURE_ENTRY(202306L, __cpp_lib_freestanding_operator_new)
    COMPILER_FEATURE_ENTRY(202311L, __cpp_lib_freestanding_optional)
    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(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(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[] = {
    //< Continue to Populate
    COMPILER_FEATURE_ENTRY(202604L, __cpp_core_TODO)
};
static constexpr CompilerFeature cxx29_lib[] = {
    //< Continue to Populate
    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("Compiler specific macros:\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.maybe()) or
            (print.unsupported_features and not x.maybe())))
        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.maybe() ? 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.titles)
    {
        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 macros
    if (print.core_features)
    {   // preserve reverse revision insertion order!
        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, "ALL CORE MACROS UP TO C++%02i", latest_rev());
        show(text, latest);
    }
    latest.clear();
    if (print.lib_features)
    {   // preserve reverse revision insertion order!
        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, "ALL LIB MACROS UP TO C++%02i", latest_rev());
        show(text, latest);
    }
}
 
int main()
{
    if (print.separated_revisions)
    {
        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 LIB" , 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 LIB" , 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("ATTRIBUTES", attributes);
    if (print.compiler_specific) show_compiler_specific_info();
}

Mögliche Ausgabe

C++11 CORE (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
... truncated ...
 
C++14 CORE (9/9)
__cpp_aggregate_nsdmi                         2013-04  =  2013-04
__cpp_binary_literals                         2013-04  =  2013-04
__cpp_constexpr                               2022-11  >  2013-04
... truncated ...
 
C++14 LIB (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
... truncated ...
 
... truncated ...
 
C++23 LIB (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
... truncated ...
 
ALL CORE MACROS UP TO 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
... truncated ...
 
ALL LIB MACROS UP TO C++26 (158/255)
__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
... truncated ...
 
ATTRIBUTES (9/11)
assume                                        2022-07  =  2022-07
carries_dependency                            -------  <  2008-09
deprecated                                    2013-09  =  2013-09
fallthrough                                   2016-03  =  2016-03
... truncated ...
 
Compiler specific macros:
__cplusplus                                   202302L
__GNUG__                                      14
__GNUC_MINOR__                                2
__GNUC_PATCHLEVEL__                           0

Fehlerberichte

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

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
P2552R3	C++20	__has_cpp_attribute muss für Standardattribute auf einen Wert größer als Null erweitert werden	kann zu ​0​ erweitert werden

Siehe auch

Library Feature-Test Macros (C++20)	definiert im Header <version>
Vordefinierte Makrosymbole
Makro-Symbol-Index

Externe Links

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