Namespaces
Variants

Feature testing (since C++20)

From cppreference.net
C++
Feature testing

표준은 C++11 또는 이후에 도입된 C++ 언어 및 라이브러리 기능에 해당하는 preprocessor macros 세트를 정의합니다. 이들은 해당 기능의 존재를 감지하는 간단하고 이식 가능한 방법으로 의도되었습니다.

목차

속성

__has_cpp_attribute( attribute-token )

attribute-token 으로 명명된 속성 의 지원 여부를 확인합니다(매크로 확장 후).

각 표준 속성에 대해, __has_cpp_attribute 가 아래 표에 주어진 값(해당 속성이 작업 초안에 추가된 연도와 월)으로 확장되는지 또는 ​ 0 ​ 으로 확장되는지는 구현에 따라 정의됩니다. 이는 표준 속성이 권장된 방식으로 구현이 동작하도록 할 때(진단 메시지 출력, 클래스 레이아웃 영향 등)에만 표에 주어진 값으로 확장됩니다.

벤더별 속성의 존재 여부는 0이 아닌 값으로 결정됩니다.

__has_cpp_attribute 는 #if 및 #elif 표현식 내에서 확장될 수 있습니다. 이것은 #ifdef , #ifndef , #elifdef , #elifndef (C++23부터) 및 defined 에 의해 정의된 매크로로 취급되지만 다른 곳에서는 사용할 수 없습니다.

attribute-token 속성 값 표준 문서
assume [[ assume ]] 202207L (C++23) P1774R8
carries_dependency [[ carries_dependency ]] 200809L (C++11)
(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 ]] with reason 201907L (C++20) P1301R4
noreturn [[ noreturn ]] 200809L (C++11) N2761
unlikely [[ unlikely ]] 201803L (C++20) P0479R5
전체 속성 수: 11

언어 기능

다음 매크로들은 현재 구현에서 언어 기능이 구현되었는지 여부를 감지하는 데 사용할 수 있습니다. 이들은 predefined 되어 모든 번역 단위에서 사용 가능합니다.

각 매크로는 해당 기능이 작업 초안에 포함된 연도와 월에 해당하는 정수 리터럴로 확장됩니다. 기능이 상당히 변경될 경우, 매크로는 그에 따라 업데이트됩니다.

**번역 결과:** **설명:** - 모든 HTML 태그와 속성은 원본 그대로 유지되었습니다 - ` `, ` ` 태그 내의 텍스트는 번역되지 않았습니다 - C++ 관련 용어(`using enum`, `__cpp_using_enum` 등)는 번역되지 않았습니다 - 숫자 값과 링크 텍스트는 원본 형식을 그대로 유지했습니다
매크로 이름 기능 값 표준 문서
__cpp_aggregate_ bases 베이스 클래스를 가진 집계 클래스 201603L (C++17) P0017R1
__cpp_aggregate_ nsdmi 집계 클래스 와 기본 멤버 초기화자 201304L (C++14) N3653
__cpp_aggregate_ paren_init 집계 초기화 의 직접 초기화 형태 201902L (C++20) P0960R3
__cpp_alias_templates 별칭 템플릿 200704L (C++11) N2258
__cpp_aligned_new 과도하게 정렬된 데이터를 위한 동적 메모리 할당 201606L (C++17) P0035R4
__cpp_attributes 속성 200809L (C++11) N2761
__cpp_auto_cast auto ( x ) 및 auto { x } 202110L (C++23) P0849R8
__cpp_binary_literals 2진수 리터럴 201304L (C++14) N3472
__cpp_capture_star_ this 값으로 * this 람다 캡처 [ = , * this ] 201603L (C++17) P0018R3
__cpp_char8_t char8_t 201811L (C++20) P0482R6
char8_t 호환성 및 이식성 수정 ( (unsigned) char 배열 초기화 를 UTF-8 문자열 리터럴 로 허용) 202207L (C++23)
(DR20) 		P2513R4
__cpp_concepts Concepts 201907L (C++20) P0734R0
P1084R2
P1452R2
조건부 사소한 특수 멤버 함수 202002L P0848R3
P2493R0
__cpp_conditional_ explicit explicit(bool) 201806L (C++20) P0892R2
__cpp_consteval 즉시 실행 함수 201811L (C++20) P1073R3
consteval 상향 전파 202211L (C++23)
(DR20) 		P2564R3
__cpp_constexpr constexpr 200704L (C++11) N2235
완화된 constexpr , non- const constexpr 메서드 201304L (C++14) N3652
constexpr 람다 201603L (C++17) P0170R1
가상 함수 호출을 상수 표현식에서 사용; try 블록 을 constexpr 함수에서 사용, dynamic_cast 와 다형적 typeid 를 상수 표현식에서 사용; 단순 기본 초기화 와 asm-선언 을 constexpr 함수에서 사용 201907L (C++20) P1064R0
P1002R1
P1327R1
P1331R2
P1668R1
상수 평가에서 유니온의 활성 멤버 변경 202002L P1330R0
P2493R0
비- 리터럴 변수, 레이블, 그리고 goto 문장을 constexpr 함수에서 사용 202110L (C++23) P2242R3
constexpr 함수 및 함수 템플릿에 대한 일부 제한 완화 202207L P2448R2
정적 constexpr 변수를 constexpr 함수 내에서 허용 202211L P2647R1
void * 에서의 Constexpr 캐스트: constexpr 타입 소거를 향하여 202306L (C++26) P2738R1
constexpr 플레이스먼트 new 202406L P2747R2
__cpp_constexpr_ dynamic_alloc constexpr 함수에서의 동적 저장 기간 연산 201907L (C++20) P0784R7
__cpp_constexpr_ exceptions constexpr 예외: [1] , [2] 202411L (C++26) P3068R6
__cpp_constexpr_ in_decltype 상수 평가에 필요한 경우 함수 및 변수 정의의 생성 201711L (C++20)
(DR11) 		P0859R0
__cpp_constinit constinit 201907L (C++20) P1143R2
__cpp_contracts 계약 202502L (C++26) P2900R14
__cpp_decltype decltype 200707L (C++11) N2343
__cpp_decltype_auto 일반 함수의 반환형 추론 201304L (C++14) N3638
__cpp_deduction_ guides 클래스 템플릿을 위한 템플릿 인수 추론 (CTAD) 201703L (C++17) P0091R3
P0512R0
P0620R0
집계체 및 별칭에 대한 CTAD 201907L (C++20) P1814R0
P1816R0
__cpp_delegating_ constructors 위임 생성자 200604L (C++11) N1986
__cpp_deleted_function 삭제된 함수 정의 와 메시지 ( = delete ( "should have a reason" ) ; ) 202403L (C++26) P2573R2
__cpp_designated_ initializers 지정 이니셜라이저 201707L (C++20) P0329R4
__cpp_enumerator_ attributes 열거자에 대한 속성 201411L (C++17) N4266
__cpp_explicit_this_ parameter 명시적 객체 매개변수 202110L (C++23) P0847R7
__cpp_fold_expressions 폴드 표현식 201603L (C++17) N4295
P0036R0
제약 조건 과 폴드 표현식 을 포함하는 순서화 202406L (C++26) P2963R3
__cpp_generic_lambdas 제네릭 람다 표현식 201304L (C++14) N3649
제네릭 람다에 대한 명시적 템플릿 매개변수 목록 201707L (C++20) P0428R2
__cpp_guaranteed_ copy_elision 단순화된 값 범주 를 통한 보장된 복사 생략 201606L (C++17) P0135R1
__cpp_hex_float 16진수 부동 소수점 리터럴 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 코루틴 (컴파일러 지원) 201902L (C++20) P0912R5
LWG3393
__cpp_impl_destroying_ delete Destroying operator delete (컴파일러 지원) 201806L (C++20) P0722R3
__cpp_impl_three_ way_comparison 3-way 비교 (컴파일러 지원) 201907L (C++20) P0515R3
P0768R1
P1185R2
P1630R1
__cpp_implicit_move 간소화된 암시적 이동 202207L (C++23) P2266R3
__cpp_inheriting_ constructors 상속 생성자 200802L (C++11) N2540
상속 생성자 재정의: 상속 생성자 에 대한 새로운 명세 ( DR1941 등) 201511L (C++17)
(DR11) 		P0136R1
__cpp_init_captures 람다 초기화 캡처 201304L (C++14) N3648
람다 init-capture에서 lambda 팩 확장 허용 201803L (C++20) P0780R2
__cpp_initializer_ lists 목록 초기화 및 std::initializer_list 200806L (C++11) N2672
__cpp_inline_variables 인라인 변수 201606L (C++17) P0386R2
__cpp_lambdas 람다 표현식 200907L (C++11) N2927
__cpp_modules 모듈 201907L (C++20) P1103R3
P1811R0
__cpp_multidimensional_ subscript 다차원 첨자 연산자 202110L (C++23) P2128R6
Static operator[] 202211L P2589R1
__cpp_named_character_ escapes 명명된 유니버설 문자 이스케이프 202207L (C++23) P2071R2
__cpp_namespace_ attributes 네임스페이스에 대한 속성 201411L (C++17) N4266
__cpp_noexcept_function_ type 예외 명세를 타입 시스템의 일부로 만듦 201510L (C++17) P0012R1
__cpp_nontype_template_ args 모든 상수 템플릿 인수 에 대해 상수 평가 허용 201411L (C++17) N4268
클래스 타입과 부동소수점 타입을 상수 템플릿 매개변수 에서 사용 201911L (C++20) P1907R1
__cpp_nontype_template_ parameter_auto 상수 템플릿 매개변수 를 auto 로 선언 201606L (C++17) P0127R2
__cpp_nsdmi 비정적 데이터 멤버 초기화 200809L (C++11) N2756
__cpp_pack_indexing 팩 인덱싱 202311L (C++26) P2662R3
__cpp_placeholder_ variables 이름 없는 편리한 플레이스홀더 202306L (C++26) P2169R4
__cpp_pp_embed #embed 202502L (C++26) P1967R14
__cpp_range_based_ for 범위 기반 for 루프 200907L (C++11) N2930
범위 기반 for 루프 에서 서로 다른 begin / end 타입 사용 201603L (C++17) P0184R0
범위 기반 for 에서의 수명 연장 202211L (C++23) P2644R1
P2718R0
CWG2659
__cpp_raw_strings 원시 문자열 리터럴 200710L (C++11) N2442
__cpp_ref_qualifiers 참조 한정자 200710L (C++11) N2439
__cpp_return_type_ deduction 일반 함수의 반환 타입 추론 201304L (C++14) N3638
__cpp_rvalue_references 우측값 참조 200610L (C++11) N2118
__cpp_size_t_suffix std::size_t 및 부호 있는 버전을 위한 리터럴 접미사 202011L (C++23) P0330R8
__cpp_sized_deallocation 크기 지정 할당 해제 201309L (C++14) N3778
__cpp_static_assert static_assert 200410L (C++11) N1720
단일 인수 static_assert 201411L (C++17) N3928
사용자 생성 static_assert 메시지 202306L (C++26) P2741R3
__cpp_static_call_ operator 정적 operator() 202207L (C++23) P1169R4
__cpp_structured_ bindings 구조화된 바인딩 201606L (C++17) P0217R3
속성 for structured binding 202403L (C++26) P0609R3
구조화된 바인딩 선언 조건으로서 202406L P0963R3
구조화된 바인딩 은 팩 을 도입할 수 있습니다 202411L P1061R10
__cpp_template_parameters 개념 및 변수 템플릿 템플릿 매개변수 202502L (C++26) P2841R7
__cpp_template_template_ args 템플릿 템플릿 인수의 매칭 201611L (C++17) P0522R0
__cpp_threadsafe_ static_init 동시성을 고려한 동적 초기화 및 소멸 200806L (C++11) N2660
__cpp_trivial_relocatability 단순 재배치 가능성 202502L (C++26) P2786R13
__cpp_trivial_union 트리비얼 유니온 202502L (C++26) P3074R7
__cpp_unicode_characters 새로운 문자 타입 ( char16_t 및 char32_t ) 200704L (C++11) N2249
__cpp_unicode_literals 유니코드 문자열 리터럴 200710L (C++11) N2442
__cpp_user_defined_ literals 사용자 정의 리터럴 200809L (C++11) N2765
__cpp_using_enum using enum 201907L (C++20) P1099R5
__cpp_using_enum using enum 201907L (C++20) P1099R5
__cpp_variable_templates 변수 템플릿 201304L (C++14) N3651
__cpp_variadic_friend 가변 인자 friend 선언 202403L (C++26) P2893R3
__cpp_variadic_templates 가변 인자 템플릿 200704L (C++11) N2242
__cpp_variadic_using using -선언에서의 팩 확장 201611L (C++17) P0195R2
매크로 총 개수: 76

라이브러리 기능

다음 매크로들은 현재 구현에서 표준 라이브러리 기능이 구현되었는지 감지하는 데 사용할 수 있습니다. 언어 기능 테스트 매크로와 달리, 이들은 미리 정의되어 있지 않습니다. 대신, <version> 헤더에 의해 제공됩니다.

각 라이브러리 기능 테스트 매크로는 관련 표준 라이브러리 구성요소를 제공하는 헤더에서도 제공됩니다. 이러한 매크로를 제공하는 헤더의 전체 목록은 라이브러리 기능 테스트 매크로 를 참조하십시오.

각 매크로는 해당 기능이 작업 초안에 포함된 연도와 월에 해당하는 정수 리터럴로 확장됩니다. 기능이 상당히 변경될 경우, 매크로는 그에 따라 업데이트됩니다.

**변역 결과:** **설명:** - 모든 HTML 태그와 속성은 원본 그대로 유지되었습니다 - ` `, ` 
`, `` 태그 내부의 텍스트는 번역되지 않았습니다
- C++ 관련 용어(`__cpp_lib_as_const`, `std::as_const`, `201510L`, `P0007R1`)는 번역되지 않았습니다
- 이 웹페이지 요소는 C++ 표준 라이브러리 기능에 대한 기술적 정보를 담고 있어 전문적인 표현이 유지되었습니다
 **번역 결과:** **번역 설명:** - 모든 HTML 태그와 속성은 원본 그대로 유지됨 - ` `, ` `, ` 
`, `` 태그 내의 텍스트는 번역하지 않음
- C++ 관련 용어(`std::lerp`, `std::midpoint`, `__cpp_lib_interpolate` 등)는 번역하지 않음
- 숫자, 버전 정보, 문서 식별자는 원본 그대로 보존
 **번역 결과:** **설명:** - HTML 태그, 속성, ` `, ` 
`, `` 태그 내부의 텍스트는 번역하지 않음
- C++ 관련 용어(`__cpp_lib_remove_cvref`, `std::remove_cvref`, `201711L`, `P0550R2`)는 원문 유지
- 이 웹페이지 요소는 C++ 표준 라이브러리 기능에 대한 기술적 정보를 담고 있어 전문성을 유지함
 **번역 결과:** **설명:** - 모든 HTML 태그와 속성은 그대로 유지되었습니다 - ` `, ` ` 태그 내의 텍스트는 번역되지 않았습니다 - C++ 관련 용어(`__cpp_lib_to_array`, `std::to_array`, `201907L`, `P0325R4`)는 번역되지 않았습니다 - (C++20) 표기는 그대로 유지되었습니다 - 제목(title) 속성도 번역되지 않았습니다
매크로 이름 기능 값 표준 문서
__cpp_lib_adaptor_ iterator_pair_constructor std::stack 및 std::queue 를 위한 반복자 쌍 생성자 202106L (C++23) P1425R4
__cpp_lib_addressof_ constexpr Constexpr std::addressof 201603L (C++17) LWG2296
__cpp_lib_algorithm_ default_value_type 알고리즘에 대한 목록 초기화 활성화 202403L (C++26) P2248R8
P3217R0
__cpp_lib_algorithm_ iterator_requirements Ranges 반복자를 비-Ranges 알고리즘 입력으로 사용 202207L (C++23) P2408R5
__cpp_lib_aligned_ accessor std::aligned_accessor : std::mdspan 접근자로서 포인터의 오버 얼라인먼트를 표현함 202411L (C++26) P2897R7
__cpp_lib_allocate_ at_least 할당자 인터페이스의 크기 피드백, 예시: 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 정리 작업 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 std::reverse_iterator , std::move_iterator , std::array 및 범위 접근 에 대한 Constexpr 201603L (C++17) P0031R0
ConstexprIterator ; constexpr 비교 연산자 for std::array ; 기타 constexpr 기능들 ( std::array::fill 등) 201811L (C++20) P0858R0
LWG3257
P1023R0
P1032R1
__cpp_lib_as_const std::as_const 201510L (C++17) P0007R1
__cpp_lib_as_const std::as_const 201510L (C++17) P0007R1
__cpp_lib_associative_ heterogeneous_erasure 연관 컨테이너와 비정렬 연관 컨테이너에서의 이종 삭제 및 이종 삭제 202110L (C++23) P2077R3
__cpp_lib_associative_ heterogeneous_insertion 정렬된 연관 컨테이너 와 비정렬 연관 컨테이너 에 남아있는 멤버 함수들에 대한 이종(heterogeneous) 오버로드 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 부동 소수점 원자 연산 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 원자적 록프리 정수형 타입 ( std::atomic_signed_lock_free , std::atomic_unsigned_lock_free ) 201907L (C++20) P1135R6
__cpp_lib_atomic_ min_max 원자적 최소/최대 ( std::atomic::fetch_min , std::atomic::fetch_max 등) 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 원자적 초기화 수정 (기본값으로 std::atomic 값 초기화) 201911L (C++20) P0883R2
__cpp_lib_atomic_ wait 효율적인 std::atomic 대기 201907L (C++20) P1135R6
__cpp_lib_barrier std::barrier 201907L (C++20) P1135R6
std::barrier 의 페이즈 완료 보장 202302L (C++23) P2588R3
__cpp_lib_bind_back std::bind_back 202202L (C++23) P2387R3
콜러블 객체를 상수 템플릿 인수로 std::bind_back 에 전달할 수 있도록 허용 202306L (C++26) P2714R1
__cpp_lib_bind_front std::bind_front 201907L (C++20) P0356R5
P1651R0
콜러블 객체를 상수 템플릿 인수로 전달할 수 있도록 허용 std::bind_front 202306L (C++26) P2714R1
__cpp_lib_bit_cast std::bit_cast 201806L (C++20) P0476R2
__cpp_lib_bitops 비트 연산 201907L (C++20) P0553R4
__cpp_lib_bitset std::bitset 과 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 검색기 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 char8_t에 대한 라이브러리 지원 201907L (C++20) P0482R6
P1423R3
__cpp_lib_chrono std::chrono::duration 및 std::chrono::time_point 에 대한 반올림 함수 201510L (C++17) P0092R1
std::chrono::duration 및 std::chrono::time_point 의 모든 멤버 함수에 대한 Constexpr 201611L P0505R0
Calendars 및 Time zones 201907L (C++20) P0355R7
P1466R3
해싱 지원 for std::chrono 값 클래스 202306L (C++26) P2592R3
__cpp_lib_chrono_ udls 시간 타입을 위한 사용자 정의 리터럴 201304L (C++14) N3642
__cpp_lib_clamp std::clamp 201603L (C++17) P0025R1
__cpp_lib_common_ reference std::common_reference_t 의 std::reference_wrapper 를 참조 타입으로 만들기 202302L (C++23) P2655R3
__cpp_lib_common_ reference_wrapper std::common_reference_t 의 std::reference_wrapper 를 참조 타입으로 만들기 202302L (C++23) P2655R3
__cpp_lib_complex_ udls std::complex 에 대한 사용자 정의 리터럴 201309L (C++14) N3779
__cpp_lib_concepts 표준 라이브러리 컨셉트 202002L (C++20) P0898R3
P1754R1
P1964R2
이동 전용 타입에 대한 equality_comparable_with , totally_ordered_with , 및 three_way_comparable_with 202207L (C++23) P2404R3
__cpp_lib_constexpr_ algorithms 알고리즘의 constexpr 지원 201806L (C++20) P0202R3
P0879R0
LWG3256
LWG3792
Constexpr 안정 정렬 202306L (C++26) P2562R1
__cpp_lib_constexpr_ atomic constexpr std::atomic 및 std::atomic_ref 202411L (C++26) P3309R3
__cpp_lib_constexpr_ bitset 더 많은 constexpr std::bitset 202207L (C++23) P2417R2
__cpp_lib_constexpr_ charconv 정수형에 대한 std::to_chars 및 std::from_chars 의 Constexpr 지원 202207L (C++23) P2291R3
__cpp_lib_constexpr_ cmath <cmath> 및 <cstdlib> 내 수학 함수에 대한 Constexpr 202202L (C++23) P0533R9
더 많은 constexpr for <cmath> 202306L (C++26) P1383R2
__cpp_lib_constexpr_ complex std::complex 에 대한 Constexpr 201711L (C++20) P0415R1
추가 constexpr for <complex> 202306L (C++26) P1383R2
__cpp_lib_constexpr_ deque constexpr std::deque 202502L (C++26) P3372R3
__cpp_lib_constexpr_ dynamic_alloc std::allocator 및 관련 유틸리티에 대한 Constexpr 201907L (C++20) P0784R7
__cpp_lib_constexpr_ exceptions constexpr 예외 타입에 대한 constexpr, 예를 들어 std::bad_alloc , std::bad_cast 등 202411L (C++26) P3068R6
예외 타입에 대한 더 많은 constexpr 지원 202502L P3378R2
__cpp_lib_constexpr_ flat_map constexpr std::flat_map 와 std::flat_multimap 202502L (C++26) P3372R3
__cpp_lib_constexpr_ flat_set constexpr std::flat_set 및 std::flat_multiset 202502L (C++26) P3372R3
__cpp_lib_constexpr_ forward_list constexpr std::forward_list 202502L (C++26) P3372R3
__cpp_lib_constexpr_ functional 기타 constexpr 비트 ( std::default_searcher ); constexpr INVOKE 201907L (C++20) P1032R1
P1065R2
__cpp_lib_constexpr_ inplace_vector constexpr std::inplace_vector 비트리비얼 타입을 위한 202502L (C++26) P3074R7
__cpp_lib_constexpr_ iterator 기타 constexpr 비트 ( std::insert_iterator 등) 201811L (C++20) P1032R1
__cpp_lib_constexpr_ list constexpr std::list 202502L (C++26) P3372R3
__cpp_lib_constexpr_ map constexpr std::map 와 std::multimap 202502L (C++26) P3372R3
__cpp_lib_constexpr_ memory std::pointer_traits 의 Constexpr 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 알고리즘 의 상수 표현식 <numeric> 201911L (C++20) P1645R1
__cpp_lib_constexpr_ queue constexpr std::queue 202502L (C++26) P3372R3
__cpp_lib_constexpr_ set constexpr std::set 와 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 기타 constexpr 기능 ( std::string_view::copy ) 201811L (C++20) P1032R1
__cpp_lib_constexpr_ tuple 기타 constexpr 기능들 ( std::tuple::operator= 등) 201811L (C++20) P1032R1
__cpp_lib_constexpr_ typeinfo std::type_info::operator== 에 대한 Constexpr 202106L (C++23) P1328R1
__cpp_lib_constexpr_ unordered_map constexpr std::unordered_map 와 std::unordered_multimap 202502L (C++26) P3372R3
__cpp_lib_constexpr_ unordered_set constexpr std::unordered_set 및 std::unordered_multiset 202502L (C++26) P3372R3
__cpp_lib_constexpr_ utility 기타 constexpr 기능들 ( std::pair::operator= 등) 201811L (C++20) P1032R1
__cpp_lib_constexpr_ vector std::vector 에 대한 constexpr 지원 201907L (C++20) P1004R2
__cpp_lib_constrained_ equality std::pair , std::tuple , std::optional , 및 std::variant 에 대한 제약된 관계 연산자 202403L (C++26) P2944R3
제약 조건을 적용한 std::expected 동등성 연산자 202411L P3379R0
__cpp_lib_containers_ ranges Ranges-aware 컨테이너 및 문자열을 위한 생성 및 삽입 202202L (C++23) P1206R7
__cpp_lib_contracts <contracts> : 계약 지원 202502L (C++26) P2900R14
__cpp_lib_copyable_ function std::copyable_function 202306L (C++26) P2548R6
__cpp_lib_coroutine 코루틴 (라이브러리 지원) 201902L (C++20) P0912R5
LWG3393
__cpp_lib_debugging <debugging> : 디버깅 지원 202311L (C++26) P2546R5
Replaceable std::is_debugger_present 202403L P2810R4
__cpp_lib_destroying_ delete Destroying operator delete (라이브러리 지원) 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 통합 컨테이너 삭제 202002L (C++20) P1209R0
P1115R3
__cpp_lib_exchange_ function std::exchange 201304L (C++14) N3668
__cpp_lib_execution 실행 정책 201603L (C++17) P0024R2
std::execution::unsequenced_policy 201902L (C++20) P1001R2
__cpp_lib_expected 클래스 템플릿 std::expected 202202L (C++23) P0323R12
std::expected를 위한 모나딕 함수 std::expected 202211L P2505R5
__cpp_lib_filesystem 파일시스템 라이브러리 201703L (C++17) P0218R1
P0219R1
P0392R0
P0317R1
__cpp_lib_flat_map std::flat_map 및 std::flat_multimap 202207L (C++23) P0429R9
__cpp_lib_flat_set std::flat_set 및 std::flat_multiset 202207L (C++23) P1222R4
LWG3751
__cpp_lib_format 텍스트 서식 지정 201907L (C++20) P0645R10
P1361R2
P1652R1
컴파일 타임 형식 문자열 검사; std::vformat_to 의 매개변수화 감소 202106L (C++23)
(DR20) 		P2216R3
chrono 포매터의 로케일 처리 수정; const-포맷 가능하지 않은 타입 지원 202110L P2372R3
P2418R2
std::basic_format_string 을 노출하고; chrono 타입의 지역화된 서식에서 인코딩 처리 방식을 명확히 함 202207L (C++23) P2419R2
P2508R1
포인터 서식 지정 202304L (C++26) P2510R3
형식 인수 타입 검사 202305L P2757R3
멤버 visit 202306L P2637R3
런타임 형식 문자열 202311L P2918R2
__cpp_lib_format_ path std::filesystem::path 의 포맷팅 202403L (C++26) P2845R8
__cpp_lib_format_ ranges 범위 서식 지정 202207L (C++23) P2286R8
P2585R1
LWG3750
__cpp_lib_format_ uchar 코드 단위를 정수로 서식 지정 수정 202311L (C++26) P2909R4
__cpp_lib_formatters 포맷팅 std::thread::id 및 std::stacktrace 202302L (C++23) P2693R1
__cpp_lib_forward_ like std::forward_like 202207L (C++23) P2445R1
__cpp_lib_freestanding_ algorithm <algorithm> 의 독립 실행형 기능 202311L (C++26) P2407R5
독립형 라이브러리: <algorithm> 202502L P2976R1
__cpp_lib_freestanding_ array std::array 의 일부를 독립 실행형으로 만들기 202311L (C++26) P2407R5
__cpp_lib_freestanding_ char_traits 독립 실행형 std::char_traits 202306L (C++26) P2338R4
__cpp_lib_freestanding_ charconv <charconv> 의 독립 실행형 기능 202306L (C++26) P2338R4
__cpp_lib_freestanding_ cstdlib <cstdlib> 의 독립 실행형 기능 202306L (C++26) P2338R4
__cpp_lib_freestanding_ cstring <cstring> 의 독립 실행형 기능 202306L (C++26) P2338R4
freestanding 기능에서 std::strtok 제거 202311L P2937R0
__cpp_lib_freestanding_ cwchar <cwchar> 의 독립 실행형 기능 202306L (C++26) P2338R4
__cpp_lib_freestanding_ errc 독립 실행 환경 std::errc 202306L (C++26) P2338R4
__cpp_lib_freestanding_ execution 독립형 라이브러리: <execution> 202502L (C++26) P2976R1
__cpp_lib_freestanding_ expected std::expected 의 일부를 독립 실행형으로 만들기 202311L (C++26) P2833R2
__cpp_lib_freestanding_ feature_test_macros 독립 실행 환경 기능 테스트 매크로 지원 202306L (C++26) P2198R7
__cpp_lib_freestanding_ functional <functional> 의 독립 실행형 기능 202306L (C++26) P2198R7
__cpp_lib_freestanding_ iterator <iterator> 의 독립 실행형 기능 202306L (C++26) P2198R7
__cpp_lib_freestanding_ mdspan 독립형 std::mdspan 202311L (C++26) P2833R2
__cpp_lib_freestanding_ memory <memory> 의 독립 실행 환경 기능 202306L (C++26) P2198R7
독립형 라이브러리: <memory> 202502L P2976R1
__cpp_lib_freestanding_ numeric <numeric> 내 독립 실행 환경 기능 (포화 연산) 202311L (C++26) P0543R3
독립형 라이브러리: <numeric> 202502L P2976R1
__cpp_lib_freestanding_ operator_new 독립 실행 환경 구현에서 선택적(optional)인 operator new 의 정의 202306L (C++26) P2198R7
__cpp_lib_freestanding_ optional std::optional 일부를 독립 실행형으로 만들기 202311L (C++26) P2407R5
__cpp_lib_freestanding_ random 독립형 라이브러리: <random> 202502L (C++26) P2976R1
__cpp_lib_freestanding_ ranges <ranges> 의 독립 실행형 기능 202306L (C++26) P2198R7
__cpp_lib_freestanding_ ratio 헤더의 독립 실행형 기능 202306L (C++26) P2198R7
__cpp_lib_freestanding_ string_view std::string_view 일부를 독립 실행형으로 만들기 202311L (C++26) P2407R5
__cpp_lib_freestanding_ tuple <tuple> 의 독립 실행형 기능 202306L (C++26) P2198R7
__cpp_lib_freestanding_ utility <utility> 의 독립 실행형 기능 202306L (C++26) P2198R7
__cpp_lib_freestanding_ variant std::variant 일부를 독립 실행형으로 만들기 202311L (C++26) P2407R5
__cpp_lib_fstream_ native_handle 파일 스트림에서 네이티브 핸들 획득 202306L (C++26) P1759R6
__cpp_lib_function_ ref std::function_ref : 타입 삭제된 호출 가능 참조 202306L (C++26) P0792R14
__cpp_lib_gcd_lcm std::gcd , std::lcm 201606L (C++17) P0295R0
__cpp_lib_generator std::generator : 범위를 위한 동기 코루틴 생성기 202207L (C++23) P2502R2
__cpp_lib_generic_ associative_lookup 연관 컨테이너에서의 이종 비교 검색 associative containers 201304L (C++14) N3657
__cpp_lib_generic_ unordered_lookup 비정렬 연관 컨테이너에서의 이종 비교 검색 201811L (C++20) P0919R3
__cpp_lib_hardened_ array 표준 라이브러리 강화 (강화된 구현에서만 제공됨) 202502L (C++26) P3471R4
__cpp_lib_hardened_ basic_string 표준 라이브러리 강화 (강화된 구현에서만 존재) 202502L (C++26) P3471R4
__cpp_lib_hardened_ basic_string_view 표준 라이브러리 강화 (강화된 구현에서만 제공됨) 202502L (C++26) P3471R4
__cpp_lib_hardened_ bitset 표준 라이브러리 강화 (강화된 구현에서만 존재) 202502L (C++26) P3471R4
__cpp_lib_hardened_ deque 표준 라이브러리 강화 (강화된 구현에서만 제공됨) 202502L (C++26) P3471R4
__cpp_lib_hardened_ expected 표준 라이브러리 강화 (강화된 구현에서만 존재) 202502L (C++26) P3471R4
__cpp_lib_hardened_ forward_list 표준 라이브러리 강화 (강화된 구현에서만 제공됨) 202502L (C++26) P3471R4
__cpp_lib_hardened_ inplace_vector 표준 라이브러리 강화 (강화된 구현에서만 존재) 202502L (C++26) P3471R4
__cpp_lib_hardened_ list 표준 라이브러리 강화 (강화된 구현에서만 존재) 202502L (C++26) P3471R4
__cpp_lib_hardened_ mdspan 표준 라이브러리 강화 (강화된 구현에서만 존재) 202502L (C++26) P3471R4
__cpp_lib_hardened_ optional 표준 라이브러리 강화 (강화된 구현에서만 존재) 202502L (C++26) P3471R4
__cpp_lib_hardened_ span 표준 라이브러리 강화 (강화된 구현에서만 존재) 202502L (C++26) P3471R4
__cpp_lib_hardened_ valarray 표준 라이브러리 강화 (강화된 구현에서만 존재) 202502L (C++26) P3471R4
__cpp_lib_hardened_ vector 표준 라이브러리 강화 (강화된 구현에서만 존재) 202502L (C++26) P3471R4
__cpp_lib_hardware_ interference_size Constexpr std::hardware_{constructive, destructive}_interference_size 201703L (C++17) P0154R1
__cpp_lib_hive <hive> : 삭제된 요소의 메모리 위치를 재사용하는 버킷 기반 컨테이너 202502L (C++26) P0447R28
__cpp_lib_has_unique_ object_representations std::has_unique_object_representations 201606L (C++17) P0258R2
__cpp_lib_hazard_ pointer <hazard_pointer> : Hazard pointers 202306L (C++26) P2530R3
__cpp_lib_hypot std::hypot 의 3인자 오버로드 201603L (C++17) P0030R1
__cpp_lib_incomplete_ container_elements std::forward_list , std::list , 및 std::vector 에 대한 최소 불완전 타입 지원 201505L (C++17) N4510
__cpp_lib_indirect std::indirect 202502L (C++26) P3019R13
__cpp_lib_inplace_ vector std::inplace_vector : 고정된 용량을 가진 동적으로 크기 조정 가능한 벡터 (인플레이스 저장소) 202406L (C++26) P0843R14
__cpp_lib_int_pow2 정수 2의 거듭제곱 연산 ( std::has_single_bit , std::bit_ceil , std::bit_floor , std::bit_width ) 202002L (C++20) P0556R3
P1956R1
__cpp_lib_integer_ comparison_functions 정수 비교 함수 202002L (C++20) P0586R2
__cpp_lib_integer_ sequence 컴파일 타임 정수 시퀀스 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_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 fstream에 대한 배타적 모드 지원 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 포인터 상호 변환 가능 특성: 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 : 포인터의 정렬 선행 조건을 검사합니다 202411L (C++26) P2897R7
__cpp_lib_is_swappable (nothrow-)swappable 특성 201603L (C++17) P0185R1
__cpp_lib_is_virtual_ base_of std::is_virtual_base_of : 가상 기본 클래스 검출을 위한 타입 특성 202406L (C++26) P2985R0
__cpp_lib_is_within_ lifetime 유니온 대안이 활성 상태인지 확인 ( std::is_within_lifetime ) 202306L (C++26) P2641R4
__cpp_lib_jthread 스톱 토큰 및 조인 스레드 201911L (C++20) P0660R10
P1869R1
__cpp_lib_latch std::latch 201907L (C++20) P1135R6
__cpp_lib_launder CWG 이슈 1776 : 참조 멤버를 포함하는 클래스 객체의 교체 ( std::launder ) 201606L (C++17) P0137R1
__cpp_lib_linalg BLAS 기반의 자유 함수 선형 대수 인터페이스 202311L (C++26) P1673R13
__cpp_lib_list_remove_ return_type std::forward_list 와 std::list 의 remove() , remove_if() , unique() 멤버 함수의 반환 타입 변경 201806L (C++20) P0646R1
__cpp_lib_logical_ traits 타입 트레이트에 대한 논리 연산 201510L (C++17) P0013R1
__cpp_lib_make_from_ tuple std::make_from_tuple 201606L (C++17) P0209R2
__cpp_lib_make_reverse_ iterator std::make_reverse_iterator 201402L (C++14) LWG2285
__cpp_lib_make_unique std::make_unique 201304L (C++14) N3656
__cpp_lib_map_try_ emplace std::map::try_emplace , std::map::insert_or_assign 201411L (C++17) N4279
__cpp_lib_math_constants 수학 상수 201907L (C++20) P0631R8
__cpp_lib_math_special_ functions 수학적 특수 함수 201603L (C++17) P0226R1
__cpp_lib_mdspan std::mdspan 202207L (C++23) P0009R18
P2599R2
P2604R0
P2613R1
std::dims for std::mdspan 202406L (C++26) P2389R2
__cpp_lib_memory_ resource std::pmr::memory_resource 201603L (C++17) P0220R1
__cpp_lib_modules 표준 라이브러리 모듈 std 및 std.compat 202207L (C++23) P2465R3
__cpp_lib_move_iterator_ concept std::move_iterator<T*> 를 임의 접근 반복자로 만들기 202207L (C++23) P2520R0
__cpp_lib_move_only_ function std::move_only_function 202110L (C++23) P0288R9
__cpp_lib_node_extract 맵과 셋 스플라이싱 ( std::map::extract , std::map::merge , insert(node_type) , 등) 201606L (C++17) P0083R3
__cpp_lib_nonmember_ container_access std::size , std::data 및 std::empty 201411L (C++17) N4280
__cpp_lib_not_fn std::not_fn 201603L (C++17) P0005R4
콜러블 객체를 상수 템플릿 인수로 전달할 수 있도록 허용 std::not_fn 202306L (C++26) P2714R1
__cpp_lib_null_iterators 널 LegacyForwardIterator s 201304L (C++14) N3644
__cpp_lib_optional std::optional 201606L (C++17) P0220R1
P0032R3
P0307R2
완전히 constexpr std::optional 202106L (C++23)
(DR20) 		P2231R1
모나딕 연산 in std::optional 202110L (C++23) P0798R8
LWG3621
__cpp_lib_optional_ range_support std::optional 범위 지원 202406L (C++26) P3168R2
__cpp_lib_out_ptr std::out_ptr , std::inout_ptr 202106L (C++23) P1132R8
독립형 std::out_ptr , std::inout_ptr 202311L (C++26) P2833R2
__cpp_lib_parallel_ algorithm 병렬 알고리즘 201603L (C++17) P0024R2
__cpp_lib_polymorphic std::polymorphic 202502L (C++26) P3019R13
__cpp_lib_polymorphic_ allocator std::pmr::polymorphic_allocator<> 어휘 유형으로서 201902L (C++20) P0339R6
LWG3437
__cpp_lib_print 서식화된 출력 202207L (C++23) P2093R14
효율적인 구현을 허용하는 std::print 202403L (C++26)
(DR23) 		P3107R5
P3235R3
빈 줄 출력하기 std::println 202403L (C++26) P3142R0
__cpp_lib_quoted_ string_io std::quoted 201304L (C++14) N3654
__cpp_lib_philox_ engine std::philox_engine : 카운터 기반 난수 엔진 202406L (C++26) P2075R6
__cpp_lib_ranges Ranges 라이브러리 와 제약 알고리즘 201911L (C++20) P0896R4
P1035R7
P1716R3
비- default-initializable views 202106L (C++23)
(DR20) 		P2325R3
Views with ownership 202110L P2415R2
std::ranges::range_adaptor_closure 202202L (C++23) P2387R3
무브 전용(move-only) 타입을 허용하도록 range adaptors 완화 202207L P2494R2
ranges::begin , ranges::end , ranges::rbegin , ranges::rend , 그리고 ranges::size 에서 "poison pill" 오버로드 제거 202211L P2602R2
특정 프로젝션을 허용하도록 범위 완화 202302L P2609R3
간접 호출 가능 개념들에서 공통 참조 요구사항 제거 202406L (C++26)
(DR20) 		P2997R1
__cpp_lib_ranges_ as_const std::const_iterator , std::ranges::as_const_view 202207L (C++23) P2278R4
std::basic_const_iterator 가 해당 기본 타입의 변환 가능성을 따르도록 만들기 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 , 및 std::ranges::find_last_if_not 202207L (C++23) P1223R5
LWG3807
__cpp_lib_ranges_ fold std::ranges fold 알고리즘 202207L (C++23) P2322R6
__cpp_lib_ranges_ generate_random 난수 생성을 위한 벡터 API ( 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 및 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 2022년 새로운 SI 접두사 추가 202306L (C++26) P2734R0
__cpp_lib_raw_memory_ algorithms 메모리 관리 도구 확장 201606L (C++17) P0040R3
constexpr for 특수화된 메모리 알고리즘 202411L (C++26) P3508R0
P3369R0
__cpp_lib_rcu <rcu> : 읽기-복사 업데이트 (RCU) 202306L (C++26) P2545R4
__cpp_lib_reference_ from_temporary std::reference_constructs_from_temporary 와 std::reference_converts_from_temporary 202202L (C++23) P2255R2
__cpp_lib_reference_ wrapper std::reference_wrapper 에 대한 비교 연산 202403L (C++26) P2944R3
__cpp_lib_remove_ cvref std::remove_cvref 201711L (C++20) P0550R2
__cpp_lib_remove_ cvref std::remove_cvref 201711L (C++20) P0550R2
__cpp_lib_result_ of_sfinae std::result_of 및 SFINAE 201210L (C++14) N3462
__cpp_lib_robust_ nonmodifying_seq_ops 비수정 시퀀스 연산의 견고성 향상 ( std::mismatch , std::equal 및 std::is_permutation 에 대한 이중 범위 오버로드) 201304L (C++14) N3671
__cpp_lib_sample std::sample 201603L (C++17) P0220R1
__cpp_lib_saturation_ arithmetic 포화 산술 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 : 실행 제어를 위한 발신자-수신자 모델 202406L (C++26) P2300R10
__cpp_lib_shared_ mutex std::shared_mutex (비시간 제한) 201505L (C++17) N4508
__cpp_lib_shared_ ptr_arrays std::shared_ptr<T[]> 201611L (C++17) P0497R0
배열 지원 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 및 std::shift_right 201806L (C++20) P0769R2
std::ranges::shift_left 와 std::ranges::shift_right 202202L (C++23) P2440R1
__cpp_lib_simd <simd> : 데이터 병렬 타입 202411L (C++26) P1928R15
P3430R3
P3441R2
P3287R3
P2933R4
__cpp_lib_simd_complex std::datapar::simd 에서 인터리브된 복소수 값 지원 202502L (C++26) P2663R7
__cpp_lib_smart_ ptr_for_overwrite 기본 초기화를 통한 스마트 포인터 생성 ( 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 std::weak_ptr 를 비정렬 연관 컨테이너 에서 키로 사용할 수 있도록 함 202306L (C++26) P1901R2
__cpp_lib_source_ location 소스 코드 정보 캡처 ( std::source_location ) 201907L (C++20) P1208R6
__cpp_lib_span std::span 202002L (C++20) P0122R7
LWG3274
P1024R3
P1976R2
std::span 의 일부를 독립 실행형으로 만들기 202311L (C++26) P2821R5
P2833R2
__cpp_lib_span_initializer_ list 이니셜라이저 리스트로부터 std::span 생성하기 202311L (C++26) P2447R6
__cpp_lib_spanstream std::spanbuf , std::spanstream 202106L (C++23) P0448R4
__cpp_lib_ssize std::ssize 및 부호 없는 std::span::size 201902L (C++20) P1227R2
__cpp_lib_sstream_ from_string_view std::stringstream 과 std::string_view 간의 연동 202306L (C++26) P2495R3
__cpp_lib_stacktrace 스택 트레이스 라이브러리 202011L (C++23) P0881R7
__cpp_lib_start_ lifetime_as 명시적 수명 관리 ( std::start_lifetime_as ) 202207L (C++23) P2590R2
__cpp_lib_starts_ ends_with 문자열 접두사 및 접미사 검사 ( starts_with() 및 ends_with() 함수, std::string 및 std::string_view 대상) 201711L (C++20) P0457R2
__cpp_lib_stdatomic_ h C 원자 연산을 위한 호환성 헤더 202011L (C++23) P0943R6
__cpp_lib_string_ contains contains() for std::basic_string and 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 문자열 타입을 위한 사용자 정의 리터럴 201304L (C++14) N3642
__cpp_lib_string_ view std::string_view 201606L (C++17) P0220R1
P0254R2
ConstexprIterator 201803L (C++20) P0858R0
LWG3257
연결 of std::string s and std::string_view s 202403L (C++26) P2591R5
__cpp_lib_submdspan std::submdspan 202306L (C++26) P2630R4
패딩된 mdspan 레이아웃 202403L P2642R6
__cpp_lib_syncbuf 동기화된 버퍼링된 ostream ( std::syncbuf , std::osyncstream ) 및 조작자 201803L (C++20) P0053R7
P0753R2
__cpp_lib_text_encoding std::text_encoding 202306L (C++26) P1885R12
__cpp_lib_three_ way_comparison 3-way 비교 (라이브러리 지원); 라이브러리에 3-way 비교 추가 201907L (C++20) P0768R1
P1614R2
__cpp_lib_to_address 포인터를 원시 포인터로 변환하는 유틸리티 ( std::to_address ) 201711L (C++20) P0653R2
__cpp_lib_to_array std::to_array 201907L (C++20) P0325R4
__cpp_lib_to_array std::to_array 201907L (C++20) P0325R4
__cpp_lib_to_chars 기본 문자열 변환 ( std::to_chars , std::from_chars ) 201611L (C++17) P0067R5
P0682R1
LWG3137
<charconv> 함수들의 성공 또는 실패 테스트 202306L (C++26) P2497R0
__cpp_lib_to_string std::to_string 를 std::format 관점에서 재정의 202306L (C++26) P2587R3
__cpp_lib_to_underlying std::to_underlying 202102L (C++23) P1682R3
__cpp_lib_transformation_ trait_aliases 변환 특성에 대한 별칭 템플릿 201304L (C++14) N3655
__cpp_lib_transparent_ operators 투명 연산자 함수 객체 ( std::less<> 등) 201210L (C++14) N3421
투명한 std::owner_less ( std::owner_less<void> ) 201510L (C++17) P0074R0
__cpp_lib_trivially_ relocatable 사소한 재배치 가능성 특성 및 연산 202502L (C++26) P2786R13
__cpp_lib_tuple_ element_t std::tuple_element_t 201402L (C++14) N3887
__cpp_lib_tuple_ like std::tuple 과 튜플-유사 객체들( std::pair , std::array , std::subrange ) 간의 호환성 202207L (C++23) P2165R4
튜플 프로토콜을 std::complex 에 추가 202311L (C++26) P2819R2
__cpp_lib_tuples_ by_type 타입별 튜플 접근 201304L (C++14) N3670
__cpp_lib_type_identity std::type_identity 201806L (C++20) P0887R1
__cpp_lib_type_trait_ variable_templates 타입 특성 변수 템플릿 ( std::is_void_v , 등) 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 및 std::unwrap_reference 201811L (C++20) P0318R1
LWG3348
__cpp_lib_variant std::variant : C++17을 위한 타입 안전한 유니온 201606L (C++17) P0088R3
P0393R3
P0032R3
std::visit std::variant 에서 파생된 클래스용 202102L (C++23)
(DR17) 		P2162R2
완전히 constexpr std::variant 202106L (C++23)
(DR20) 		P2231R1
멤버 visit 202306L (C++26) P2637R3
__cpp_lib_void_t std::void_t 201411L (C++17) N3911
전체 매크로 수: 282

예제

일반적인 사용법

이 코드 실행 
#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() {}

컴파일러 기능 덤프

다음 (C++11 호환) 프로그램은 C++ 컴파일러 기능과 속성들을 출력합니다. __has_cpp_attribute ( ) 사용은 표준 준수 가 아니며 gcc/clang 구현에 의존합니다.

이 코드 실행 
static constexpr struct choose_what_and_how_to_print
{
    constexpr static int longest_macro_name { 45 };
    constexpr static bool titles               = 1;
    constexpr static bool counters             = 1;
    constexpr static bool attributes           = 1;
    constexpr static bool standard_values      = 1;
    constexpr static bool compiler_specific    = 1;
    constexpr static bool core_features        = 1;
    constexpr static bool lib_features         = 1;
    constexpr static bool supported_features   = 1;
    constexpr static bool unsupported_features = 1;
    constexpr static bool sort_by_date         = 0;
    constexpr static bool separate_year_month  = 1;
    constexpr static bool separated_revisions  = 1;
    constexpr static bool latest_revisions     = 1;
    constexpr static bool cxx98                = 0;
    constexpr static bool cxx11                = 1;
    constexpr static bool cxx14                = 1;
    constexpr static bool cxx17                = 1;
    constexpr static bool cxx20                = 1;
    constexpr static bool cxx23                = 1;
    constexpr static bool cxx26                = 1;
    constexpr static bool cxx29                = 0;
} print;
#if __cplusplus < 201100
#  error "C++11 이상이 필요합니다"
#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
// 6자리 10진수 숫자로 시작하거나 '_'로 시작하는 문자열을 예상합니다 (지원되지 않는 경우)
#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; }
};
// FTM이 아닌 매크로들, 구현체별 매크로 포함:
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__)
    // Optional <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__)
    // 선호하는 구현별 매크로를 추가하세요...
    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[] = {
    //< 계속해서 채우기
    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[] = {
    //< 계속 채우기
    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[] = {
    //< 계속 채우기
    COMPILER_FEATURE_ENTRY(202604L, __cpp_core_TODO)
};
static constexpr CompilerFeature cxx29_lib[] = {
    //< 계속해서 채우기
    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("기타 매크로:\n");
    for (auto co : compiler)
        if (std::strcmp(co.first, co.second))
            std::printf("%*s %s\n", -print.longest_macro_name, co.first, co.second);
}
inline void print_compiler_feature(const CompilerFeature& x)
{
    if (not ((print.supported_features and x.maybe()) or
            (print.unsupported_features and not x.maybe())))
        return;
    auto print_year_month = [](long n)
    {
        return std::printf("%ld%s%02ld",
            n / 100, print.separate_year_month ? "-" : "", n % 100);
    };
    std::printf("%*s ", -print.longest_macro_name, x.name());
    x.maybe() ? print_year_month(x.data()) :
                    std::printf("------%s", print.separate_year_month ? "-" : "");
    if (print.standard_values)
        std::printf("  %c  ", (x.supported() ? (x.data() > x.std() ? '>' : '=') : '<')),
            print_year_month(x.std());
    std::puts("");
}
template<class Container>
inline void show(char const* const title, Container const& co)
{
    if (print.titles)
    {
        std::printf("%-s (", title);
        if (print.counters)
        {
            std::printf("%zd/", std::count_if(std::begin(co), std::end(co),
                [](CompilerFeature x)
                {
                    return x.supported();
                }));
        }
        std::printf("%td)\n", std::distance(std::begin(co), std::end(co)));
    }
    if (print.sort_by_date)
    {
        std::vector<CompilerFeature> v(std::begin(co), std::end(co));
        std::stable_sort(v.begin(), v.end(),
            [](CompilerFeature const& lhs, CompilerFeature const& rhs)
            {
                return lhs.data() < rhs.data();
            });
        std::for_each(v.cbegin(), v.cend(), print_compiler_feature);
    }
    else
        std::for_each(std::begin(co), std::end(co), print_compiler_feature);
    std::puts("");
}
inline void show_latest()
{
    auto latest_rev = []() -> int
    {
        return print.cxx29 ? 29 : print.cxx26 ? 26 : print.cxx23 ? 23 : print.cxx20 ? 20 :
               print.cxx17 ? 17 : print.cxx14 ? 14 : print.cxx11 ? 11 : 98;
    };
    std::vector<CompilerFeature> latest;
    auto add = [&latest](CompilerFeature x)
    {
        auto i = std::lower_bound(latest.begin(), latest.end(), x);
        if (i == latest.end() or not (*i == x))
            latest.insert(i, x);
        else if (i->data() < x.data())
            i->data(x.data());
    };
    char text[64];
    latest.reserve(512); // max 매크로
    if (print.core_features)
    {   // 역순 개정 삽입 순서를 유지하세요!
        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, "C++%02i까지의 모든 핵심 매크로", latest_rev());
        show(text, latest);
    }
    latest.clear();
    if (print.lib_features)
    {   // 역순 개정 삽입 순서를 유지하세요!
        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, "C++%02i까지의 모든 라이브러리 매크로", latest_rev());
        show(text, latest);
    }
}
int main()
{
    if (print.separated_revisions)
    {
        if (print.cxx98 and print.core_features) show("C++98 CORE", cxx98_core);
        if (print.cxx11 and print.core_features) show("C++11 CORE", cxx11_core);
        if (print.cxx14 and print.core_features) show("C++14 CORE", cxx14_core);
        if (print.cxx14 and print.lib_features ) show("C++14 LIB" , cxx14_lib);
        if (print.cxx17 and print.core_features) show("C++17 코어", 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 코어", 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 라이브러리" , cxx23_lib);
        if (print.cxx26 and print.core_features) show("C++26 CORE", cxx26_core);
        if (print.cxx26 and print.lib_features ) show("C++26 LIB" , cxx26_lib);
        if (print.cxx29 and print.core_features) show("C++29 CORE", cxx29_core);
        if (print.cxx29 and print.lib_features ) show("C++29 LIB" , cxx29_lib);
    }
    if (print.latest_revisions) show_latest();
    if (print.attributes) show("ATTRIBUTES", attributes);
    if (print.compiler_specific) show_compiler_specific_info();
}

가능한 출력: 

C++11 코어 (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
... 생략 ...
C++14 코어 (9/9)
__cpp_aggregate_nsdmi                         2013-04  =  2013-04
__cpp_binary_literals                         2013-04  =  2013-04
__cpp_constexpr                               2022-11  >  2013-04
... 생략 ...
C++14 라이브러리 (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
... 생략 ...
... 생략 ...
C++23 라이브러리 (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
... 생략 ...
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
... 생략 ...
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
... 생략 ...
속성 (9/11)
assume                                        2022-07  =  2022-07
carries_dependency                            -------  <  2008-09
deprecated                                    2013-09  =  2013-09
fallthrough                                   2016-03  =  2016-03
... 생략 ...
기타 매크로:
__cplusplus                                   202302L
__GNUG__                                      14
__GNUC_MINOR__                                2
__GNUC_PATCHLEVEL__                           0
__STDCPP_FLOAT16_T__                          1
__STDCPP_FLOAT32_T__                          1
... 생략 ...

결함 보고서

다음의 동작 변경 결함 보고서들은 이전에 발표된 C++ 표준에 소급 적용되었습니다.

DR 적용 대상 게시된 동작 올바른 동작
P2552R3 C++20 __has_cpp_attribute 는 표준 속성에 대해 0이 아닌 값으로 확장되어야 함 ​ 0 ​ 으로 확장될 수 있음

참고 항목

라이브러리 기능 테스트 매크로 (C++20) 헤더 파일에 정의됨 <version>
사전 정의된 매크로 심볼
매크로 심볼 인덱스

외부 링크

1. 기능 테스트 권장사항 공식 문서
2. 컴파일러 기능 덤프 소스 코드