Namespaces
Variants

Feature testing (since C++20)

From cppreference.net
C++
Feature testing

El estándar define un conjunto de macros de preprocesador correspondientes a características del lenguaje C++ y de la biblioteca introducidas en C++11 o posteriores. Están diseñadas como una forma simple y portable de detectar la presencia de dichas características.

Contenidos

Atributos

__has_cpp_attribute( attribute-token )

Comprueba la compatibilidad con un atributo denominado por attribute-token (después de la expansión de macros).

Para cada atributo estándar, está definido por la implementación si __has_cpp_attribute se expande al valor dado en la tabla siguiente (que es el año y mes en que el atributo fue añadido al borrador de trabajo) o ​ 0 ​ . Se expandirá al valor dado en la tabla si y solo si el atributo estándar hace que la implementación se comporte como se recomienda (emitiendo mensajes de diagnóstico, afectando el diseño de clases, etc.).

La presencia de atributos específicos del proveedor se determina por un valor distinto de cero.

__has_cpp_attribute puede expandirse en la expresión de #if y #elif . Es tratado como una macro definida por #ifdef , #ifndef , #elifdef , #elifndef (desde C++23) y defined pero no puede ser utilizado en ningún otro lugar.

attribute-token Atributo Valor Estándar Documento(s)
assume [[ assume ]] 202207L (C++23) P1774R8
carries_dependency [[ carries_dependency ]] 200809L (C++11)
(hasta 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 ]] con razón 201907L (C++20) P1301R4
noreturn [[ noreturn ]] 200809L (C++11) N2761
unlikely [[ unlikely ]] 201803L (C++20) P0479R5
Número total de atributos: 11

Características del lenguaje

Las siguientes macros pueden utilizarse para detectar si una característica del lenguaje está implementada por la implementación actual. Están predefinidas en cada unidad de traducción.

Cada macro se expande a un literal entero correspondiente al año y mes en que la característica correspondiente se incluyó en el borrador de trabajo. Cuando una característica cambia significativamente, la macro se actualizará en consecuencia.

Nombre de macro Característica Valor Estándar Documento(s)
__cpp_aggregate_ bases Clases agregadas con clases base 201603L (C++17) P0017R1
__cpp_aggregate_ nsdmi Clases agregadas con inicializadores de miembro predeterminados 201304L (C++14) N3653
__cpp_aggregate_ paren_init Inicialización de agregados en forma de inicialización directa 201902L (C++20) P0960R3
__cpp_alias_templates Plantillas de alias 200704L (C++11) N2258
__cpp_aligned_new Asignación dinámica de memoria para datos sobrealineados 201606L (C++17) P0035R4
__cpp_attributes Atributos 200809L (C++11) N2761
__cpp_auto_cast auto ( x ) y auto { x } 202110L (C++23) P0849R8
__cpp_binary_literals Literales binarios 201304L (C++14) N3472
__cpp_capture_star_ this Captura lambda de * this por valor como [ = , * this ] 201603L (C++17) P0018R3
__cpp_char8_t char8_t 201811L (C++20) P0482R6
char8_t corrección de compatibilidad y portabilidad (permitir inicialización de arrays de (unsigned) char desde literales de cadena UTF-8 ) 202207L (C++23)
(DR20) 		P2513R4
__cpp_concepts Conceptos 201907L (C++20) P0734R0
P1084R2
P1452R2
Funciones especiales miembro triviales condicionales 202002L P0848R3
P2493R0
__cpp_conditional_ explicit explicit(bool) 201806L (C++20) P0892R2
__cpp_consteval Funciones inmediatas 201811L (C++20) P1073R3
Hacer que consteval se propague hacia arriba 202211L (C++23)
(DR20) 		P2564R3
__cpp_constexpr constexpr 200704L (C++11) N2235
Relajado constexpr , métodos const constexpr no constantes 201304L (C++14) N3652
Lambda constexpr 201603L (C++17) P0170R1
Llamadas a función virtual en expresiones constantes; try bloques en funciones constexpr , dynamic_cast y typeid polimórfico en expresiones constantes; inicialización por defecto trivial y declaración asm en funciones constexpr 201907L (C++20) P1064R0
P1002R1
P1327R1
P1331R2
P1668R1
Cambiar el miembro activo de una unión en evaluación constante 202002L P1330R0
P2493R0
Variables no literales , etiquetas y sentencias goto en funciones constexpr 202110L (C++23) P2242R3
Relajando algunas restricciones en constexpr funciones y plantillas de funciones 202207L P2448R2
Permitir variables estáticas constexpr en funciones constexpr 202211L P2647R1
Conversión constexpr desde void * : hacia constexpr type-erasure 202306L (C++26) P2738R1
constexpr colocación new 202406L P2747R2
__cpp_constexpr_ dynamic_alloc Operaciones para duración de almacenamiento dinámico en constexpr funciones 201907L (C++20) P0784R7
__cpp_constexpr_ exceptions constexpr excepciones: [1] , [2] 202411L (C++26) P3068R6
__cpp_constexpr_ in_decltype Generación de definiciones de funciones y variables cuando son necesarias para evaluación constante 201711L (C++20)
(DR11) 		P0859R0
__cpp_constinit constinit 201907L (C++20) P1143R2
__cpp_contracts Contratos 202502L (C++26) P2900R14
__cpp_decltype decltype 200707L (C++11) N2343
__cpp_decltype_auto Deducción de tipo de retorno para funciones normales 201304L (C++14) N3638
__cpp_deduction_ guides Deducción de argumentos de plantilla para plantillas de clase (CTAD) 201703L (C++17) P0091R3
P0512R0
P0620R0
CTAD para agregados y alias 201907L (C++20) P1814R0
P1816R0
__cpp_delegating_ constructors Constructores delegados 200604L (C++11) N1986
__cpp_deleted_function Definiciones de función eliminadas con mensajes ( = delete ( "should have a reason" ) ; ) 202403L (C++26) P2573R2
__cpp_designated_ initializers Inicializadores designados 201707L (C++20) P0329R4
__cpp_enumerator_ attributes Atributos para enumeradores 201411L (C++17) N4266
__cpp_explicit_this_ parameter Parámetro de objeto explícito 202110L (C++23) P0847R7
__cpp_fold_expressions Expresiones de plegado 201603L (C++17) N4295
P0036R0
Ordenamiento de constraints que involucran fold expressions 202406L (C++26) P2963R3
__cpp_generic_lambdas Expresiones lambda genéricas 201304L (C++14) N3649
Lista de parámetros de plantilla explícita para lambdas genéricas 201707L (C++20) P0428R2
__cpp_guaranteed_ copy_elision Eliminación de copia garantizada mediante categorías de valor simplificadas 201606L (C++17) P0135R1
__cpp_hex_float Literales flotantes hexadecimales 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 Corrutinas (soporte del compilador) 201902L (C++20) P0912R5
LWG3393
__cpp_impl_destroying_ delete Eliminador destructor operator delete (soporte del compilador) 201806L (C++20) P0722R3
__cpp_impl_three_ way_comparison Comparación de tres vías (soporte del compilador) 201907L (C++20) P0515R3
P0768R1
P1185R2
P1630R1
__cpp_implicit_move Movimiento implícito más simple implicit move 202207L (C++23) P2266R3
__cpp_inheriting_ constructors Constructores heredados 200802L (C++11) N2540
Reformulación de constructores heredados: Nueva especificación para constructores heredados ( DR1941 et al) 201511L (C++17)
(DR11) 		P0136R1
__cpp_init_captures Captura inicial en lambdas 201304L (C++14) N3648
Permitir expansión de paquete en lambda init-capture 201803L (C++20) P0780R2
__cpp_initializer_ lists Inicialización de lista y std::initializer_list 200806L (C++11) N2672
__cpp_inline_variables Variables en línea 201606L (C++17) P0386R2
__cpp_lambdas Expresiones lambda 200907L (C++11) N2927
__cpp_modules Módulos 201907L (C++20) P1103R3
P1811R0
__cpp_multidimensional_ subscript Operador de subíndice multidimensional 202110L (C++23) P2128R6
Static operator[] 202211L P2589R1
__cpp_named_character_ escapes Escapes de caracteres universales con nombre 202207L (C++23) P2071R2
__cpp_namespace_ attributes Atributos para espacios de nombres 201411L (C++17) N4266
__cpp_noexcept_function_ type Hacer que las especificaciones de excepción sean parte del sistema de tipos 201510L (C++17) P0012R1
__cpp_nontype_template_ args Permitir evaluación constante para todos los argumentos de plantilla constantes 201411L (C++17) N4268
Tipos de clase y tipos de punto flotante en parámetros de plantilla constantes 201911L (C++20) P1907R1
__cpp_nontype_template_ parameter_auto Declarar parámetros de plantilla constantes con auto 201606L (C++17) P0127R2
__cpp_nsdmi Inicializadores de miembros de datos no estáticos 200809L (C++11) N2756
__cpp_pack_indexing Indexación de paquetes 202311L (C++26) P2662R3
__cpp_placeholder_ variables Un marcador de posición agradable sin nombre 202306L (C++26) P2169R4
__cpp_pp_embed #embed 202502L (C++26) P1967R14
__cpp_range_based_ for Bucle for basado en rangos 200907L (C++11) N2930
Bucle for basado en rangos con tipos diferentes de begin / end 201603L (C++17) P0184R0
Extensión de vida útil en bucles for basados en rangos 202211L (C++23) P2644R1
P2718R0
CWG2659
__cpp_raw_strings Literales de cadena sin formato 200710L (C++11) N2442
__cpp_ref_qualifiers calificadores de referencia 200710L (C++11) N2439
__cpp_return_type_ deduction Deducción del tipo de retorno para funciones normales 201304L (C++14) N3638
__cpp_rvalue_references Referencia a valor derecho 200610L (C++11) N2118
__cpp_size_t_suffix Sufijos literales para std::size_t y su versión con signo 202011L (C++23) P0330R8
__cpp_sized_deallocation Desasignación dimensionada 201309L (C++14) N3778
__cpp_static_assert static_assert 200410L (C++11) N1720
static_assert de un solo argumento 201411L (C++17) N3928
Mensajes de static_assert generados por el usuario 202306L (C++26) P2741R3
__cpp_static_call_ operator Operador operator() estático 202207L (C++23) P1169R4
__cpp_structured_ bindings Enlaces estructurados 201606L (C++17) P0217R3
Atributos para enlace estructurado 202403L (C++26) P0609R3
Enlaces estructurados declaración como condición 202406L P0963R3
Enlaces estructurados pueden introducir un paquete 202411L P1061R10
__cpp_template_parameters Parámetros de plantilla de conceptos y plantillas de variables 202502L (C++26) P2841R7
__cpp_template_template_ args Coincidencia de template template arguments 201611L (C++17) P0522R0
__cpp_threadsafe_ static_init Inicialización dinámica y destrucción con concurrencia 200806L (C++11) N2660
__cpp_trivial_relocatability Trivial relocatability 202502L (C++26) P2786R13
__cpp_trivial_union Uniones triviales 202502L (C++26) P3074R7
__cpp_unicode_characters Nuevos tipos de caracteres ( char16_t y char32_t ) 200704L (C++11) N2249
__cpp_unicode_literals Literales de cadena Unicode 200710L (C++11) N2442
__cpp_user_defined_ literals Literales definidos por el usuario 200809L (C++11) N2765
__cpp_using_enum using enum 201907L (C++20) P1099R5
__cpp_variable_templates Plantillas de variables 201304L (C++14) N3651
__cpp_variadic_friend Declaraciones friend variádicas 202403L (C++26) P2893R3
__cpp_variadic_templates Plantillas variádicas 200704L (C++11) N2242
__cpp_variadic_using Expansiones de paquete en using -declaraciones 201611L (C++17) P0195R2
Número total de macros: 76

Características de la biblioteca

Las siguientes macros pueden utilizarse para detectar si una característica de la biblioteca estándar está implementada por la implementación actual. A diferencia de las macros de prueba de características del lenguaje, no están predefinidas. En su lugar, son proporcionadas por el encabezado <version> .

Para cada macro de prueba de características de la biblioteca, también es proporcionada por los encabezados que ofrecen los componentes relevantes de la biblioteca estándar. Consulte macros de prueba de características de la biblioteca para una lista completa de encabezados que proporcionan estas macros.

Cada macro se expande a un literal entero correspondiente al año y mes en que la característica correspondiente se ha incluido en el borrador de trabajo. Cuando una característica cambia significativamente, la macro se actualizará en consecuencia.

Nombre de macro Característica Valor Estándar Documento(s)
__cpp_lib_adaptor_ iterator_pair_constructor Constructores de pares de iteradores para std::stack y std::queue 202106L (C++23) P1425R4
__cpp_lib_addressof_ constexpr Constexpr std::addressof 201603L (C++17) LWG2296
__cpp_lib_algorithm_ default_value_type Habilitar list-initialization para algorithms 202403L (C++26) P2248R8
P3217R0
__cpp_lib_algorithm_ iterator_requirements Iteradores de rangos como entradas para algoritmos no-Ranges 202207L (C++23) P2408R5
__cpp_lib_aligned_ accessor std::aligned_accessor : un accessor de std::mdspan que expresa sobrealineación de punteros 202411L (C++26) P2897R7
__cpp_lib_allocate_ at_least Retroalimentación de tamaño en la interfaz del asignador, por ejemplo: 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 limpiezas 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 para std::reverse_iterator , std::move_iterator , std::array y acceso a rangos 201603L (C++17) P0031R0
ConstexprIterator ; constexpr comparación para std::array ; misceláneos constexpr bits ( std::array::fill et al.) 201811L (C++20) P0858R0
LWG3257
P1023R0
P1032R1
__cpp_lib_as_const std::as_const 201510L (C++17) P0007R1
__cpp_lib_associative_ heterogeneous_erasure Eliminación heterogénea en contenedores asociativos y contenedores asociativos no ordenados 202110L (C++23) P2077R3
__cpp_lib_associative_ heterogeneous_insertion Sobrecargas heterogéneas para las funciones miembro restantes en contenedores ordenados y contenedores asociativos no ordenados 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 Atomic de punto flotante 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 Tipos integrales atómicos libres de bloqueo ( std::atomic_signed_lock_free , std::atomic_unsigned_lock_free ) 201907L (C++20) P1135R6
__cpp_lib_atomic_ min_max Mínimo/máximo atómico ( 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 Corrección de inicialización atómica (inicialización por valor std::atomic por defecto) 201911L (C++20) P0883R2
__cpp_lib_atomic_ wait Espera eficiente para std::atomic 201907L (C++20) P1135R6
__cpp_lib_barrier std::barrier 201907L (C++20) P1135R6
std::barrier garantías de finalización de fase 202302L (C++23) P2588R3
__cpp_lib_bind_back std::bind_back 202202L (C++23) P2387R3
Permitir pasar objetos invocables como argumentos de plantilla constantes a std::bind_back 202306L (C++26) P2714R1
__cpp_lib_bind_front std::bind_front 201907L (C++20) P0356R5
P1651R0
Permitir pasar objetos invocables como argumentos de plantilla constantes a std::bind_front 202306L (C++26) P2714R1
__cpp_lib_bit_cast std::bit_cast 201806L (C++20) P0476R2
__cpp_lib_bitops Operaciones de bits 201907L (C++20) P0553R4
__cpp_lib_bitset Interconexión std::bitset con 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 Buscadores 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 Soporte de biblioteca para char8_t 201907L (C++20) P0482R6
P1423R3
__cpp_lib_chrono Funciones de redondeo para std::chrono::duration y std::chrono::time_point 201510L (C++17) P0092R1
Constexpr para todas las funciones miembro de std::chrono::duration y std::chrono::time_point 201611L P0505R0
Calendarios y Zonas horarias 201907L (C++20) P0355R7
P1466R3
Soporte de hashing para las clases de valor de std::chrono 202306L (C++26) P2592R3
__cpp_lib_chrono_ udls Literales definidos por el usuario para tipos de tiempo 201304L (C++14) N3642
__cpp_lib_clamp std::clamp 201603L (C++17) P0025R1
__cpp_lib_common_ reference Hacer que std::common_reference_t de std::reference_wrapper sea un tipo referencia 202302L (C++23) P2655R3
__cpp_lib_common_ reference_wrapper Hacer que std::common_reference_t de std::reference_wrapper sea un tipo de referencia 202302L (C++23) P2655R3
__cpp_lib_complex_ udls Literales Definidos por el Usuario para std::complex 201309L (C++14) N3779
__cpp_lib_concepts Conceptos de la biblioteca estándar 202002L (C++20) P0898R3
P1754R1
P1964R2
Tipos de solo movimiento para equality_comparable_with , totally_ordered_with , y three_way_comparable_with 202207L (C++23) P2404R3
__cpp_lib_constexpr_ algorithms Constexpr para algoritmos 201806L (C++20) P0202R3
P0879R0
LWG3256
LWG3792
Ordenamiento estable constexpr 202306L (C++26) P2562R1
__cpp_lib_constexpr_ atomic constexpr std::atomic y std::atomic_ref 202411L (C++26) P3309R3
__cpp_lib_constexpr_ bitset Un constexpr std::bitset más completo 202207L (C++23) P2417R2
__cpp_lib_constexpr_ charconv Constexpr para std::to_chars y std::from_chars para tipos integrales 202207L (C++23) P2291R3
__cpp_lib_constexpr_ cmath Constexpr para funciones matemáticas en <cmath> y <cstdlib> 202202L (C++23) P0533R9
Más constexpr para <cmath> 202306L (C++26) P1383R2
__cpp_lib_constexpr_ complex Constexpr para std::complex 201711L (C++20) P0415R1
Más constexpr para <complex> 202306L (C++26) P1383R2
__cpp_lib_constexpr_ deque constexpr std::deque 202502L (C++26) P3372R3
__cpp_lib_constexpr_ dynamic_alloc Constexpr para std::allocator y utilidades relacionadas 201907L (C++20) P0784R7
__cpp_lib_constexpr_ exceptions constexpr para tipos de excepción, ej. std::bad_alloc , std::bad_cast etc. 202411L (C++26) P3068R6
Más constexpr para tipos de excepción 202502L P3378R2
__cpp_lib_constexpr_ flat_map constexpr std::flat_map y std::flat_multimap 202502L (C++26) P3372R3
__cpp_lib_constexpr_ flat_set constexpr std::flat_set y std::flat_multiset 202502L (C++26) P3372R3
__cpp_lib_constexpr_ forward_list constexpr std::forward_list 202502L (C++26) P3372R3
__cpp_lib_constexpr_ functional Misc constexpr bits ( std::default_searcher ); constexpr INVOKE 201907L (C++20) P1032R1
P1065R2
__cpp_lib_constexpr_ inplace_vector constexpr std::inplace_vector para tipos no triviales 202502L (C++26) P3074R7
__cpp_lib_constexpr_ iterator Misceláneos constexpr bits ( std::insert_iterator et al.) 201811L (C++20) P1032R1
__cpp_lib_constexpr_ list constexpr std::list 202502L (C++26) P3372R3
__cpp_lib_constexpr_ map constexpr std::map y std::multimap 202502L (C++26) P3372R3
__cpp_lib_constexpr_ memory Constexpr en 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 para algoritmos en <numeric> 201911L (C++20) P1645R1
__cpp_lib_constexpr_ queue constexpr std::queue 202502L (C++26) P3372R3
__cpp_lib_constexpr_ set constexpr std::set y 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 Misceláneos constexpr bits ( std::string_view::copy ) 201811L (C++20) P1032R1
__cpp_lib_constexpr_ tuple Misceláneos constexpr bits ( std::tuple::operator= et al.) 201811L (C++20) P1032R1
__cpp_lib_constexpr_ typeinfo Constexpr para std::type_info::operator== 202106L (C++23) P1328R1
__cpp_lib_constexpr_ unordered_map constexpr std::unordered_map y std::unordered_multimap 202502L (C++26) P3372R3
__cpp_lib_constexpr_ unordered_set constexpr std::unordered_set y std::unordered_multiset 202502L (C++26) P3372R3
__cpp_lib_constexpr_ utility Bits misceláneos constexpr ( std::pair::operator= et al.) 201811L (C++20) P1032R1
__cpp_lib_constexpr_ vector Constexpr para std::vector 201907L (C++20) P1004R2
__cpp_lib_constrained_ equality Operadores relacionales restringidos para std::pair , std::tuple , std::optional , y std::variant 202403L (C++26) P2944R3
Restringiendo std::expected operadores de igualdad 202411L P3379R0
__cpp_lib_containers_ ranges Construcción e inserción con reconocimiento de rangos para contenedores y cadenas 202202L (C++23) P1206R7
__cpp_lib_contracts <contracts> : Soporte para contratos 202502L (C++26) P2900R14
__cpp_lib_copyable_ function std::copyable_function 202306L (C++26) P2548R6
__cpp_lib_coroutine Corrutinas (soporte de biblioteca) 201902L (C++20) P0912R5
LWG3393
__cpp_lib_debugging <debugging> : Soporte de depuración 202311L (C++26) P2546R5
Reemplazable std::is_debugger_present 202403L P2810R4
__cpp_lib_destroying_ delete Eliminador destructor operator delete (soporte de biblioteca) 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 Borrado uniforme de contenedores 202002L (C++20) P1209R0
P1115R3
__cpp_lib_exchange_ function std::exchange 201304L (C++14) N3668
__cpp_lib_execution Políticas de ejecución 201603L (C++17) P0024R2
std::execution::unsequenced_policy 201902L (C++20) P1001R2
__cpp_lib_expected plantilla de clase std::expected 202202L (C++23) P0323R12
Funciones monádicas para std::expected 202211L P2505R5
__cpp_lib_filesystem Biblioteca de sistema de archivos 201703L (C++17) P0218R1
P0219R1
P0392R0
P0317R1
__cpp_lib_flat_map std::flat_map y std::flat_multimap 202207L (C++23) P0429R9
__cpp_lib_flat_set std::flat_set y std::flat_multiset 202207L (C++23) P1222R4
LWG3751
__cpp_lib_format Formato de texto 201907L (C++20) P0645R10
P1361R2
P1652R1
Comprobaciones de cadenas de formato en tiempo de compilación; Reducción de parametrización de std::vformat_to 202106L (C++23)
(DR20) 		P2216R3
Corrección del manejo de configuraciones regionales en formateadores chrono; Soporte para tipos no constantemente formateables 202110L P2372R3
P2418R2
Exponer std::basic_format_string ; aclarar el manejo de codificaciones en el formateo localizado de tipos chrono 202207L (C++23) P2419R2
P2508R1
Formateo de punteros 202304L (C++26) P2510R3
Verificación de tipos en argumentos de formato 202305L P2757R3
Miembro visit 202306L P2637R3
Cadenas de formato en tiempo de ejecución 202311L P2918R2
__cpp_lib_format_ path Formateo de std::filesystem::path 202403L (C++26) P2845R8
__cpp_lib_format_ ranges Formateo de rangos 202207L (C++23) P2286R8
P2585R1
LWG3750
__cpp_lib_format_ uchar Corregir el formato de unidades de código como enteros 202311L (C++26) P2909R4
__cpp_lib_formatters Formateo std::thread::id y std::stacktrace 202302L (C++23) P2693R1
__cpp_lib_forward_ like std::forward_like 202207L (C++23) P2445R1
__cpp_lib_freestanding_ algorithm Facilidades independientes en <algorithm> 202311L (C++26) P2407R5
Biblioteca independiente: <algorithm> 202502L P2976R1
__cpp_lib_freestanding_ array Hacer partes de std::array independientes 202311L (C++26) P2407R5
__cpp_lib_freestanding_ char_traits Independiente std::char_traits 202306L (C++26) P2338R4
__cpp_lib_freestanding_ charconv Facilidades independientes en <charconv> 202306L (C++26) P2338R4
__cpp_lib_freestanding_ cstdlib Facilidades independientes en <cstdlib> 202306L (C++26) P2338R4
__cpp_lib_freestanding_ cstring Facilidades independientes en <cstring> 202306L (C++26) P2338R4
Eliminando std::strtok de las facilidades independientes 202311L P2937R0
__cpp_lib_freestanding_ cwchar Facilidades independientes en <cwchar> 202306L (C++26) P2338R4
__cpp_lib_freestanding_ errc Independiente std::errc 202306L (C++26) P2338R4
__cpp_lib_freestanding_ execution Biblioteca independiente: <execution> 202502L (C++26) P2976R1
__cpp_lib_freestanding_ expected Hacer partes de std::expected independientes 202311L (C++26) P2833R2
__cpp_lib_freestanding_ feature_test_macros Soporte para macros de prueba de características en entornos independientes 202306L (C++26) P2198R7
__cpp_lib_freestanding_ functional Facilidades independientes en <functional> 202306L (C++26) P2198R7
__cpp_lib_freestanding_ iterator Facilidades independientes en <iterator> 202306L (C++26) P2198R7
__cpp_lib_freestanding_ mdspan Independiente std::mdspan 202311L (C++26) P2833R2
__cpp_lib_freestanding_ memory Facilidades independientes en <memory> 202306L (C++26) P2198R7
Biblioteca Independiente: <memory> 202502L P2976R1
__cpp_lib_freestanding_ numeric Facilidades independientes en <numeric> (aritmética de saturación) 202311L (C++26) P0543R3
Biblioteca independiente: <numeric> 202502L P2976R1
__cpp_lib_freestanding_ operator_new Definición de operator new (opcional en implementaciones freestanding) 202306L (C++26) P2198R7
__cpp_lib_freestanding_ optional Hacer partes de std::optional independientes 202311L (C++26) P2407R5
__cpp_lib_freestanding_ random Biblioteca independiente: <random> 202502L (C++26) P2976R1
__cpp_lib_freestanding_ ranges Facilidades independientes en <ranges> 202306L (C++26) P2198R7
__cpp_lib_freestanding_ ratio Facilidades independientes en <ratio> 202306L (C++26) P2198R7
__cpp_lib_freestanding_ string_view Hacer partes de std::string_view independientes 202311L (C++26) P2407R5
__cpp_lib_freestanding_ tuple Instalaciones independientes en <tuple> 202306L (C++26) P2198R7
__cpp_lib_freestanding_ utility Facilidades independientes en <utility> 202306L (C++26) P2198R7
__cpp_lib_freestanding_ variant Hacer partes de std::variant independientes 202311L (C++26) P2407R5
__cpp_lib_fstream_ native_handle Obtención de identificadores nativos de flujos de archivos 202306L (C++26) P1759R6
__cpp_lib_function_ ref std::function_ref : Una referencia invocable con borrado de tipo 202306L (C++26) P0792R14
__cpp_lib_gcd_lcm std::gcd , std::lcm 201606L (C++17) P0295R0
__cpp_lib_generator std::generator : Generador de corrutina síncrona para rangos 202207L (C++23) P2502R2
__cpp_lib_generic_ associative_lookup Búsqueda de comparación heterogénea en contenedores asociativos 201304L (C++14) N3657
__cpp_lib_generic_ unordered_lookup Búsqueda de comparación heterogénea en contenedores asociativos desordenados 201811L (C++20) P0919R3
__cpp_lib_hardened_ array Endurecimiento de la biblioteca estándar (presente solo en implementaciones endurecidas) 202502L (C++26) P3471R4
__cpp_lib_hardened_ basic_string Endurecimiento de la biblioteca estándar (presente solo en implementación endurecida) 202502L (C++26) P3471R4
__cpp_lib_hardened_ basic_string_view Endurecimiento de la biblioteca estándar (presente solo en implementaciones endurecidas) 202502L (C++26) P3471R4
__cpp_lib_hardened_ bitset Fortalecimiento de la biblioteca estándar (presente solo en implementaciones reforzadas) 202502L (C++26) P3471R4
__cpp_lib_hardened_ deque Endurecimiento de la biblioteca estándar (presente solo en implementación endurecida) 202502L (C++26) P3471R4
__cpp_lib_hardened_ expected Endurecimiento de la biblioteca estándar (presente solo en implementación endurecida) 202502L (C++26) P3471R4
__cpp_lib_hardened_ forward_list Endurecimiento de la biblioteca estándar (presente solo en implementaciones endurecidas) 202502L (C++26) P3471R4
__cpp_lib_hardened_ inplace_vector Fortalecimiento de la biblioteca estándar (presente solo en implementaciones reforzadas) 202502L (C++26) P3471R4
__cpp_lib_hardened_ list Endurecimiento de la biblioteca estándar (presente solo en implementación endurecida) 202502L (C++26) P3471R4
__cpp_lib_hardened_ mdspan Endurecimiento de la biblioteca estándar (presente solo en implementaciones endurecidas) 202502L (C++26) P3471R4
__cpp_lib_hardened_ optional Fortalecimiento de la biblioteca estándar (presente solo en implementaciones reforzadas) 202502L (C++26) P3471R4
__cpp_lib_hardened_ span Endurecimiento de la biblioteca estándar (presente solo en implementaciones endurecidas) 202502L (C++26) P3471R4
__cpp_lib_hardened_ valarray Endurecimiento de la biblioteca estándar (presente solo en implementaciones endurecidas) 202502L (C++26) P3471R4
__cpp_lib_hardened_ vector Fortalecimiento de la biblioteca estándar (presente solo en implementaciones reforzadas) 202502L (C++26) P3471R4
__cpp_lib_hardware_ interference_size Constexpr std::hardware_{constructive, destructive}_interference_size 201703L (C++17) P0154R1
__cpp_lib_hive <hive> : un contenedor basado en cubos que reutiliza ubicaciones de memoria de elementos borrados 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> : Punteros de riesgo 202306L (C++26) P2530R3
__cpp_lib_hypot Sobrecarga de 3 argumentos de std::hypot 201603L (C++17) P0030R1
__cpp_lib_incomplete_ container_elements Soporte mínimo para tipos incompletos en std::forward_list , std::list , y std::vector 201505L (C++17) N4510
__cpp_lib_indirect std::indirect 202502L (C++26) P3019R13
__cpp_lib_inplace_ vector std::inplace_vector : Vector redimensionable dinámicamente con capacidad fija (almacenamiento in situ) 202406L (C++26) P0843R14
__cpp_lib_int_pow2 Operaciones de potencia de 2 enteras ( std::has_single_bit , std::bit_ceil , std::bit_floor , std::bit_width ) 202002L (C++20) P0556R3
P1956R1
__cpp_lib_integer_ comparison_functions Funciones de comparación de enteros 202002L (C++20) P0586R2
__cpp_lib_integer_ sequence Secuencias enteras en tiempo de compilación 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 Soporte para modo exclusivo para 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 Rasgos de interconvertibilidad de punteros: 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 : verifica la precondición de alineación de un puntero 202411L (C++26) P2897R7
__cpp_lib_is_swappable Rasgos (nothrow-)swappable 201603L (C++17) P0185R1
__cpp_lib_is_virtual_ base_of std::is_virtual_base_of : Rasgo de tipo para detectar clases base virtuales 202406L (C++26) P2985R0
__cpp_lib_is_within_ lifetime Verificar si una alternativa de unión está activa ( std::is_within_lifetime ) 202306L (C++26) P2641R4
__cpp_lib_jthread Token de parada y Hilo de unión 201911L (C++20) P0660R10
P1869R1
__cpp_lib_latch std::latch 201907L (C++20) P1135R6
__cpp_lib_launder CWG issue 1776 : Reemplazo de objetos de clase que contienen miembros de referencia ( std::launder ) 201606L (C++17) P0137R1
__cpp_lib_linalg Una interfaz de álgebra lineal basada en BLAS con funciones libres 202311L (C++26) P1673R13
__cpp_lib_list_remove_ return_type Cambiar el tipo de retorno de remove() , remove_if() y unique() de std::forward_list y std::list 201806L (C++20) P0646R1
__cpp_lib_logical_ traits Operaciones lógicas en traits de tipos 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 Constantes matemáticas 201907L (C++20) P0631R8
__cpp_lib_math_special_ functions Funciones matemáticas especiales 201603L (C++17) P0226R1
__cpp_lib_mdspan std::mdspan 202207L (C++23) P0009R18
P2599R2
P2604R0
P2613R1
std::dims para std::mdspan 202406L (C++26) P2389R2
__cpp_lib_memory_ resource std::pmr::memory_resource 201603L (C++17) P0220R1
__cpp_lib_modules Módulos de la biblioteca estándar std y std.compat 202207L (C++23) P2465R3
__cpp_lib_move_iterator_ concept Hacer que std::move_iterator<T*> sea un iterador de acceso aleatorio 202207L (C++23) P2520R0
__cpp_lib_move_only_ function std::move_only_function 202110L (C++23) P0288R9
__cpp_lib_node_extract Empalme de mapas y conjuntos ( std::map::extract , std::map::merge , insert(node_type) , etc) 201606L (C++17) P0083R3
__cpp_lib_nonmember_ container_access std::size , std::data y std::empty 201411L (C++17) N4280
__cpp_lib_not_fn std::not_fn 201603L (C++17) P0005R4
Permitir pasar objetos invocables como argumentos de plantilla constantes a std::not_fn 202306L (C++26) P2714R1
__cpp_lib_null_iterators Iteradores nulos LegacyForwardIterator s 201304L (C++14) N3644
__cpp_lib_optional std::optional 201606L (C++17) P0220R1
P0032R3
P0307R2
Completamente constexpr std::optional 202106L (C++23)
(DR20) 		P2231R1
Operaciones monádicas en std::optional 202110L (C++23) P0798R8
LWG3621
__cpp_lib_optional_ range_support std::optional soporte para rangos 202406L (C++26) P3168R2
__cpp_lib_out_ptr std::out_ptr , std::inout_ptr 202106L (C++23) P1132R8
Independiente std::out_ptr , std::inout_ptr 202311L (C++26) P2833R2
__cpp_lib_parallel_ algorithm Algoritmos paralelos 201603L (C++17) P0024R2
__cpp_lib_polymorphic std::polymorphic 202502L (C++26) P3019R13
__cpp_lib_polymorphic_ allocator std::pmr::polymorphic_allocator<> como tipo de vocabulario 201902L (C++20) P0339R6
LWG3437
__cpp_lib_print Salida formateada 202207L (C++23) P2093R14
Permitir una implementación eficiente de std::print 202403L (C++26)
(DR23) 		P3107R5
P3235R3
Imprimir Líneas en Blanco con std::println 202403L (C++26) P3142R0
__cpp_lib_quoted_ string_io std::quoted 201304L (C++14) N3654
__cpp_lib_philox_ engine std::philox_engine : Motor de números aleatorios basado en contador 202406L (C++26) P2075R6
__cpp_lib_ranges Biblioteca de rangos y algoritmos restringidos 201911L (C++20) P0896R4
P1035R7
P1716R3
Vistas no inicializables por defecto 202106L (C++23)
(DR20) 		P2325R3
Vistas con propiedad 202110L P2415R2
std::ranges::range_adaptor_closure 202202L (C++23) P2387R3
Relajando los adaptadores de rango para permitir tipos de solo movimiento 202207L P2494R2
Eliminación de sobrecargas "poison pill" en ranges::begin , ranges::end , ranges::rbegin , ranges::rend , y ranges::size 202211L P2602R2
Relajando rangos para permitir ciertas proyecciones 202302L P2609R3
Eliminando el requisito de referencia común de los conceptos indirectamente invocables 202406L (C++26)
(DR20) 		P2997R1
__cpp_lib_ranges_ as_const std::const_iterator , std::ranges::as_const_view 202207L (C++23) P2278R4
Hacer que std::basic_const_iterator siga la convertibilidad de su tipo subyacente 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 , y std::ranges::find_last_if_not 202207L (C++23) P1223R5
LWG3807
__cpp_lib_ranges_ fold std::ranges algoritmos fold 202207L (C++23) P2322R6
__cpp_lib_ranges_ generate_random API de vector para generación de números aleatorios ( 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 y 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 Adición de los nuevos prefijos del SI de 2022 202306L (C++26) P2734R0
__cpp_lib_raw_memory_ algorithms Extendiendo herramientas de gestión de memoria 201606L (C++17) P0040R3
constexpr para algoritmos de memoria especializados 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 y std::reference_converts_from_temporary 202202L (C++23) P2255R2
__cpp_lib_reference_ wrapper Comparaciones para 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 y SFINAE 201210L (C++14) N3462
__cpp_lib_robust_ nonmodifying_seq_ops Hacer las operaciones de secuencia no modificadoras más robustas (sobrecargas de dos rangos para std::mismatch , std::equal y std::is_permutation ) 201304L (C++14) N3671
__cpp_lib_sample std::sample 201603L (C++17) P0220R1
__cpp_lib_saturation_ arithmetic Aritmética de saturación 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 : Modelo emisor-receptor de control de ejecución 202406L (C++26) P2300R10
__cpp_lib_shared_ mutex std::shared_mutex (sin temporización) 201505L (C++17) N4508
__cpp_lib_shared_ ptr_arrays std::shared_ptr<T[]> 201611L (C++17) P0497R0
Soporte de arreglos para 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 y std::shift_right 201806L (C++20) P0769R2
std::ranges::shift_left y std::ranges::shift_right 202202L (C++23) P2440R1
__cpp_lib_simd <simd> : Tipos de datos paralelos 202411L (C++26) P1928R15
P3430R3
P3441R2
P3287R3
P2933R4
__cpp_lib_simd_complex Soporte de valores complejos entrelazados en std::datapar::simd 202502L (C++26) P2663R7
__cpp_lib_smart_ ptr_for_overwrite Creación de punteros inteligentes con inicialización por defecto ( 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 Habilitar el uso de std::weak_ptr como claves en contenedores asociativos desordenados 202306L (C++26) P1901R2
__cpp_lib_source_ location Captura de información del código fuente ( std::source_location ) 201907L (C++20) P1208R6
__cpp_lib_span std::span 202002L (C++20) P0122R7
LWG3274
P1024R3
P1976R2
Hacer partes de std::span independientes 202311L (C++26) P2821R5
P2833R2
__cpp_lib_span_initializer_ list Construcción de std::span desde una lista de inicialización 202311L (C++26) P2447R6
__cpp_lib_spanstream std::spanbuf , std::spanstream 202106L (C++23) P0448R4
__cpp_lib_ssize std::ssize y unsigned std::span::size 201902L (C++20) P1227R2
__cpp_lib_sstream_ from_string_view Interconexión de std::stringstream con std::string_view 202306L (C++26) P2495R3
__cpp_lib_stacktrace Biblioteca de seguimiento de pila 202011L (C++23) P0881R7
__cpp_lib_start_ lifetime_as Gestión explícita del tiempo de vida ( std::start_lifetime_as ) 202207L (C++23) P2590R2
__cpp_lib_starts_ ends_with Verificación de prefijos y sufijos de cadenas ( starts_with() y ends_with() para std::string y std::string_view ) 201711L (C++20) P0457R2
__cpp_lib_stdatomic_ h Cabecera de compatibilidad para operaciones atómicas de C 202011L (C++23) P0943R6
__cpp_lib_string_ contains contains() para std::basic_string y 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 Literales definidos por el usuario para tipos de cadena 201304L (C++14) N3642
__cpp_lib_string_ view std::string_view 201606L (C++17) P0220R1
P0254R2
ConstexprIterator 201803L (C++20) P0858R0
LWG3257
Concatenación de std::string s y std::string_view s 202403L (C++26) P2591R5
__cpp_lib_submdspan std::submdspan 202306L (C++26) P2630R4
Diseños mdspan con relleno 202403L P2642R6
__cpp_lib_syncbuf Flujo de salida sincronizado con búfer ( std::syncbuf , std::osyncstream ) y manipuladores 201803L (C++20) P0053R7
P0753R2
__cpp_lib_text_encoding std::text_encoding 202306L (C++26) P1885R12
__cpp_lib_three_ way_comparison Comparación de tres vías (soporte de biblioteca); adición de comparación de tres vías a la biblioteca 201907L (C++20) P0768R1
P1614R2
__cpp_lib_to_address Utilidad para convertir un puntero a un puntero crudo ( std::to_address ) 201711L (C++20) P0653R2
__cpp_lib_to_array std::to_array 201907L (C++20) P0325R4
__cpp_lib_to_chars Conversiones elementales de cadenas ( std::to_chars , std::from_chars ) 201611L (C++17) P0067R5
P0682R1
LWG3137
Prueba de éxito o fallo de las funciones de <charconv> 202306L (C++26) P2497R0
__cpp_lib_to_string Redefinición de std::to_string en términos de std::format 202306L (C++26) P2587R3
__cpp_lib_to_underlying std::to_underlying 202102L (C++23) P1682R3
__cpp_lib_transformation_ trait_aliases Alias templates para traits de transformación 201304L (C++14) N3655
__cpp_lib_transparent_ operators Operadores funtores transparentes ( std::less<> y similares) 201210L (C++14) N3421
Transparente std::owner_less ( std::owner_less<void> ) 201510L (C++17) P0074R0
__cpp_lib_trivially_ relocatable Rasgos y operaciones de reubicación trivial 202502L (C++26) P2786R13
__cpp_lib_tuple_ element_t std::tuple_element_t 201402L (C++14) N3887
__cpp_lib_tuple_ like Compatibilidad entre std::tuple y objetos tipo tupla ( std::pair , std::array , std::subrange ) 202207L (C++23) P2165R4
Agregar protocolo de tupla a std::complex 202311L (C++26) P2819R2
__cpp_lib_tuples_ by_type Direccionamiento de tuplas por tipo 201304L (C++14) N3670
__cpp_lib_type_identity std::type_identity 201806L (C++20) P0887R1
__cpp_lib_type_trait_ variable_templates Plantillas de variables para rasgos de tipo ( 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 y std::unwrap_reference 201811L (C++20) P0318R1
LWG3348
__cpp_lib_variant std::variant : Una unión type-safe para C++17 201606L (C++17) P0088R3
P0393R3
P0032R3
std::visit para clases derivadas de std::variant 202102L (C++23)
(DR17) 		P2162R2
Completamente constexpr std::variant 202106L (C++23)
(DR20) 		P2231R1
Miembro visit 202306L (C++26) P2637R3
__cpp_lib_void_t std::void_t 201411L (C++17) N3911
Número total de macros: 282

Ejemplo

Uso normal

Ejecutar este código 
#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() {}

Volcado de Características del Compilador

El siguiente programa (compatible con C++11) muestra las características y atributos del compilador de C++. Tenga en cuenta que el uso de __has_cpp_attribute ( ) no es conforme al estándar y depende de la implementación de gcc/clang.

Ejecutar este código 
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 "Se requiere C++11 o superior"
#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
// Esperar una cadena que comience con 6-dígitos-decimales o con '_' (si no es compatible)
#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; }
};
// Macros no FTM, incluyendo implementaciones específicas:
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__)
    // Tipos de punto flotante de ancho fijo opcionales <stdfloat> (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__)
    // Agregue sus macros específicos de implementación favoritos...
    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[] = {
    //< Continuar Poblando
    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[] = {
    //< Continuar Poblando
    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[] = {
    //< Continuar Poblando
    COMPILER_FEATURE_ENTRY(202604L, __cpp_core_TODO)
};
static constexpr CompilerFeature cxx29_lib[] = {
    //< Continuar Poblando
    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("OTRAS MACROS:\n");
    for (auto co : compiler)
        if (std::strcmp(co.primero, 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.títulos)
    {
        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); // macros max
    if (print.core_features)
    {   // ¡preservar el orden de inserción de revisión inversa!
        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, "TODAS LAS MACROS PRINCIPALES HASTA C++%02i", latest_rev());
        show(text, latest);
    }
    latest.clear();
    if (print.lib_features)
    {   // ¡preservar el orden de inserción de revisión inversa!
        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, "TODAS LAS MACROS DE BIBLIOTECA HASTA 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("BIBLIOTECA C++14" , 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("ATRIBUTOS", attributes);
    if (print.compiler_specific) show_compiler_specific_info();
}

Salida posible: 

C++11 NÚCLEO (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
... truncado ...
C++14 NÚCLEO (9/9)
__cpp_aggregate_nsdmi                         2013-04  =  2013-04
__cpp_binary_literals                         2013-04  =  2013-04
__cpp_constexpr                               2022-11  >  2013-04
... truncado ...
C++14 BIBLIOTECA (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
... truncado ...
... truncado ...
C++23 BIBLIOTECA (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
... truncado ...
TODAS LAS MACROS DE NÚCLEO HASTA 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
... truncado ...
TODAS LAS MACROS DE BIBLIOTECA HASTA 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
... truncado ...
ATRIBUTOS (9/11)
assume                                        2022-07  =  2022-07
carries_dependency                            -------  <  2008-09
deprecated                                    2013-09  =  2013-09
fallthrough                                   2016-03  =  2016-03
... truncado ...
OTRAS MACROS:
__cplusplus                                   202302L
__GNUG__                                      14
__GNUC_MINOR__                                2
__GNUC_PATCHLEVEL__                           0
__STDCPP_FLOAT16_T__                          1
__STDCPP_FLOAT32_T__                          1
... truncado ...

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

DR Aplicado a Comportamiento publicado Comportamiento correcto
P2552R3 C++20 __has_cpp_attribute debe expandirse a un valor distinto de cero para atributos estándar puede expandirse a ​ 0 ​

Véase también

Macros de prueba de características de la biblioteca (C++20) definidos en el encabezado <version>
Símbolos de Macros Predefinidos
Índice de Símbolos de Macro

Enlaces externos

1. El documento oficial sobre Recomendaciones de Pruebas de Características
2. Código fuente para volcar características del compilador