Макросы проверки возможностей (C++20)

 

C++

Поддержка компилятором

Автономные и размещённые реализации

Язык

Заголовки стандартной библиотеки

Требования к именованию

Макросы тестирования функциональности (C++20)

Поддержка языка

Библиотека концептов (C++20)

Библиотека диагностики

Библиотека общих утилит

Библиотека строк

Библиотека контейнеров

Библиотека итераторов

Библиотека диапазонов (C++20)

Библиотека алгоритмов

Библиотека численных данных

Библиотека ввода/вывода

Библиотека локализаций

Регулярные выражения (C++11)

Атомарные операции (C++11)

Библиотека поддержки потоков (C++11)

Библиотека файловой системы (C++17)

Технические спецификации

Указатель символов

Внешние библиотеки

 

Макросы проверки возможностей

 

Стандарт определяет набор макросов препроцессора, соответствующих языку C++ и возможностям библиотеки, представленным в C++11 или новее. Они предназначены как простой и портабельный способ проверки наличия указанных возможностей.

Атрибуты

__has_cpp_attribute( маркер-атрибута )

Проверяет наличие атрибута с именем маркер-атрибута (после раскрытия макроса).

Для стандартных атрибутов он будет расширен до года и месяца, когда атрибут был добавлен в рабочий черновик (смотрите таблицу ниже), наличие атрибутов, зависящих от поставщика, определяется ненулевым значением.

__has_cpp_attribute можно разложить на выражение #if и #elif. Он рассматривается как определённый макрос для #ifdef, #ifndef и defined, но не может быть использован где-либо еще.

маркер-атрибута	Атрибут	Значение	Стандарт
carries_dependency	[[carries_dependency]]	200809L	(C++11)
deprecated	[[deprecated]]	201309L	(C++14)
fallthrough	[[fallthrough]]	201603L	(C++17)
likely	[[likely]]	201803L	(C++20)
maybe_unused	[[maybe_unused]]	201603L	(C++17)
no_unique_address	[[no_unique_address]]	201803L	(C++20)
nodiscard	[[nodiscard]]	201603L	(C++17)
		201907L	(C++20)
noreturn	[[noreturn]]	200809L	(C++11)
unlikely	[[unlikely]]	201803L	(C++20)

Возможности языка

Следующие макросы предопределены в каждой единице трансляции. Каждый макрос расширяется до целочисленного литерала, соответствующего году и месяцу, когда соответствующая возможность была включена в рабочий черновик.

Когда возможность значительно изменится, макрос будет обновлён соответствующим образом.

Имя макроса	Возможность	Значение	Стд
__cpp_aggregate_bases	Агрегирование классов с базовыми классами	201603L	(C++17)
__cpp_aggregate_nsdmi	Агрегирование классов с инициализаторами элементов по умолчанию	201304L	(C++14)
__cpp_aggregate_paren_init	Агрегированная инициализация в форме прямой инициализации	201902L	(C++20)
__cpp_alias_templates	Шаблоны псевдонимов	200704L	(C++11)
__cpp_aligned_new	Динамическое выделение памяти для данных с нестандартным выравниванием	201606L	(C++17)
__cpp_attributes	Атрибуты	200809L	(C++11)
__cpp_binary_literals	Двоичные литералы	201304L	(C++14)
__cpp_capture_star_this	Лямбда-захват *this по значению как [=,*this]	201603L	(C++17)
__cpp_char8_t	char8_t	201811L	(C++20)
__cpp_concepts	Концепты	201907L	(C++20)
__cpp_conditional_explicit	explicit(bool)	201806L	(C++20)
__cpp_consteval	Немедленно выполняемые функции	201811L	(C++20)
__cpp_constexpr	constexpr	200704L	(C++11)
	Ослабленный constexpr, не-const constexpr методы	201304L	(C++14)
	Constexpr лямбда	201603L	(C++17)
	Тривиальный инициализация по умолчанию и объявление asm в constexpr функциях	201907L	(C++20)
__cpp_constexpr_dynamic_alloc	Операции для динамической длительности хранения в constexpr функциях	201907L	(C++20)
__cpp_constexpr_in_decltype	Создание определений функций и переменных, когда они необходимы для вычисления константы	201711L	(C++20)
__cpp_constinit	constinit	201907L	(C++20)
__cpp_decltype	decltype	200707L	(C++11)
__cpp_decltype_auto	Вывод типа возвращаемого значения для обычных функций	201304L	(C++14)
__cpp_deduction_guides	Вывод аргументов шаблона для шаблонов классов	201703L	(C++17)
	CTAD для агрегатов и псевдонимов	201907L	(C++20)
__cpp_delegating_constructors	Делегирование конструкторов	200604L	(C++11)
__cpp_designated_initializers	Назначенный инициализатор	201707L	(C++20)
__cpp_enumerator_attributes	Атрибуты для нумераторов	201411L	(C++17)
__cpp_fold_expressions	Выражения свёртки	201603L	(C++17)
__cpp_generic_lambdas	Общие лямбда-выражения	201304L	(C++14)
	Знакомый синтаксис шаблона для общих лямбд	201707L	(C++20)
__cpp_guaranteed_copy_elision	Гарантированный пропуск копирования за счёт упрощённой категории значений	201606L	(C++17)
__cpp_hex_float	Шестнадцатеричные литералы с плавающей запятой	201603L	(C++17)
__cpp_if_consteval	consteval if	202106L	(C++23)
__cpp_if_constexpr	constexpr if	201606L	(C++17)
__cpp_impl_coroutine	Сопрограммы (поддержка компилятором)	201902L	(C++20)
__cpp_impl_destroying_delete	Уничтожающий оператор delete (поддержка компилятором)	201806L	(C++20)
__cpp_impl_three_way_comparison	Трёхстороннее сравнение (поддержка компилятором)	201907L	(C++20)
__cpp_inheriting_constructors	Наследование конструкторов	200802L	(C++11)
	Переделка наследуемых конструкторов	201511L	(C++17)
__cpp_init_captures	Захват при инициализации лямбда	201304L	(C++14)
	Разрешено расширение пакета в захвате при инициализации лямбда	201803L	(C++20)
__cpp_initializer_lists	Список инициализации и std::initializer_list	200806L	(C++11)
__cpp_inline_variables	Встроенные переменные	201606L	(C++17)
__cpp_lambdas	Лямбда-выражения	200907L	(C++11)
__cpp_modules	Модули	201907L	(C++20)
__cpp_namespace_attributes	Атрибуты для пространств имён	201411L	(C++17)
__cpp_noexcept_function_type	Спецификации исключений сделаны частью системы типов	201510L	(C++17)
__cpp_nontype_template_args	Разрешено константное вычисление для всех аргументов шаблона, не относящиеся к типу	201411L	(C++17)
	Типы классов и типы с плавающей запятой в аргументах шаблона не являющихся типами	201911L	(C++20)
__cpp_nontype_template_parameter_auto	Объявление аргументов шаблона не являющиеся типами с auto	201606L	(C++17)
__cpp_nsdmi	Инициализаторы нестатических элементов данных	200809L	(C++11)
__cpp_range_based_for	Основанный на диапазоне цикл for	200907L	(C++11)
	Цикл for на основе диапазона с разными начальным/конечным типами	201603L	(C++17)
__cpp_raw_strings	Необработанные строковые литералы	200710L	(C++11)
__cpp_ref_qualifiers	Квалификаторы ссылок	200710L	(C++11)
__cpp_return_type_deduction	Вывод типа возвращаемого значения для обычных функций	201304L	(C++14)
__cpp_rvalue_references	Правосторонняя ссылка	200610L	(C++11)
__cpp_size_t_suffix	Литеральные суффиксы для size_t и её знаковой версии	202011L	(C++23)
__cpp_sized_deallocation	Освобождение памяти по размеру	201309L	(C++14)
__cpp_static_assert	static_assert	200410L	(C++11)
	Одно-аргументный static_assert	201411L	(C++17)
__cpp_structured_bindings	Структурные привязки	201606L	(C++17)
__cpp_template_template_args	Соответствие шаблонным аргументам шаблона	201611L	(C++17)
__cpp_threadsafe_static_init	Динамическая инициализация и уничтожение с конкуренцией	200806L	(C++11)
__cpp_unicode_characters	Новые символьные типы (char16_t и char32_t)	200704L	(C++11)
__cpp_unicode_literals	Строковые литералы в Юникоде	200710L	(C++11)
__cpp_user_defined_literals	Пользовательские литералы	200809L	(C++11)
__cpp_using_enum	Using enum	201907L	(C++20)
__cpp_variable_templates	Шаблоны переменных	201304L	(C++14)
__cpp_variadic_templates	Вариативные шаблоны	200704L	(C++11)
__cpp_variadic_using	Расширения пакетов в using-объявлении	201611L	(C++17)

Возможности библиотеки

Следующие макросы определены, если включён заголовок <version> или любой из соответствующих заголовков в таблице ниже. Каждый макрос расширяется в целочисленный литерал, соответствующий году и месяцу, когда соответствующая возможность была включена в рабочий черновик.

Когда возможность значительно изменяется, макрос обновляется соответствующим образом.

Имя макроса	Возможность	Значение	Заголовок	Стд
__cpp_lib_addressof_constexpr	Constexpr std::addressof	201603L	<memory>	(C++17)
__cpp_lib_allocator_traits_is_always_equal	std::allocator_traits::is_always_equal	201411L	<memory> <scoped_allocator> <string> <deque> <forward_list> <list> <vector> <map> <set> <unordered_map> <unordered_set>	(C++17)
__cpp_lib_any	std::any	201606L	<any>	(C++17)
__cpp_lib_apply	std::apply	201603L	<tuple>	(C++17)
__cpp_lib_array_constexpr	Constexpr для std::reverse_iterator, std::move_iterator, std::array и доступа в диапазоне	201603L	<iterator> <array>	(C++17)
	ConstexprIterator; constexpr сравнение для std::array; разные constexpr биты (std::array::fill и другие)	201811L	<iterator> <array>	(C++20)
__cpp_lib_as_const	std::as_const	201510L	<utility>	(C++17)
__cpp_lib_assume_aligned	std::assume_aligned	201811L	<memory>	(C++20)
__cpp_lib_atomic_flag_test	std::atomic_flag::test	201907L	<atomic>	(C++20)
__cpp_lib_atomic_float	Атомарность с плавающей точкой	201711L	<atomic>	(C++20)
__cpp_lib_atomic_is_always_lock_free	constexpr atomic<T>::is_always_lock_free	201603L	<atomic>	(C++17)
__cpp_lib_atomic_lock_free_type_aliases	атомарные целочисленные типы без блокировок (std::atomic_signed_lock_free, std::atomic_unsigned_lock_free)	201907L	<atomic>	(C++20)
__cpp_lib_atomic_ref	std::atomic_ref	201806L	<atomic>	(C++20)
__cpp_lib_atomic_shared_ptr	std::atomic<std::shared_ptr>	201711L	<memory>	(C++20)
__cpp_lib_atomic_value_initialization	Исправление атомарной инициализации (инициализация значения std::atomic по умолчанию)	201911L	<atomic> <memory>	(C++20)
__cpp_lib_atomic_wait	Эффективное std::atomic ожидание	201907L	<atomic>	(C++20)
__cpp_lib_barrier	std::barrier	201907L	<barrier>	(C++20)
__cpp_lib_bind_front	std::bind_front	201907L	<functional>	(C++20)
__cpp_lib_bit_cast	std::bit_cast	201806L	<bit>	(C++20)
__cpp_lib_bitops	Битовые операции	201907L	<bit>	(C++20)
__cpp_lib_bool_constant	std::bool_constant	201505L	<type_traits>	(C++17)
__cpp_lib_bounded_array_traits	std::is_bounded_array, std::is_unbounded_array	201902L	<type_traits>	(C++20)
__cpp_lib_boyer_moore_searcher	Алгоритмы поиска	201603L	<functional>	(C++17)
__cpp_lib_byte	std::byte	201603L	<cstddef>	(C++17)
__cpp_lib_char8_t	Библиотечная поддержка для char8_t	201907L	<atomic> <filesystem> <istream> <limits> <locale> <ostream> <string> <string_view>	(C++20)
__cpp_lib_chrono	Функции округления для std::chrono::duration и std::chrono::time_point	201510L	<chrono>	(C++17)
	Constexpr для всех функций-элементов std::chrono::duration и std::chrono::time_point	201611L	<chrono>	(C++17)
	Календари и Часовые Пояса	201907L	<chrono>	(C++20)
__cpp_lib_chrono_udls	Определяемые пользователем литералы для типов времени	201304L	<chrono>	(C++14)
__cpp_lib_clamp	std::clamp	201603L	<algorithm>	(C++17)
__cpp_lib_complex_udls	Пользовательские литералы для std::complex	201309L	<complex>	(C++14)
__cpp_lib_concepts	Концепты стандартной библиотеки	202002L	<concepts>	(C++20)
__cpp_lib_constexpr_algorithms	Constexpr для алгоритмов	201806L	<algorithm>	(C++20)
__cpp_lib_constexpr_complex	Constexpr для std::complex	201711L	<complex>	(C++20)
__cpp_lib_constexpr_dynamic_alloc	Constexpr для std::allocator и связанных утилит	201907L	<memory>	(C++20)
__cpp_lib_constexpr_functional	Разные constexpr биты (std::default_searcher); constexpr INVOKE	201907L	<functional>	(C++20)
__cpp_lib_constexpr_iterator	Разные constexpr биты (std::insert_iterator и другие)	201811L	<iterator>	(C++20)
__cpp_lib_constexpr_memory	Constexpr в std::pointer_traits	201811L	<memory>	(C++20)
__cpp_lib_constexpr_numeric	Constexpr для числовых алгоритмов	201911L	<numeric>	(C++20)
__cpp_lib_constexpr_string	Constexpr для std::string	201907L	<string>	(C++20)
__cpp_lib_constexpr_string_view	Разные constexpr биты (std::string_view::copy)	201811L	<string_view>	(C++20)
__cpp_lib_constexpr_tuple	Разные constexpr биты (std::tuple::operator= и другие)	201811L	<tuple>	(C++20)
__cpp_lib_constexpr_typeinfo	Constexpr для std::type_info::operator==	202106L	<typeinfo>	(C++23)
__cpp_lib_constexpr_utility	Разные constexpr биты (std::pair::operator= и другие)	201811L	<utility>	(C++20)
__cpp_lib_constexpr_vector	Constexpr для std::vector	201907L	<vector>	(C++20)
__cpp_lib_coroutine	Сопрограммы (поддержка библиотекой)	201902L	<coroutine>	(C++20)
__cpp_lib_destroying_delete	Уничтожение operator delete (поддержка библиотекой)	201806L	<new>	(C++20)
__cpp_lib_enable_shared_from_this	Более точная спецификация std::enable_shared_from_this	201603L	<memory>	(C++17)
__cpp_lib_endian	std::endian	201907L	<bit>	(C++20)
__cpp_lib_erase_if	Равномерная очистка контейнера	202002L	<string> <deque> <forward_list> <list> <vector> <map> <set> <unordered_map> <unordered_set>	(C++20)
__cpp_lib_exchange_function	std::exchange	201304L	<utility>	(C++14)
__cpp_lib_execution	Политики исполнения	201603L	<execution>	(C++17)
	std::execution::unsequenced_policy	201902L	<execution>	(C++20)
__cpp_lib_filesystem	Библиотека файловой системы	201703L	<filesystem>	(C++17)
__cpp_lib_format	Форматирование текста	201907L	<format>	(C++20)
__cpp_lib_gcd_lcm	std::gcd, std::lcm	201606L	<numeric>	(C++17)
__cpp_lib_generic_associative_lookup	Поиск гетерогенным сравнением в [[cpp/container#Ассоциативные контейнеры|ассоциативных контейнерах	201304L	<map> <set>	(C++14)
__cpp_lib_generic_unordered_lookup	Поиск гетерогенным сравнением в ассоциативных контейнерах	201811L	<unordered_map> <unordered_set>	(C++20)
__cpp_lib_hardware_interference_size	[[constexpr std::hardware_{constructive, destructive}_interference_size|hardware_destructive_interference_size|constexpr std::hardware_{constructive, destructive}_interference_size]]]]	201703L	<new>	(C++17)
__cpp_lib_has_unique_object_representations	std::has_unique_object_representations	201606L	<type_traits>	(C++17)
__cpp_lib_hypot	3-аргументная перегрузка std::hypot	201603L	<cmath>	(C++17)
__cpp_lib_incomplete_container_elements	Минимальная поддержка неполных типов для стандартных контейнеров	201505L	<forward_list> <list> <vector>	(C++17)
__cpp_lib_int_pow2	Интегральные операции степени двойки (std::has_single_bit, std::bit_ceil, std::bit_floor, std::bit_length)	202002L	<bit>	(C++20)
__cpp_lib_integer_comparison_functions	Целочисленные функции сравнения	202002L	<utility>	(C++20)
__cpp_lib_integer_sequence	Целочисленные последовательности времени компиляции	201304L	<utility>	(C++14)
__cpp_lib_integral_constant_callable	std::integral_constant::operator()	201304L	<type_traits>	(C++14)
__cpp_lib_interpolate	std::lerp, std::midpoint	201902L	<cmath> <numeric>	(C++20)
__cpp_lib_invoke	std::invoke	201411L	<functional>	(C++17)
__cpp_lib_invoke_r	std::invoke_r	202106L	<functional>	(C++23)
__cpp_lib_is_aggregate	std::is_aggregate	201703L	<type_traits>	(C++17)
__cpp_lib_is_constant_evaluated	std::is_constant_evaluated	201811L	<type_traits>	(C++20)
__cpp_lib_is_final	std::is_final	201402L	<type_traits>	(C++14)
__cpp_lib_is_invocable	std::is_invocable, std::invoke_result	201703L	<type_traits>	(C++17)
__cpp_lib_is_layout_compatible	std::is_layout_compatible	201907L	<type_traits>	(C++20)
__cpp_lib_is_nothrow_convertible	std::is_nothrow_convertible	201806L	<type_traits>	(C++20)
__cpp_lib_is_null_pointer	std::is_null_pointer	201309L	<type_traits>	(C++14)
__cpp_lib_is_pointer_interconvertible	Свойства указателя-взаимоконвертируемости	201907L	<type_traits>	(C++20)
__cpp_lib_is_scoped_enum	std::is_scoped_enum	202011L	<type_traits>	(C++23)
__cpp_lib_is_swappable	[nothrow-]замена свойств	201603L	<type_traits>	(C++17)
__cpp_lib_jthread	Стоповый токен и присоединяющаяся ветвь	201911L	<stop_token> <thread>	(C++20)
__cpp_lib_latch	std::latch	201907L	<latch>	(C++20)
__cpp_lib_launder	Основной Выпуск 1776: Обмен объектов класса, содержащих ссылочные элементы (std::launder)	201606L	<new>	(C++17)
__cpp_lib_list_remove_return_type	Изменение типа возврата remove(), remove_if() и unique() элементов объектов std::forward_list и std::list	201806L	<forward_list> <list>	(C++20)
__cpp_lib_logical_traits	Свойства типа логического оператора	201510L	<type_traits>	(C++17)
__cpp_lib_make_from_tuple	std::make_from_tuple()	201606L	<tuple>	(C++17)
__cpp_lib_make_reverse_iterator	std::make_reverse_iterator	201402L	<iterator>	(C++14)
__cpp_lib_make_unique	std::make_unique	201304L	<memory>	(C++14)
__cpp_lib_map_try_emplace	std::map::try_emplace, std::map::insert_or_assign	201411L	<map>	(C++17)
__cpp_lib_math_constants	Математические константы	201907L	<numbers>	(C++20)
__cpp_lib_math_special_functions	Специальные математические функции для C++17	201603L	<cmath>	(C++17)
__cpp_lib_memory_resource	std::pmr::memory_resource	201603L	<memory_resource>	(C++17)
__cpp_lib_node_extract	Объединение карт и наборов (std::map::extract, std::map::merge, std::map::insert(node_type) и т.д.)	201606L	<map> <set> <unordered_map> <unordered_set>	(C++17)
__cpp_lib_nonmember_container_access	std::size(), std::data() и std::empty()	201411L	<iterator> <array> <deque> <forward_list> <list> <map> <regex> <set> <string> <unordered_map> <unordered_set> <vector>	(C++17)
__cpp_lib_not_fn	std::not_fn()	201603L	<functional>	(C++17)
__cpp_lib_null_iterators	Null LegacyForwardIterators	201304L	<iterator>	(C++14)
__cpp_lib_optional	std::optional	201606L	<optional>	(C++17)
__cpp_lib_parallel_algorithm	Параллельные алгоритмы	201603L	<algorithm> <numeric>	(C++17)
__cpp_lib_polymorphic_allocator	std::polymorphic_allocator<> как тип словаря	201902L	<memory_resource>	(C++20)
__cpp_lib_quoted_string_io	std::quoted	201304L	<iomanip>	(C++14)
__cpp_lib_ranges	Библиотека диапазонов и ограниченные алгоритмы	201911L	<algorithm> <functional> <iterator> <memory> <ranges>	(C++20)
__cpp_lib_raw_memory_algorithms	Расширение инструментов управления памятью	201606L	<memory>	(C++17)
__cpp_lib_remove_cvref	std::remove_cvref	201711L	<type_traits>	(C++20)
__cpp_lib_result_of_sfinae	std::result_of и SFINAE	201210L	<type_traits> <functional>	(C++14)
__cpp_lib_robust_nonmodifying_seq_ops	Повышение устойчивости последовательности немодифицирующих операций (двухдиапазонные перегрузки для std::mismatch, std::equal и std::is_permutation)	201304L	<algorithm>	(C++14)
__cpp_lib_sample	std::sample	201603L	<algorithm>	(C++17)
__cpp_lib_scoped_lock	std::scoped_lock	201703L	<mutex>	(C++17)
__cpp_lib_semaphore	std::counting_semaphore, std::binary_semaphore	201907L	<semaphore>	(C++20)
__cpp_lib_shared_mutex	std::shared_mutex (безвременной)	201505L	<shared_mutex>	(C++17)
__cpp_lib_shared_ptr_arrays	std::shared_ptr<T[]>	201611L	<memory>	(C++17)
	Поддержка массива std::make_shared	201707L	<memory>	(C++20)
__cpp_lib_shared_ptr_weak_type	shared_ptr::weak_type	201606L	<memory>	(C++17)
__cpp_lib_shared_timed_mutex	std::shared_timed_mutex	201402L	<shared_mutex>	(C++14)
__cpp_lib_shift	std::shift_left и std::shift_right	201806L	<algorithm>	(C++20)
__cpp_lib_smart_ptr_for_overwrite	Создание умного указателя с инициализацией по умолчанию (std::allocate_shared_for_overwrite, std::make_shared_for_overwrite, std::make_unique_for_overwrite)	202002L	<memory>	(C++20)
__cpp_lib_source_location	Сбор информации об исходном коде (std::source_location)	201907L	<source_location>	(C++20)
__cpp_lib_span	std::span	202002L	<span>	(C++20)
__cpp_lib_ssize	std::ssize и беззнаковый std::span::size	201902L	<iterator>	(C++20)
__cpp_lib_stacktrace	Библиотека Stacktrace	202011L	<stacktrace>	(C++23)
__cpp_lib_starts_ends_with	Проверка префикса и суффикса строки (starts_with() и ends_with() для std::string и std::string_view)	201711L	<string> <string_view>	(C++20)
__cpp_lib_stdatomic_h	Заголовок совместимости для атомарных операций C	202011L	<stdatomic.h>	(C++23)
__cpp_lib_string_contains	Функции contains объектов std::basic_string и std::basic_string_view	202011L	<string> <string_view>	(C++23)
__cpp_lib_string_udls	Пользовательские литералы для строковых типов	201304L	<string>	(C++14)
__cpp_lib_string_view	std::string_view	201606L	<string> <string_view>	(C++17)
	ConstexprIterator	201803L	<string> <string_view>	(C++20)
__cpp_lib_syncbuf	Синхронизированный буферизированный ostream (std::syncbuf, std::osyncstream) и манипуляторы	201803L	<syncstream>	(C++20)
__cpp_lib_three_way_comparison	Трёхстороннее сравнение (поддержка библиотекой); добавление трёхстороннего сравнения в библиотеку	201907L	<compare>	(C++20)
__cpp_lib_to_address	Утилита для преобразования указателя в сырой указатель (std::to_address)	201711L	<memory>	(C++20)
__cpp_lib_to_array	std::to_array	201907L	<array>	(C++20)
__cpp_lib_to_chars	Элементарные преобразования строк (std::to_chars, std::from_chars)	201611L	<charconv>	(C++17)
__cpp_lib_to_underlying	std::to_underlying	2XXXXXL	<utility>	(C++23)
__cpp_lib_transformation_trait_aliases	Шаблоны псевдонимов для TransformationTraits	201304L	<type_traits>	(C++14)
__cpp_lib_transparent_operators	Прозрачные операторы функторы (std::less<> и другие)	201210L	<functional>	(C++14)
	Прозрачный std::owner_less (std::owner_less<void>)	201510L	<memory> <functional>	(C++17)
__cpp_lib_tuple_element_t	std::tuple_element_t	201402L	<tuple>	(C++14)
__cpp_lib_tuples_by_type	Адресация кортежей по типу	201304L	<tuple> <utility>	(C++14)
__cpp_lib_type_identity	std::type_identity	201806L	<type_traits>	(C++20)
__cpp_lib_type_trait_variable_templates	Шаблоны переменных свойств типов (std::is_void_v, etc)	201510L	<type_traits>	(C++17)
__cpp_lib_uncaught_exceptions	std::uncaught_exceptions	201411L	<exception>	(C++17)
__cpp_lib_unordered_map_try_emplace	std::unordered_map::try_emplace, std::unordered_map::insert_or_assign	201411L	<unordered_map>	(C++17)
__cpp_lib_unwrap_ref	std::unwrap_ref_decay и std::unwrap_reference	201811L	<functional>	(C++20)
__cpp_lib_variant	std::variant: типобезопасное объединение для C++17	201606L	<variant>	(C++17)
__cpp_lib_void_t	std::void_t	201411L	<type_traits>	(C++17)

Пример

Запустить этот код

#ifdef __has_include                            // Проверяет существует ли __has_include
#  if __has_include(<optional>)                 // Проверяет наличие стандартной
#    include <optional>                         // библиотеки
#  elif __has_include(<experimental/optional>)  // Проверяет наличие экспериментальной
#    include <experimental/optional>            // версии
#  elif __has_include(<boost/optional.hpp>)     // Пробует с внешней библиотекой
#    include <boost/optional.hpp>
#  else                                         // Ничего не найдено
#     error "Отсутствует <optional>"
#  endif
#endif
 
#ifdef __has_cpp_attribute                      // Проверяет существует ли
                                                // __has_cpp_attribute
#  if __has_cpp_attribute(deprecated)           // Проверяет атрибут
#    define DEPRECATED(msg) [[deprecated(msg)]]
#  endif
#endif
#ifndef DEPRECATED
#    define DEPRECATED(msg)
#endif
 
DEPRECATED("foo() устарела") void foo();
 
#if __cpp_constexpr >= 201304              // Проверяет конкретную версию функциональности
#  define CONSTEXPR constexpr
#else
#  define CONSTEXPR inline
#endif
 
CONSTEXPR int bar(unsigned i)
{
#if __cpp_binary_literals                  // Проверяет наличие функциональности
    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()
{
}

Пример

Следующая программа выводит данные о функциях и атрибутах компилятора C++.

Запустить этот код

#if __cplusplus < 201100
#  ошибка "Требуется C++11 или лучше"
#endif
 
#include <algorithm>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <string>
 
#ifdef __has_include
# if __has_include(<version>)
#   include <version>
# endif
#endif
 
#define COMPILER_FEATURE_VALUE(value) #value
#define COMPILER_FEATURE_ENTRY(name) { #name, COMPILER_FEATURE_VALUE(name) },
 
#ifdef __has_cpp_attribute
# define COMPILER_ATTRIBUTE_VALUE_AS_STRING(s) #s
# define COMPILER_ATTRIBUTE_AS_NUMBER(x) COMPILER_ATTRIBUTE_VALUE_AS_STRING(x)
# define COMPILER_ATTRIBUTE_ENTRY(attr) \
  { #attr, COMPILER_ATTRIBUTE_AS_NUMBER(__has_cpp_attribute(attr)) },
#else
# define COMPILER_ATTRIBUTE_ENTRY(attr) { #attr, "_" },
#endif
 
// Измените эти параметры, чтобы вывести только необходимую информацию.
static struct PrintOptions {
    constexpr static bool titles               = 1;
    constexpr static bool attributes           = 1;
    constexpr static bool general_features     = 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 sorted_by_value      = 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;
}   print;
 
struct CompilerFeature {
    CompilerFeature(const char* name = nullptr, const char* value = nullptr)
        : name(name), value(value) {}
    const char* name; const char* value;
};
 
static CompilerFeature cxx[] = {
COMPILER_FEATURE_ENTRY(__cplusplus)
COMPILER_FEATURE_ENTRY(__cpp_exceptions)
COMPILER_FEATURE_ENTRY(__cpp_rtti)
#if 0
COMPILER_FEATURE_ENTRY(__GNUC__)
COMPILER_FEATURE_ENTRY(__GNUC_MINOR__)
COMPILER_FEATURE_ENTRY(__GNUC_PATCHLEVEL__)
COMPILER_FEATURE_ENTRY(__GNUG__)
COMPILER_FEATURE_ENTRY(__clang__)
COMPILER_FEATURE_ENTRY(__clang_major__)
COMPILER_FEATURE_ENTRY(__clang_minor__)
COMPILER_FEATURE_ENTRY(__clang_patchlevel__)
#endif
};
static CompilerFeature cxx11[] = {
COMPILER_FEATURE_ENTRY(__cpp_alias_templates)
COMPILER_FEATURE_ENTRY(__cpp_attributes)
COMPILER_FEATURE_ENTRY(__cpp_constexpr)
COMPILER_FEATURE_ENTRY(__cpp_decltype)
COMPILER_FEATURE_ENTRY(__cpp_delegating_constructors)
COMPILER_FEATURE_ENTRY(__cpp_inheriting_constructors)
COMPILER_FEATURE_ENTRY(__cpp_initializer_lists)
COMPILER_FEATURE_ENTRY(__cpp_lambdas)
COMPILER_FEATURE_ENTRY(__cpp_nsdmi)
COMPILER_FEATURE_ENTRY(__cpp_range_based_for)
COMPILER_FEATURE_ENTRY(__cpp_raw_strings)
COMPILER_FEATURE_ENTRY(__cpp_ref_qualifiers)
COMPILER_FEATURE_ENTRY(__cpp_rvalue_references)
COMPILER_FEATURE_ENTRY(__cpp_static_assert)
COMPILER_FEATURE_ENTRY(__cpp_threadsafe_static_init)
COMPILER_FEATURE_ENTRY(__cpp_unicode_characters)
COMPILER_FEATURE_ENTRY(__cpp_unicode_literals)
COMPILER_FEATURE_ENTRY(__cpp_user_defined_literals)
COMPILER_FEATURE_ENTRY(__cpp_variadic_templates)
};
static CompilerFeature cxx14[] = {
COMPILER_FEATURE_ENTRY(__cpp_aggregate_nsdmi)
COMPILER_FEATURE_ENTRY(__cpp_binary_literals)
COMPILER_FEATURE_ENTRY(__cpp_constexpr)
COMPILER_FEATURE_ENTRY(__cpp_decltype_auto)
COMPILER_FEATURE_ENTRY(__cpp_generic_lambdas)
COMPILER_FEATURE_ENTRY(__cpp_init_captures)
COMPILER_FEATURE_ENTRY(__cpp_return_type_deduction)
COMPILER_FEATURE_ENTRY(__cpp_sized_deallocation)
COMPILER_FEATURE_ENTRY(__cpp_variable_templates)
};
static CompilerFeature cxx14lib[] = {
COMPILER_FEATURE_ENTRY(__cpp_lib_chrono_udls)
COMPILER_FEATURE_ENTRY(__cpp_lib_complex_udls)
COMPILER_FEATURE_ENTRY(__cpp_lib_exchange_function)
COMPILER_FEATURE_ENTRY(__cpp_lib_generic_associative_lookup)
COMPILER_FEATURE_ENTRY(__cpp_lib_integer_sequence)
COMPILER_FEATURE_ENTRY(__cpp_lib_integral_constant_callable)
COMPILER_FEATURE_ENTRY(__cpp_lib_is_final)
COMPILER_FEATURE_ENTRY(__cpp_lib_is_null_pointer)
COMPILER_FEATURE_ENTRY(__cpp_lib_make_reverse_iterator)
COMPILER_FEATURE_ENTRY(__cpp_lib_make_unique)
COMPILER_FEATURE_ENTRY(__cpp_lib_null_iterators)
COMPILER_FEATURE_ENTRY(__cpp_lib_quoted_string_io)
COMPILER_FEATURE_ENTRY(__cpp_lib_result_of_sfinae)
COMPILER_FEATURE_ENTRY(__cpp_lib_robust_nonmodifying_seq_ops)
COMPILER_FEATURE_ENTRY(__cpp_lib_shared_timed_mutex)
COMPILER_FEATURE_ENTRY(__cpp_lib_string_udls)
COMPILER_FEATURE_ENTRY(__cpp_lib_transformation_trait_aliases)
COMPILER_FEATURE_ENTRY(__cpp_lib_transparent_operators)
COMPILER_FEATURE_ENTRY(__cpp_lib_tuple_element_t)
COMPILER_FEATURE_ENTRY(__cpp_lib_tuples_by_type)
};
 
static CompilerFeature cxx17[] = {
COMPILER_FEATURE_ENTRY(__cpp_aggregate_bases)
COMPILER_FEATURE_ENTRY(__cpp_aligned_new)
COMPILER_FEATURE_ENTRY(__cpp_capture_star_this)
COMPILER_FEATURE_ENTRY(__cpp_constexpr)
COMPILER_FEATURE_ENTRY(__cpp_deduction_guides)
COMPILER_FEATURE_ENTRY(__cpp_enumerator_attributes)
COMPILER_FEATURE_ENTRY(__cpp_fold_expressions)
COMPILER_FEATURE_ENTRY(__cpp_guaranteed_copy_elision)
COMPILER_FEATURE_ENTRY(__cpp_hex_float)
COMPILER_FEATURE_ENTRY(__cpp_if_constexpr)
COMPILER_FEATURE_ENTRY(__cpp_inheriting_constructors)
COMPILER_FEATURE_ENTRY(__cpp_inline_variables)
COMPILER_FEATURE_ENTRY(__cpp_namespace_attributes)
COMPILER_FEATURE_ENTRY(__cpp_noexcept_function_type)
COMPILER_FEATURE_ENTRY(__cpp_nontype_template_args)
COMPILER_FEATURE_ENTRY(__cpp_nontype_template_parameter_auto)
COMPILER_FEATURE_ENTRY(__cpp_range_based_for)
COMPILER_FEATURE_ENTRY(__cpp_static_assert)
COMPILER_FEATURE_ENTRY(__cpp_structured_bindings)
COMPILER_FEATURE_ENTRY(__cpp_template_template_args)
COMPILER_FEATURE_ENTRY(__cpp_variadic_using)
};
static CompilerFeature cxx17lib[] = {
COMPILER_FEATURE_ENTRY(__cpp_lib_addressof_constexpr)
COMPILER_FEATURE_ENTRY(__cpp_lib_allocator_traits_is_always_equal)
COMPILER_FEATURE_ENTRY(__cpp_lib_any)
COMPILER_FEATURE_ENTRY(__cpp_lib_apply)
COMPILER_FEATURE_ENTRY(__cpp_lib_array_constexpr)
COMPILER_FEATURE_ENTRY(__cpp_lib_as_const)
COMPILER_FEATURE_ENTRY(__cpp_lib_atomic_is_always_lock_free)
COMPILER_FEATURE_ENTRY(__cpp_lib_bool_constant)
COMPILER_FEATURE_ENTRY(__cpp_lib_boyer_moore_searcher)
COMPILER_FEATURE_ENTRY(__cpp_lib_byte)
COMPILER_FEATURE_ENTRY(__cpp_lib_chrono)
COMPILER_FEATURE_ENTRY(__cpp_lib_clamp)
COMPILER_FEATURE_ENTRY(__cpp_lib_enable_shared_from_this)
COMPILER_FEATURE_ENTRY(__cpp_lib_execution)
COMPILER_FEATURE_ENTRY(__cpp_lib_filesystem)
COMPILER_FEATURE_ENTRY(__cpp_lib_gcd_lcm)
COMPILER_FEATURE_ENTRY(__cpp_lib_hardware_interference_size)
COMPILER_FEATURE_ENTRY(__cpp_lib_has_unique_object_representations)
COMPILER_FEATURE_ENTRY(__cpp_lib_hypot)
COMPILER_FEATURE_ENTRY(__cpp_lib_incomplete_container_elements)
COMPILER_FEATURE_ENTRY(__cpp_lib_invoke)
COMPILER_FEATURE_ENTRY(__cpp_lib_is_aggregate)
COMPILER_FEATURE_ENTRY(__cpp_lib_is_invocable)
COMPILER_FEATURE_ENTRY(__cpp_lib_is_swappable)
COMPILER_FEATURE_ENTRY(__cpp_lib_launder)
COMPILER_FEATURE_ENTRY(__cpp_lib_logical_traits)
COMPILER_FEATURE_ENTRY(__cpp_lib_make_from_tuple)
COMPILER_FEATURE_ENTRY(__cpp_lib_map_try_emplace)
COMPILER_FEATURE_ENTRY(__cpp_lib_math_special_functions)
COMPILER_FEATURE_ENTRY(__cpp_lib_memory_resource)
COMPILER_FEATURE_ENTRY(__cpp_lib_node_extract)
COMPILER_FEATURE_ENTRY(__cpp_lib_nonmember_container_access)
COMPILER_FEATURE_ENTRY(__cpp_lib_not_fn)
COMPILER_FEATURE_ENTRY(__cpp_lib_optional)
COMPILER_FEATURE_ENTRY(__cpp_lib_parallel_algorithm)
COMPILER_FEATURE_ENTRY(__cpp_lib_raw_memory_algorithms)
COMPILER_FEATURE_ENTRY(__cpp_lib_sample)
COMPILER_FEATURE_ENTRY(__cpp_lib_scoped_lock)
COMPILER_FEATURE_ENTRY(__cpp_lib_shared_mutex)
COMPILER_FEATURE_ENTRY(__cpp_lib_shared_ptr_arrays)
COMPILER_FEATURE_ENTRY(__cpp_lib_shared_ptr_weak_type)
COMPILER_FEATURE_ENTRY(__cpp_lib_string_view)
COMPILER_FEATURE_ENTRY(__cpp_lib_to_chars)
COMPILER_FEATURE_ENTRY(__cpp_lib_transparent_operators)
COMPILER_FEATURE_ENTRY(__cpp_lib_type_trait_variable_templates)
COMPILER_FEATURE_ENTRY(__cpp_lib_uncaught_exceptions)
COMPILER_FEATURE_ENTRY(__cpp_lib_unordered_map_try_emplace)
COMPILER_FEATURE_ENTRY(__cpp_lib_variant)
COMPILER_FEATURE_ENTRY(__cpp_lib_void_t)
};
 
static CompilerFeature cxx20[] = {
COMPILER_FEATURE_ENTRY(__cpp_aggregate_paren_init)
COMPILER_FEATURE_ENTRY(__cpp_char8_t)
COMPILER_FEATURE_ENTRY(__cpp_concepts)
COMPILER_FEATURE_ENTRY(__cpp_conditional_explicit)
COMPILER_FEATURE_ENTRY(__cpp_consteval)
COMPILER_FEATURE_ENTRY(__cpp_constexpr)
COMPILER_FEATURE_ENTRY(__cpp_constexpr_dynamic_alloc)
COMPILER_FEATURE_ENTRY(__cpp_constexpr_in_decltype)
COMPILER_FEATURE_ENTRY(__cpp_constinit)
COMPILER_FEATURE_ENTRY(__cpp_deduction_guides)
COMPILER_FEATURE_ENTRY(__cpp_designated_initializers)
COMPILER_FEATURE_ENTRY(__cpp_generic_lambdas)
COMPILER_FEATURE_ENTRY(__cpp_impl_coroutine)
COMPILER_FEATURE_ENTRY(__cpp_impl_destroying_delete)
COMPILER_FEATURE_ENTRY(__cpp_impl_three_way_comparison)
COMPILER_FEATURE_ENTRY(__cpp_init_captures)
COMPILER_FEATURE_ENTRY(__cpp_modules)
COMPILER_FEATURE_ENTRY(__cpp_nontype_template_args)
COMPILER_FEATURE_ENTRY(__cpp_using_enum)
};
static CompilerFeature cxx20lib[] = {
COMPILER_FEATURE_ENTRY(__cpp_lib_array_constexpr)
COMPILER_FEATURE_ENTRY(__cpp_lib_assume_aligned)
COMPILER_FEATURE_ENTRY(__cpp_lib_atomic_flag_test)
COMPILER_FEATURE_ENTRY(__cpp_lib_atomic_float)
COMPILER_FEATURE_ENTRY(__cpp_lib_atomic_lock_free_type_aliases)
COMPILER_FEATURE_ENTRY(__cpp_lib_atomic_ref)
COMPILER_FEATURE_ENTRY(__cpp_lib_atomic_shared_ptr)
COMPILER_FEATURE_ENTRY(__cpp_lib_atomic_value_initialization)
COMPILER_FEATURE_ENTRY(__cpp_lib_atomic_wait)
COMPILER_FEATURE_ENTRY(__cpp_lib_barrier)
COMPILER_FEATURE_ENTRY(__cpp_lib_bind_front)
COMPILER_FEATURE_ENTRY(__cpp_lib_bit_cast)
COMPILER_FEATURE_ENTRY(__cpp_lib_bitops)
COMPILER_FEATURE_ENTRY(__cpp_lib_bounded_array_traits)
COMPILER_FEATURE_ENTRY(__cpp_lib_char8_t)
COMPILER_FEATURE_ENTRY(__cpp_lib_chrono)
COMPILER_FEATURE_ENTRY(__cpp_lib_concepts)
COMPILER_FEATURE_ENTRY(__cpp_lib_constexpr_algorithms)
COMPILER_FEATURE_ENTRY(__cpp_lib_constexpr_complex)
COMPILER_FEATURE_ENTRY(__cpp_lib_constexpr_dynamic_alloc)
COMPILER_FEATURE_ENTRY(__cpp_lib_constexpr_functional)
COMPILER_FEATURE_ENTRY(__cpp_lib_constexpr_iterator)
COMPILER_FEATURE_ENTRY(__cpp_lib_constexpr_memory)
COMPILER_FEATURE_ENTRY(__cpp_lib_constexpr_numeric)
COMPILER_FEATURE_ENTRY(__cpp_lib_constexpr_string)
COMPILER_FEATURE_ENTRY(__cpp_lib_constexpr_string_view)
COMPILER_FEATURE_ENTRY(__cpp_lib_constexpr_tuple)
COMPILER_FEATURE_ENTRY(__cpp_lib_constexpr_utility)
COMPILER_FEATURE_ENTRY(__cpp_lib_constexpr_vector)
COMPILER_FEATURE_ENTRY(__cpp_lib_coroutine)
COMPILER_FEATURE_ENTRY(__cpp_lib_destroying_delete)
COMPILER_FEATURE_ENTRY(__cpp_lib_endian)
COMPILER_FEATURE_ENTRY(__cpp_lib_erase_if)
COMPILER_FEATURE_ENTRY(__cpp_lib_execution)
COMPILER_FEATURE_ENTRY(__cpp_lib_format)
COMPILER_FEATURE_ENTRY(__cpp_lib_generic_unordered_lookup)
COMPILER_FEATURE_ENTRY(__cpp_lib_int_pow2)
COMPILER_FEATURE_ENTRY(__cpp_lib_integer_comparison_functions)
COMPILER_FEATURE_ENTRY(__cpp_lib_interpolate)
COMPILER_FEATURE_ENTRY(__cpp_lib_is_constant_evaluated)
COMPILER_FEATURE_ENTRY(__cpp_lib_is_layout_compatible)
COMPILER_FEATURE_ENTRY(__cpp_lib_is_nothrow_convertible)
COMPILER_FEATURE_ENTRY(__cpp_lib_is_pointer_interconvertible)
COMPILER_FEATURE_ENTRY(__cpp_lib_jthread)
COMPILER_FEATURE_ENTRY(__cpp_lib_latch)
COMPILER_FEATURE_ENTRY(__cpp_lib_list_remove_return_type)
COMPILER_FEATURE_ENTRY(__cpp_lib_math_constants)
COMPILER_FEATURE_ENTRY(__cpp_lib_polymorphic_allocator)
COMPILER_FEATURE_ENTRY(__cpp_lib_ranges)
COMPILER_FEATURE_ENTRY(__cpp_lib_remove_cvref)
COMPILER_FEATURE_ENTRY(__cpp_lib_semaphore)
COMPILER_FEATURE_ENTRY(__cpp_lib_shared_ptr_arrays)
COMPILER_FEATURE_ENTRY(__cpp_lib_shift)
COMPILER_FEATURE_ENTRY(__cpp_lib_smart_ptr_for_overwrite)
COMPILER_FEATURE_ENTRY(__cpp_lib_source_location)
COMPILER_FEATURE_ENTRY(__cpp_lib_span)
COMPILER_FEATURE_ENTRY(__cpp_lib_ssize)
COMPILER_FEATURE_ENTRY(__cpp_lib_starts_ends_with)
COMPILER_FEATURE_ENTRY(__cpp_lib_string_view)
COMPILER_FEATURE_ENTRY(__cpp_lib_syncbuf)
COMPILER_FEATURE_ENTRY(__cpp_lib_three_way_comparison)
COMPILER_FEATURE_ENTRY(__cpp_lib_to_address)
COMPILER_FEATURE_ENTRY(__cpp_lib_to_array)
COMPILER_FEATURE_ENTRY(__cpp_lib_type_identity)
COMPILER_FEATURE_ENTRY(__cpp_lib_unwrap_ref)
};
 
static CompilerFeature cxx23[] = {
// Продолжить Заполнять
COMPILER_FEATURE_ENTRY(__cpp_if_consteval)
COMPILER_FEATURE_ENTRY(__cpp_size_t_suffix)
};
// Продолжить Заполнять
static CompilerFeature cxx23lib[] = {
COMPILER_FEATURE_ENTRY(__cpp_lib_constexpr_typeinfo)
COMPILER_FEATURE_ENTRY(__cpp_lib_invoke_r)
COMPILER_FEATURE_ENTRY(__cpp_lib_is_scoped_enum)
COMPILER_FEATURE_ENTRY(__cpp_lib_stacktrace)
COMPILER_FEATURE_ENTRY(__cpp_lib_stdatomic_h)
COMPILER_FEATURE_ENTRY(__cpp_lib_string_contains)
};
 
static CompilerFeature attributes[] = {
COMPILER_ATTRIBUTE_ENTRY(carries_dependency)
COMPILER_ATTRIBUTE_ENTRY(deprecated)
COMPILER_ATTRIBUTE_ENTRY(fallthrough)
COMPILER_ATTRIBUTE_ENTRY(likely)
COMPILER_ATTRIBUTE_ENTRY(maybe_unused)
COMPILER_ATTRIBUTE_ENTRY(nodiscard)
COMPILER_ATTRIBUTE_ENTRY(noreturn)
COMPILER_ATTRIBUTE_ENTRY(no_unique_address)
COMPILER_ATTRIBUTE_ENTRY(unlikely)
};
 
constexpr bool is_feature_supported(const CompilerFeature& x) {
    return x.value[0] != '_' && x.value[0] != '0' ;
}
 
inline void print_compiler_feature(const CompilerFeature& x) {
    constexpr static int max_name_length = 44; //< При необходимости обновите
    std::string value{ is_feature_supported(x) ? x.value : "------" };
    if (value.back() == 'L') value.pop_back(); //~ 201603L -> 201603
    // value.insert(4, 1, '-'); //~ 201603 -> 2016-03
    if ( (print.supported_features && is_feature_supported(x))
        or (print.unsupported_features && !is_feature_supported(x))) {
            std::cout << std::left << std::setw(max_name_length)
                      << x.name << " " << value << '\n';
    }
}
 
template<size_t N>
inline void show(char const* title, CompilerFeature (&features)[N]) {
    if (print.titles) {
        std::cout << '\n' << std::left << title << '\n';
    }
    if (print.sorted_by_value) {
        std::sort(std::begin(features), std::end(features),
            [](CompilerFeature const& lhs, CompilerFeature const& rhs) {
                return std::strcmp(lhs.value, rhs.value) < 0;
            });
    }
    for (const CompilerFeature& x : features) {
        print_compiler_feature(x);
    }
}
 
int main() {
    if (print.general_features) show("C++ ОСНОВЫ", cxx);
    if (print.cxx11 && print.core_features) show("C++11 ЯДРО".     , cxx11);
    if (print.cxx14 && print.core_features) show("C++14 ЯДРО".     , cxx14);
    if (print.cxx14 && print.lib_features ) show("C++14 БИБЛИОТЕКА", cxx14lib);
    if (print.cxx17 && print.core_features) show("C++17 ЯДРО"      , cxx17);
    if (print.cxx17 && print.lib_features ) show("C++17 БИБЛИОТЕКА", cxx17lib);
    if (print.cxx20 && print.core_features) show("C++20 ЯДРО"      , cxx20);
    if (print.cxx20 && print.lib_features ) show("C++20 БИБЛИОТЕКА", cxx20lib);
    if (print.cxx23 && print.core_features) show("C++23 ЯДРО"      , cxx23);
    if (print.cxx23 && print.lib_features ) show("C++23 БИБЛИОТЕКА", cxx23lib);
    if (print.attributes) show("АТРИБУТЫ", attributes);
}

Возможный вывод:

C++ ОСНОВЫ
__cplusplus                                  202002
__cpp_exceptions                             199711
__cpp_rtti                                   199711
 
C++11 ЯДРО
__cpp_alias_templates                        200704
__cpp_attributes                             200809
__cpp_constexpr                              201907
__cpp_decltype                               200707
__cpp_delegating_constructors                200604
__cpp_inheriting_constructors                201511
__cpp_initializer_lists                      200806
__cpp_lambdas                                200907
__cpp_nsdmi                                  200809
__cpp_range_based_for                        201603
__cpp_raw_strings                            200710
__cpp_ref_qualifiers                         200710
__cpp_rvalue_references                      200610
__cpp_static_assert                          201411
__cpp_threadsafe_static_init                 200806
__cpp_unicode_characters                     200704
__cpp_unicode_literals                       200710
__cpp_user_defined_literals                  200809
__cpp_variadic_templates                     200704
 
C++14 ЯДРО
__cpp_aggregate_nsdmi                        201304
__cpp_binary_literals                        201304
__cpp_constexpr                              201907
__cpp_decltype_auto                          201304
__cpp_generic_lambdas                        201707
__cpp_init_captures                          201803
__cpp_return_type_deduction                  201304
__cpp_sized_deallocation                     ------
__cpp_variable_templates                     201304
 
... усечено ...

Пример

Запустить этот код

#ifdef __has_include                           // Проверяет, присутствует ли __has_include
#  if __has_include(<optional>)                // Проверяет наличие стандартной библиотеки
#    include <optional>
#  elif __has_include(<experimental/optional>) // Проверяет наличие экспериментальной
                                               // версии
#    include <experimental/optional>
#  elif __has_include(<boost/optional.hpp>)    // Проверяет наличие внешней библиотеки
#    include <boost/optional.hpp>
#  else                                        // Вообще ничего не найдено
#     error "Отсутствует <optional>"
#  endif
#endif
 
#ifdef __has_cpp_attribute                      // Проверяет, присутствует ли
                                                // __has_cpp_attribute
#  if __has_cpp_attribute(deprecated)           // Проверяет атрибут
#    define DEPRECATED(msg) [[deprecated(msg)]]
#  endif
#endif
#ifndef DEPRECATED
#    define DEPRECATED(msg)
#endif
 
DEPRECATED("foo() устарела") void foo();
 
#if __cpp_constexpr >= 201304                   // Проверяет конкретную версию
                                                // функциональности
#  define CONSTEXPR constexpr
#else
#  define CONSTEXPR inline
#endif
 
CONSTEXPR int bar(unsigned i)
{
#if __cpp_binary_literals                    // Проверяет наличие функциональности
    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()
{
}

Смотрите также

Макросы тестирования функциональности библиотеки (C++20)	определённные в <version>
Официальный документ с Рекомендациями по Тестированию Функциональности
Исходный код для дампа возможностей компилятора
Документация по C++ для Индекс Макро Символов