Chapter 1. Status

Table of Contents

Implementation Status
C++ 1998/2003
Implementation Status
Implementation Specific Behavior
C++ 2011
Implementation Specific Behavior
C++ 2014
Implementation Specific Behavior
Filesystem TS
C++ 2017
Implementation Specific Behavior
C++ 2020
C++ TR1
Implementation Specific Behavior
C++ TR 24733
C++ IS 29124
Implementation Specific Behavior
License
The Code: GPL
The Documentation: GPL, FDL
Bugs
Implementation Bugs
Standard Bugs

Implementation Status

C++ 1998/2003

Implementation Status

This status table is based on the table of contents of ISO/IEC 14882:2003.

This section describes the C++ support in the GCC 10 release series.

Table 1.1. C++ 1998/2003 Implementation Status

SectionDescriptionStatusComments
18 Language support
18.1TypesY 
18.2Implementation propertiesY 
18.2.1Numeric Limits  
18.2.1.1Class template numeric_limitsY 
18.2.1.2numeric_limits membersY 
18.2.1.3float_round_styleY 
18.2.1.4float_denorm_styleY 
18.2.1.5numeric_limits specializationsY 
18.2.2C LibraryY 
18.3Start and terminationY 
18.4Dynamic memory managementY 
18.5Type identification  
18.5.1Class type_infoY 
18.5.2Class bad_castY 
18.5.3Class bad_typeidY 
18.6Exception handling  
18.6.1Class exceptionY 
18.6.2Violation exception-specificationsY 
18.6.3Abnormal terminationY 
18.6.4uncaught_exceptionY 
18.7Other runtime supportY 
19 Diagnostics
19.1Exception classesY 
19.2AssertionsY 
19.3Error numbersY 
20 General utilities
20.1RequirementsY 
20.2Utility components  
20.2.1OperatorsY 
20.2.2pairY 
20.3Function objects  
20.3.1BaseY 
20.3.2Arithmetic operationY 
20.3.3ComparisonsY 
20.3.4Logical operationsY 
20.3.5NegatorsY 
20.3.6BindersY 
20.3.7Adaptors for pointers to functionsY 
20.3.8Adaptors for pointers to membersY 
20.4Memory  
20.4.1The default allocatorY 
20.4.2Raw storage iteratorY 
20.4.3Temporary buffersY 
20.4.4Specialized algorithmsY 
20.4.4.1uninitialized_copyY 
20.4.4.2uninitialized_fillY 
20.4.4.3uninitialized_fill_nY 
20.4.5Class template auto_ptrY 
20.4.6C libraryY 
21 Strings
21.1Character traits  
21.1.1Character traits requirementsY 
21.1.2traits typedefY 
21.1.3char_traits specializations  
21.1.3.1struct char_traits<char>Y 
21.1.3.2struct char_traits<wchar_t>Y 
21.2String classesY 
21.3Class template basic_stringY 
21.4Null-terminated sequence utilitiesYC library dependency
22 Localization
22.1Locales  
22.1.1Class localeY 
22.1.2locale globalsY 
22.1.3Convenience interfaces  
22.1.3.1Character classificationY 
22.1.3.2Character conversionsY 
22.2Standard locale categories  
22.2.1ctypeY 
22.2.2Numeric  
22.2.2.1num_getY 
22.2.2.2num_putY 
22.2.3num_punctY 
22.2.4collateY 
22.2.5Time  
22.2.5.1time_getY 
22.2.5.2time_get_bynameY 
22.2.5.3time_putY 
22.2.5.3time_put_bynameY 
22.2.6Monetary  
22.2.6.1money_getY 
22.2.6.2money_putY 
22.2.6.3money_punctY 
22.2.6.4money_punct_bynameY 
22.2.7messagesY 
22.2.8Program-defined facetsY 
22.3C Library LocalesY 
23 Containers
23.1Container requirementsY 
23.2Sequence containers  
23.2.1Class template dequeY 
23.2.2Class template listY 
23.2.3Adaptors  
23.2.3.1Class template queueY 
23.2.3.2Class template priority_queueY 
23.2.3.3Class template stackY 
23.2.4Class template vectorY 
23.2.5Class vector<bool>Y 
23.3Associative containers  
23.3.1Class template mapY 
23.3.2Class template multimapY 
23.3.3Class template setY 
23.3.4Class template multisetY 
24 Iterators
24.1RequirementsY 
24.2Header <iterator> synopsisY 
24.3Iterator primitivesY 
24.4Predefined iterators and Iterator adaptors  
24.4.1Reverse iteratorsY 
24.4.2Insert iteratorsY 
24.5Stream iterators  
24.5.1Class template istream_iteratorY 
24.5.2Class template ostream_iteratorY 
24.5.3Class template istreambuf_iteratorY 
24.5.4Class template ostreambuf_iteratorY 
25 Algorithms
25.1Non-modifying sequence operationsY 
25.2Mutating sequence operationsY 
25.3Sorting and related operationsY 
25.4C library algorithmsY 
26 Numerics
26.1Numeric type requirementsY 
26.2Complex numbersY 
26.3Numeric arrays  
26.3.1Header <valarray> synopsisY 
26.3.2Class template valarrayY 
26.3.3valarray non-member operationsY 
26.3.4Class sliceY 
26.3.5Class template slice_arrayY 
26.3.6Class gsliceY 
26.3.7Class template gslice_arrayY 
26.3.8Class template mask_arrayY 
26.3.9Class template indirect_arrayY 
26.4Generalized numeric operations  
26.4.1accumulateY 
26.4.2inner_productY 
26.4.3partial_sumY 
26.4.4adjacent_differenceY 
26.4.5iotaY 
26.5C LibraryY 
27 Input/output
27.1RequirementsY 
27.2Forward declarationsY 
27.3Standard iostream objectsY 
27.3.1Narrow stream objectsY 
27.3.2Wide stream objectsY 
27.4Iostreams base classesY 
27.5Stream buffersY 
27.6Formatting and manipulatorsY 
27.7String-based streamsY 
27.8File-based streamsY 
Appendix D Compatibility features
D.1Increment operator with bool operand  
D.2static keyword  
D.3Access declarations  
D.4Implicit conversion from const strings  
D.5C standard library headers  
D.6Old iostreams members  
D.7char* streams  

Implementation Specific Behavior

The ISO standard defines the following phrase:

[1.3.5] implementation-defined behavior

Behavior, for a well-formed program construct and correct data, that depends on the implementation and that each implementation shall document.

We do so here, for the C++ library only. Behavior of the compiler, linker, runtime loader, and other elements of "the implementation" are documented elsewhere. Everything listed in Annex B, Implementation Qualities, are also part of the compiler, not the library.

For each entry, we give the section number of the standard, when applicable. This list is probably incomplet and inkorrekt.

[1.9]/11 #3 If isatty(3) is true, then interactive stream support is implied.

[17.4.4.5] Non-reentrant functions are probably best discussed in the various sections on multithreading (see above).

[18.1]/4 The type of NULL is described under Support.

[18.3]/8 Even though it's listed in the library sections, libstdc++ has zero control over what the cleanup code hands back to the runtime loader. Talk to the compiler people. :-)

[18.4.2.1]/5 (bad_alloc), [18.5.2]/5 (bad_cast), [18.5.3]/5 (bad_typeid), [18.6.1]/8 (exception), [18.6.2.1]/5 (bad_exception): The what() member function of class std::exception, and these other classes publicly derived from it, returns the name of the class, e.g. "std::bad_alloc".

[18.5.1]/7 The return value of std::type_info::name() is the mangled type name. You will need to call c++filt and pass the names as command-line parameters to demangle them, or call a runtime demangler function.

[20.1.5]/5 "Implementors are encouraged to supply libraries that can accept allocators that encapsulate more general memory models and that support non-equal instances. In such implementations, any requirements imposed on allocators by containers beyond those requirements that appear in Table 32, and the semantics of containers and algorithms when allocator instances compare non-equal, are implementation-defined." There is experimental support for non-equal allocators in the standard containers in C++98 mode. There are no additional requirements on allocators. It is undefined behaviour to swap two containers if their allocators are not equal.

[21.1.3.1]/3,4, [21.1.3.2]/2, [21.3]/6 basic_string::iterator, basic_string::const_iterator, [23.*]'s foo::iterator, [27.*]'s foo::*_type, others... Nope, these types are called implementation-defined because you shouldn't be taking advantage of their underlying types. Listing them here would defeat the purpose. :-)

[21.1.3.1]/5 I don't really know about the mbstate_t stuff... see the codecvt notes for what does exist.

[22.*] Anything and everything we have on locale implementation will be described under Localization.

[23.*] All of the containers in this clause define size_type as std::size_t and difference_type as std::ptrdiff_t.

[26.2.8]/9 I have no idea what complex<T>'s pow(0,0) returns.

[27.4.2.4]/2 Calling std::ios_base::sync_with_stdio after I/O has already been performed on the standard stream objects will flush the buffers, and destroy and recreate the underlying buffer instances. Whether or not the previously-written I/O is destroyed in this process depends mostly on the --enable-libio choice: for stdio, if the written data is already in the stdio buffer, the data may be completely safe!

[27.6.1.1.2], [27.6.2.3] The I/O sentry ctor and dtor can perform additional work than the minimum required. We are not currently taking advantage of this yet.

[27.7.1.3]/16, [27.8.1.4]/10 The effects of pubsetbuf/setbuf are described in the Input and Output chapter.

[27.8.1.4]/16 Calling fstream::sync when a get area exists will... whatever fflush() does, I think.

C++ 2011

This table is based on the table of contents of ISO/IEC JTC1 SC22 WG21 Doc No: N3290 Date: 2011-04-11 Final Draft International Standard, Standard for Programming Language C++

In this implementation the -std=gnu++11 or -std=c++11 flag must be used to enable language and library features. See dialect options. The pre-defined symbol __cplusplus is used to check for the presence of the required flag. GCC 5.1 was the first release with non-experimental C++11 support, so the API and ABI of features added in C++11 is only stable since that release.

This status table is based on the table of contents of ISO/IEC 14882:2011.

This section describes the C++11 support in the GCC 10 release series.

Table 1.2. C++ 2011 Implementation Status

SectionDescriptionStatusComments
18 Language support
18.1General  
18.2TypesY 
18.3Implementation properties  
18.3.2Numeric Limits  
18.3.2.3Class template numeric_limitsY 
18.3.2.4numeric_limits membersY 
18.3.2.5float_round_styleN 
18.3.2.6float_denorm_styleN 
18.3.2.7numeric_limits specializationsY 
18.3.3C LibraryY 
18.4Integer types  
18.4.1Header <cstdint> synopsisY 
18.5Start and terminationPartialC library dependency for quick_exit, at_quick_exit
18.6Dynamic memory managementY 
18.7Type identification  
18.7.1Class type_infoY 
18.7.2Class bad_castY 
18.7.3Class bad_typeidY 
18.8Exception handling  
18.8.1Class exceptionY 
18.8.2Class bad_exceptionY 
18.8.3Abnormal terminationY 
18.8.4uncaught_exceptionY 
18.8.5Exception PropagationY 
18.8.6nested_exceptionY 
18.9Initializer lists  
18.9.1Initializer list constructorsY 
18.9.2Initializer list accessY 
18.9.3Initializer list range accessY 
18.10Other runtime supportY 
19 Diagnostics
19.1General  
19.2Exception classesY 
19.3AssertionsY 
19.4Error numbersY 
19.5System error support  
19.5.1Class error_categoryY 
19.5.2Class error_codeY 
19.5.3Class error_conditionY 
19.5.4Comparison operatorsY 
19.5.5Class system_errorY 
20 General utilities
20.1General  
20.2Utility components  
20.2.1OperatorsY 
20.2.2swapY 
20.2.3forward/move helpersY 
20.2.4Function template declvalY 
20.3Pairs  
20.3.1In general  
20.3.2Class template pairY 
20.3.3Specialized algorithmsY 
20.3.4Tuple-like access to pairY 
20.3.5Piecewise constructionY 
20.4Tuples  
20.4.1In general  
20.4.2Class template tuple  
20.4.2.1ConstructionY 
20.4.2.2AssignmentY 
20.4.2.3SwapY 
20.4.2.4Tuple creation functionsY 
20.4.2.5Tuple helper classesY 
20.4.2.6Element accessY 
20.4.2.7Relational operatorsY 
20.4.2.8Tuple traitsY 
20.4.2.9Tuple specialized algorithmsY 
20.5Class template bitsetY 
20.5.1bitset constructorsY 
20.5.2bitset membersY 
20.5.3bitset hash supportY 
20.5.4bitset operatorsY 
20.6Memory  
20.6.1In general  
20.6.2Header <memory> synopsis  
20.6.3Pointer traitsY 
20.6.4Pointer safetyY 
20.6.5AlignY 
20.6.6Allocator argument tagY 
20.6.7uses_allocatorY 
20.6.8Allocator traitsY 
20.6.9The default allocatorY 
20.6.10Raw storage iteratorY 
20.6.11Temporary buffersY 
20.6.12Specialized algorithms  
20.6.12.1addressofY 
20.6.12.2uninitialized_copyY 
20.6.12.3uninitialized_fillY 
20.6.12.4uninitialized_fill_nY 
20.6.13C libraryY 
20.7Smart pointers  
20.7.1Class template unique_ptrY 
20.7.2Shared-ownership pointers  
20.7.2.1Class bad_weak_ptrY 
20.7.2.2Class template shared_ptrY Uses code from boost::shared_ptr.
20.7.2.3Class template weak_ptrY 
20.7.2.4Class template enable_shared_from_thisY 
20.7.2.5shared_ptr atomic accessY 
20.7.2.6Smart pointer hash supportY 
20.8Function objects  
20.8.1Definitions  
20.8.2Requirements  
20.8.3Class template reference_wrapperY 
20.8.4Arithmetic operationY 
20.8.5ComparisonsY 
20.8.6Logical operationsY 
20.8.7Bitwise operationsY 
20.8.8NegatorsY 
20.8.9Function template bindY 
20.8.10Function template mem_fnY 
20.8.11Polymorphic function wrappers  
20.8.11.1Class bad_function_callY 
20.8.11.2Class template functionPartialMissing allocator support
20.8.12Class template hashY 
20.9Metaprogramming and type traits  
20.9.1RequirementsY 
20.9.2Header <type_traits> synopsis  
20.9.3Helper classesY 
20.9.4Unary Type TraitsY 
20.9.4.1Primary type categoriesY 
20.9.4.2Composite type traitsY 
20.9.4.3Type propertiesY 
20.9.5Type property queriesY 
20.9.6Relationships between typesY 
20.9.7Transformations between types  
20.9.7.1Const-volatile modificationsY 
20.9.7.2Reference modificationsY 
20.9.7.3Sign modificationsY 
20.9.7.4Array modificationsY 
20.9.7.5Pointer modificationsY 
20.9.7.6Other transformationsY 
20.10Compile-time rational arithmetic  
20.10.1In general  
20.10.2Header <ratio> synopsis  
20.10.3Class template ratioY 
20.10.4Arithmetic on ratiosY 
20.10.5Comparison of ratiosY 
20.10.6SI types for ratioY 
20.11Time utilities  
20.11.3Clock requirementsY 
20.11.4Time-related traits  
20.11.4.1treat_as_floating_pointY 
20.11.4.2duration_valuesY 
20.11.4.3Specializations of common_typeY 
20.11.5Class template durationY 
20.11.6Class template time_pointY 
20.11.7Clocks  
20.11.7.1Class system_clockY 
20.11.7.2Class steady_clockY 
20.11.7.3Class high_resolution_clockY 
20.11.8Date and time functionsY 
20.12Scoped allocator adaptorY 
20.12.1Header <scoped_allocator> synopsis  
20.12.2Scoped allocator adaptor member typesY 
20.12.3Scoped allocator adaptor constructorsY 
20.12.4Scoped allocator adaptor membersY 
20.12.5Scoped allocator operatorsY 
20.13Class type_indexY 
21 Strings
21.1GeneralY 
21.2Character traits  
21.2.1Character traits requirementsY 
21.2.2traits typedefsY 
21.2.3char_traits specializations  
21.2.3.1struct char_traits<char>Y 
21.2.3.2struct char_traits<char16_t>Y 
21.2.3.3struct char_traits<char32_t>Y 
21.2.3.4struct char_traits<wchar_t>Y 
21.3String classesY 
21.4Class template basic_stringY 
21.5Numeric ConversionsY 
21.6Hash supportY 
21.7Null-terminated sequence utilitiesPartialC library dependency.
22 Localization
22.1GeneralY 
22.2Header <locale> synopsisY 
22.3Locales  
22.3.1Class localeY 
22.3.2locale globalsY 
22.3.3Convenience interfaces  
22.3.3.1Character classificationY 
22.3.3.2Conversions  
22.3.3.2.1Character conversionsY 
22.3.3.2.2string conversionsY 
22.3.3.2.3Buffer conversionsY 
22.4Standard locale categories  
22.4.1The ctype categoryY 
22.4.2The numeric category  
22.4.2.1num_getY 
22.4.2.2num_putY 
22.4.3The numeric punctuation facetY 
22.4.4The collate categoryY 
22.4.5The time category  
22.4.5.1Class template time_getY 
22.4.5.2Class template time_get_bynameY 
22.4.5.3Class template time_putY 
22.4.5.3Class template time_put_bynameY 
22.4.6The monetary category  
22.4.6.1Class template money_getY 
22.4.6.2Class template money_putY 
22.4.6.3Class template money_punctY 
22.4.6.4Class template money_punct_bynameY 
22.4.7The message retrieval categoryY 
22.4.8Program-defined facetsY 
22.5Standard code conversion facetsY 
22.6C Library LocalesY 
23 Containers
23.1General  
23.2Container requirements  
23.2.1General container requirementsY 
23.2.2Container data racesY 
23.2.3Sequence containersY 
23.2.4Associative containersY 
23.2.5Unordered associative containersY 
23.3Sequence containers  
23.3.2Class template arrayY 
23.3.3Class template dequeY 
23.3.4Class template forward_listY 
23.3.5Class template listY 
23.3.6Class template vectorY 
23.3.7Class vector<bool>Y 
23.4Associative containers  
23.4.4Class template mapY 
23.4.5Class template multimapY 
23.4.6Class template setY 
23.4.7Class template multisetY 
23.5Unordered associative containers  
23.5.4Class template unordered_mapY 
23.5.5Class template unordered_multimapY 
23.5.6Class template unordered_setY 
23.5.7Class template unordered_multisetY 
23.6Container adaptors  
23.6.1Class template queueY 
23.6.2Class template priority_queueY 
23.6.3Class template stackY 
24 Iterators
24.1GeneralY 
24.2Iterator requirementsY 
24.3Header <iterator> synopsisY 
24.4Iterator primitivesY 
24.5Iterator adaptors  
24.5.1Reverse iteratorsY 
24.5.2Insert iteratorsY 
24.5.3Move iteratorsY 
24.6Stream iterators  
24.6.1Class template istream_iteratorY 
24.6.2Class template ostream_iteratorY 
24.6.3Class template istreambuf_iteratorY 
24.6.4Class template ostreambuf_iteratorY 
24.6.5range accessY 
25 Algorithms
25.1General  
25.2Non-modifying sequence operationsY 
25.3Mutating sequence operationsY 
25.4Sorting and related operationsY 
25.5C library algorithmsY 
26 Numerics
26.1General  
26.2Numeric type requirementsY 
26.3The floating-point environmentY 
26.4Complex numbersY 
26.5Random number generation  
26.5.1Requirements  
26.5.2Header <random> synopsis  
26.5.3Random number engine class templates  
26.5.3.1Class template linear_congruential_engineY 
26.5.3.2Class template mersenne_twister_engineY 
26.5.3.3Class template subtract_with_carry_engineY 
26.5.4Random number engine adaptor class templates  
26.5.4.2Class template discard_block_engineY 
26.5.4.3Class template independent_bits_engineY 
26.5.4.4Class template shuffle_order_engineY 
26.5.5Engines and engine adaptors with predefined parametersY 
26.5.6Class random_deviceY 
26.5.7Utilities  
26.5.7.1Class seed_seqY 
26.5.7.2Function template generate_canonicalY 
26.5.8Random number distribution class templates  
26.5.8.2Uniform distributions  
26.5.8.2.1Class template uniform_int_distributionY 
26.5.8.2.2Class template uniform_real_distributionY 
26.5.8.3Bernoulli distributions  
26.5.8.3.1Class bernoulli_distributionY 
26.5.8.3.2Class template binomial_distributionY 
26.5.8.3.3Class template geometric_distributionY 
26.5.8.3.4Class template negative_binomial_distributionY 
26.5.8.4Poisson distributions  
26.5.8.4.1Class template poisson_distributionY 
26.5.8.4.2Class template exponential_distributionY 
26.5.8.4.3Class template gamma_distributionY 
26.5.8.4.4Class template weibull_distributionY 
26.5.8.4.5Class template extreme_value_distributionY 
26.5.8.5Normal distributions  
26.5.8.5.1Class template normal_distributionY 
26.5.8.5.2Class template lognormal_distributionY 
26.5.8.5.3Class template chi_squared_distributionY 
26.5.8.5.4Class template cauchy_distributionY 
26.5.8.5.5Class template fisher_f_distributionY 
26.5.8.5.6Class template student_t_distributionY 
26.5.8.6Sampling distributions  
26.5.8.6.1Class template discrete_distributionY 
26.5.8.6.2Class template piecewise_constant_distributionY 
26.5.8.6.3Class template piecewise_linear_distributionY 
26.6Numeric arrays  
26.6.1Header <valarray> synopsisY 
26.6.2Class template valarrayY 
26.6.3valarray non-member operationsY 
26.6.4Class sliceY 
26.6.5Class template slice_arrayY 
26.6.6The gslice classY 
26.6.7Class template gslice_arrayY 
26.6.8Class template mask_arrayY 
26.6.9Class template indirect_arrayY 
26.6.10valarray range accessY 
26.7Generalized numeric operations  
26.7.1Header <numeric> synopsisY 
26.7.2Accumulate>Y 
26.7.3Inner productY 
26.7.4Partial sumY 
26.7.5Adjacent differenceY 
26.7.6IotaY 
26.8C LibraryY 
27 Input/output library
27.1GeneralY 
27.2Iostreams requirementsY 
27.2.1Imbue LimitationsY 
27.2.2Positioning Type LimitationsY 
27.2.3Thread safetyPartial 
27.3Forward declarationsY 
27.4Standard iostream objectsY 
27.4.1OverviewY 
27.4.2Narrow stream objectsY 
27.4.3Wide stream objectsY 
27.5Iostreams base classesY 
27.6Stream buffersY 
27.7Formatting and manipulatorsY 
27.8String-based streamsY 
27.9File-based streamsY 
28 Regular expressions
28.1GeneralY 
28.2DefinitionsY 
28.3RequirementsY 
28.4Header <regex> synopsisY 
28.5Namespace std::regex_constantsY 
28.6Class regex_errorY 
28.7Class template regex_traitsPartialtransform_primary is not correctly implemented 
28.8Class template basic_regexY 
28.9Class template sub_matchY 
28.10Class template match_resultsY 
28.11Regular expression algorithmsY 
28.12Regular expression IteratorsY 
28.13Modified ECMAScript regular expression grammarY 
29 Atomic operations
29.1GeneralY 
29.2Header <atomic> synopsisY 
29.3Order and consistencyY 
29.4Lock-free propertyY 
29.5Atomic typesY 
29.6Operations on atomic typesY 
29.7Flag Type and operationsY 
29.8FencesY 
30 Thread support
30.1GeneralY 
30.2RequirementsY 
30.3Threads  
30.3.1Class threadPartialthread::id comparisons not well-defined
30.3.2Namespace this_threadY 
30.4Mutual exclusion  
30.4.1Mutex requirements  
30.4.1.1In general  
30.4.1.2Mutex types  
30.4.1.2.1Class mutexY 
30.4.1.2.2Class recursive_mutexY 
30.4.1.3Timed mutex types  
30.4.1.3.1Class timed_mutexY 
30.4.1.3.2Class recursive_timed_mutexY 
30.4.2Locks  
30.4.2.1Class template lock_guardY 
30.4.2.2Class template unique_lockY 
30.4.3Generic locking algorithmsY 
30.4.4Call once  
30.4.4.1Struct once_flagY 
30.4.4.2Function call_onceBrokenSee PR 66146
30.5Condition variablesY 
30.5.1Class condition_variableY 
30.5.2Class condition_variable_anyY 
30.6Futures  
30.6.1Overview  
30.6.2Error handlingY 
30.6.3Class future_errorY 
30.6.4Shared stateY 
30.6.5Class template promiseY 
30.6.6Class template futureY 
30.6.7Class template shared_futureY 
30.6.8Function template asyncY 
30.6.9Class template packaged_taskY 
Appendix D Compatibility features
D.1Increment operator with bool operand  
D.2register keyword  
D.3Implicit declaration of copy functions  
D.4Dynamic exception specifications  
D.5C standard library headersY 
D.6Old iostreams membersY 
D.7char* streamsY 
D.8Function objectsY 
D.9BindersY 
D.10auto_ptrY 
D.11Violating exception-specificationsY 

Implementation Specific Behavior

For behaviour which is also specified by the 1998 and 2003 standards, see C++ 1998/2003 Implementation Specific Behavior. This section only documents behaviour which is new in the 2011 standard.

17.6.5.12 [res.on.exception.handling] There are no implementation-defined exception classes, only standard exception classes (or classes derived from them) will be thrown.

17.6.5.14 [value.error.codes] The error_category for errors originating outside the OS, and the possible error code values for each error category, should be documented here.

18.6.2.2 [new.badlength] what() returns "std::bad_array_new_length".

20.6.9.1 [allocator.member]/5 Over-aligned types are not supported by std::allocator.

20.7.2.2.1 [util.smartptr.shared.const] When a shared_ptr constructor fails bad_alloc (or types derived from it) will be thrown, or when an allocator is passed to the constructor then any exceptions thrown by the allocator.

20.7.2.0 [util.smartptr.weakptr] what() returns "bad_weak_ptr".

20.8.9.1.3 [func.bind.place]/1 There are 29 placeholders defined and the placeholder types are CopyAssignable.

20.11.7.1 [time.clock.system]/3, /4 Time point values are truncated to time_t values. There is no loss of precision for conversions in the other direction.

20.15.7 [meta.trans]/2 aligned_storage does not support extended alignment.

21.2.3.2 [char.traits.specializations.char16_t], 21.2.3.3 [char.traits.specializations.char32_t] The types u16streampos and u32streampos are both synonyms for fpos<mbstate_t>. The function eof returns int_type(-1). char_traits<char16_t>::to_int_type will transform the "noncharacter" U+FFFF to U+FFFD (REPLACEMENT CHARACTER). This is done to ensure that to_int_type never returns the same value as eof, which is U+FFFF.

22.3.1 [locale] There is one global locale for the whole program, not per-thread.

22.4.5.1.2 [locale.time.get.virtuals], 22.4.5.3.2 [locale.time.put.virtuals] Additional supported formats should be documented here.

22.4.7.1.2 [locale.messages.virtuals] The mapping should be documented here.

23.3.2.1 [array.overview] array<T, N>::iterator is T* and array<T, N>::const_iterator is const T*.

23.5.4.2 [unord.map.cnstr], 23.5.5.2 [unord.multimap.cnstr], 23.5.6.2 [unord.set.cnstr], 23.5.7.2 [unord.multiset.cnstr] The default minimal bucket count is 0 for the default constructors, range constructors and initializer-list constructors.

25.3.12 [alg.random.shuffle] The two-argument overload of random_shuffle uses rand as the source of randomness.

26.5.5 [rand.predef] The type default_random_engine is a synonym for minstd_rand0.

26.5.6 [rand.device] The token parameter of the random_device constructor can be used to select a specific source of random bytes. The valid token values are shown in the list below. The default constructor uses the token "default".

"default"
Select the first available source from the other entries below. This is the only token that is always valid.
"rand_s"
Use the MSVCRT rand_s function. This token is only valid for mingw-w64 targets.
"rdseed", "rdrand" or "rdrnd"
Use the IA-32 RDSEED or RDRAND instruction to read from an on-chip hardware random number generator. These tokens are only valid for x86 and x86_64 targets when both the assembler and CPU support the corresponding instruction.
"/dev/urandom", "/dev/random"
Use the named character special file to read random bytes from. These tokens are only valid when the device files are present and readable by the current user.
"mt19937", seed value
When no source of nondeterministic random numbers is available a mersenne_twister_engine will be used. An integer seed value can be used as the token and will be converted to an unsigned long using strtoul. These tokens are only valid when no other source of random bytes is available.

An exception of type runtime_error will be thrown if a random_device object is constructed with an invalid token, or if it cannot open or read from the source of random bytes.

26.5.8.1 [rand.dist.general] The algorithms used by the distributions should be documented here.

26.8 [c.math] Whether the rand function introduces data races depends on the C library as the function is not provided by libstdc++.

27.8.2.1 [stringbuf.cons] Whether the sequence pointers are copied by the basic_stringbuf move constructor should be documented here.

27.9.1.2 [filebuf.cons] Whether the sequence pointers are copied by the basic_filebuf move constructor should be documented here.

28.5.1 [re.synopt], 28.5.2 [re.matchflag] , 28.5.3 [re.err] syntax_option_type, match_flag_type and error_type are unscoped enumeration types.

28.7 [re.traits] The blank character class corresponds to the ctype_base::blank mask.

29.4 [atomics.lockfree] The values of the ATOMIC_xxx_LOCK_FREE macros depend on the target and cannot be listed here.

30.2.3 [thread.req.native]/1 native_handle_type and native_handle are provided. The handle types are defined in terms of the Gthreads abstraction layer, although this is subject to change at any time. Any use of native_handle is inherently non-portable and not guaranteed to work between major releases of GCC.

thread
The native handle type is a typedef for __gthread_t i.e. pthread_t when GCC is configured with the posix thread model. The value of the native handle is undefined for a thread which is not joinable.
mutex, timed_mutex
The native handle type is __gthread_mutex_t* i.e. pthread_mutex_t* for the posix thread model.
recursive_mutex, recursive_timed_mutex
The native handle type is __gthread_recursive_mutex_t* i.e. pthread_mutex_t* for the posix thread model.
condition_variable
The native handle type is __gthread_cond_t* i.e. pthread_cond_t* for the posix thread model.

30.6.1 [futures.overview]/2 launch is a scoped enumeration type with overloaded operators to support bitmask operations. There are no additional bitmask elements defined.

C++ 2014

In this implementation the -std=gnu++14 or -std=c++14 flag must be used to enable language and library features. See dialect options. The pre-defined symbol __cplusplus is used to check for the presence of the required flag. GCC 6.1 was the first release with non-experimental C++14 support, so the API and ABI of features added in C++14 is only stable since that release.

This status table is based on the table of contents of ISO/IEC 14882:2014. Some subclauses are not shown in the table where the content is unchanged since C++11 and the implementation is complete.

This section describes the C++14 and library TS support in the GCC 10 release series.

Table 1.3. C++ 2014 Implementation Status

SectionDescriptionStatusComments
18 Language support
18.1General  
18.2TypesY 
18.3Implementation properties  
18.3.2Numeric Limits  
18.3.2.3Class template numeric_limitsY 
18.3.2.4numeric_limits membersY 
18.3.2.5float_round_styleN 
18.3.2.6float_denorm_styleN 
18.3.2.7numeric_limits specializationsY 
18.3.3C LibraryY 
18.4Integer types  
18.4.1Header <cstdint> synopsisY 
18.5Start and terminationPartialC library dependency for quick_exit, at_quick_exit
18.6Dynamic memory managementY 
18.7Type identification  
18.7.1Class type_infoY 
18.7.2Class bad_castY 
18.7.3Class bad_typeidY 
18.8Exception handling  
18.8.1Class exceptionY 
18.8.2Class bad_exceptionY 
18.8.3Abnormal terminationY 
18.8.4uncaught_exceptionY 
18.8.5Exception PropagationY 
18.8.6nested_exceptionY 
18.9Initializer lists  
18.9.1Initializer list constructorsY 
18.9.2Initializer list accessY 
18.9.3Initializer list range accessY 
18.10Other runtime supportY 
19 Diagnostics
19.1General  
19.2Exception classesY 
19.3AssertionsY 
19.4Error numbersY 
19.5System error support  
19.5.1Class error_categoryY 
19.5.2Class error_codeY 
19.5.3Class error_conditionY 
19.5.4Comparison operatorsY 
19.5.5Class system_errorY 
20 General utilities
20.1General  
20.2Utility components  
20.2.1OperatorsY 
20.2.2swapY 
20.2.3exchangeY 
20.2.4forward/move helpersY 
20.2.5Function template declvalY 
20.3PairsY 
20.4TuplesY 
20.5Compile-time integer sequences  
20.5.2Class template integer_sequenceY 
20.5.3Alias template make_integer_sequenceY 
20.6Class template bitsetY 
20.7MemoryY 
20.8Smart pointers  
20.8.1Class template unique_ptrY 
20.8.1.1Default deletersY 
20.8.1.2unique_ptr for single objectsY 
20.8.1.3unique_ptr for array objects with a runtime lengthY 
20.8.1.4unique_ptr creationY 
20.8.1.5unique_ptr specialized algorithmsY 
20.8.2Shared-ownership pointers  
20.8.2.1Class bad_weak_ptrY 
20.8.2.2Class template shared_ptrY Uses code from boost::shared_ptr.
20.8.2.3Class template weak_ptrY 
20.8.2.4Class template owner_lessY 
20.8.2.5Class template enable_shared_from_thisY 
20.8.2.6shared_ptr atomic accessY 
20.8.2.7Smart pointer hash supportY 
20.9Function objects  
20.9.1Definitions  
20.9.2Requirements  
20.9.3Class template reference_wrapperY 
20.9.4Arithmetic operationY 
20.9.5ComparisonsY 
20.8.6Logical operationsY 
20.9.7Bitwise operationsY 
20.9.8NegatorsY 
20.9.9Function object bindersY 
20.9.10Function template mem_fnY 
20.9.11Polymorphic function wrappers  
20.9.11.1Class bad_function_callY 
20.9.11.2Class template functionPartialMissing allocator support
20.9.12Class template hashY 
20.10Metaprogramming and type traits  
20.10.1RequirementsY 
20.10.2Header <type_traits> synopsis  
20.10.3Helper classesY 
20.10.4Unary Type TraitsY 
20.10.5Type property queriesY 
20.10.6Relationships between typesY 
20.10.7Transformations between typesY 
20.11Compile-time rational arithmeticY 
20.12Time utilities  
20.12.3Clock requirementsY 
20.12.4Time-related traitsY 
20.12.5Class template durationY 
20.12.5.8Suffixes for duration literalsY 
20.12.6Class template time_pointY 
20.12.7ClocksY 
20.12.8Date and time functionsY 
20.13Scoped allocator adaptorY 
20.14Class type_indexY 
21 Strings
21.1GeneralY 
21.2Character traitsY 
21.3String classesY 
21.4Class template basic_stringY 
21.5Numeric ConversionsY 
21.6Hash supportY 
21.7Suffixes for basic_string literalsY 
21.7Null-terminated sequence utilitiesPartialC library dependency.
22 Localization
22.1GeneralY 
22.2Header <locale> synopsisY 
22.3LocalesY 
22.4Standard locale categoriesY 
22.5Standard code conversion facetsY 
22.6C Library LocalesY 
23 Containers
23.1General  
23.2Container requirementsY 
23.3Sequence containersY 
23.4Associative containersY 
23.5Unordered associative containersY 
23.6Container adaptorsY 
24 Iterators
24.1GeneralY 
24.2Iterator requirementsY 
24.3Header <iterator> synopsisY 
24.4Iterator primitivesY 
24.5Iterator adaptorsY 
24.6Stream iteratorsY 
24.7range accessY 
25 Algorithms
25.1General  
25.2Non-modifying sequence operationsY 
25.3Mutating sequence operationsY 
25.4Sorting and related operationsY 
25.5C library algorithmsY 
26 Numerics
26.1General  
26.2Numeric type requirementsY 
26.3The floating-point environmentY 
26.4Complex numbersY 
26.4.10Suffixes for complex number literalsY 
26.5Random number generationY 
26.6Numeric arraysY 
26.7Generalized numeric operationsY 
26.8C LibraryY 
27 Input/output library
27.1GeneralY 
27.2Iostreams requirementsY 
27.2.1Imbue LimitationsY 
27.2.2Positioning Type LimitationsY 
27.2.3Thread safetyPartial 
27.3Forward declarationsY 
27.4Standard iostream objectsY 
27.5Iostreams base classesY 
27.6Stream buffersY 
27.7Formatting and manipulatorsY 
27.7.6Quoted manipulatorsY 
27.8String-based streamsY 
27.9File-based streamsY 
28 Regular expressions
28.1GeneralY 
28.2DefinitionsY 
28.3RequirementsY 
28.4Header <regex> synopsisY 
28.5Namespace std::regex_constantsY 
28.6Class regex_errorY 
28.7Class template regex_traitsPartialtransform_primary is not correctly implemented 
28.8Class template basic_regexY 
28.9Class template sub_matchY 
28.10Class template match_resultsY 
28.11Regular expression algorithmsY 
28.12Regular expression IteratorsY 
28.13Modified ECMAScript regular expression grammarY 
29 Atomic operations
29.1GeneralY 
29.2Header <atomic> synopsisY 
29.3Order and consistencyY 
29.4Lock-free propertyY 
29.5Atomic typesY 
29.6Operations on atomic typesY 
29.7Flag Type and operationsY 
29.8FencesY 
30 Thread support
30.1GeneralY 
30.2RequirementsY 
30.3Threads  
30.3.1Class threadPartialthread::id comparisons not well-defined
30.3.2Namespace this_threadY 
30.4Mutual exclusion  
30.4.1Mutex requirements  
30.4.1.1In general  
30.4.1.2Mutex types  
30.4.1.2.1Class mutexY 
30.4.1.2.2Class recursive_mutexY 
30.4.1.3Timed mutex types  
30.4.1.3.1Class timed_mutexY 
30.4.1.3.2Class recursive_timed_mutexY 
30.4.1.4Shared timed mutex types  
30.4.1.4.1Class shared_timed_mutexY 
30.4.2Locks  
30.4.2.1Class template lock_guardY 
30.4.2.2Class template unique_lockY 
30.4.2.3Class template shared_lockY 
30.4.3Generic locking algorithmsY 
30.4.4Call once  
30.4.4.1Struct once_flagY 
30.4.4.2Function call_onceBrokenSee PR 66146
30.5Condition variablesY 
30.5.1Class condition_variableY 
30.5.2Class condition_variable_anyY 
30.6Futures  
30.6.1Overview  
30.6.2Error handlingY 
30.6.3Class future_errorY 
30.6.4Shared stateY 
30.6.5Class template promiseY 
30.6.6Class template futureY 
30.6.7Class template shared_futureY 
30.6.8Function template asyncY 
30.6.9Class template packaged_taskY 
Appendix D Compatibility features
D.1Increment operator with bool operand  
D.2register keyword  
D.3Implicit declaration of copy functions  
D.4Dynamic exception specifications  
D.5C standard library headersY 
D.6Old iostreams membersY 
D.7char* streamsY 
D.8Function objectsY 
D.9BindersY 
D.10auto_ptrY 
D.11Violating exception-specificationsY 
D.12Random shuffleY 

Table 1.4. C++ Technical Specifications Implementation Status

PaperTitleStatusComments
N3662 C++ Dynamic ArraysNArray Extensions TS
N3793 A proposal to add a utility class to represent optional objectsYLibrary Fundamentals TS
N3804 Any library proposalYLibrary Fundamentals TS
N3866 Invocation type traits, but dropping function_call_operator.NLibrary Fundamentals TS
N3905 Faster string searching (Boyer-Moore et al.)YLibrary Fundamentals TS
N3915 apply() call a function with arguments from a tupleYLibrary Fundamentals TS
N3916 Polymorphic memory resourcesPartial (missing pool resource and buffer resource classes)Library Fundamentals TS
N3920 Extending shared_ptr to support arraysYLibrary Fundamentals TS
N3921 string_view: a non-owning reference to a stringYLibrary Fundamentals TS
N3925 A sample proposalYLibrary Fundamentals TS
N3932 Variable Templates For Type TraitsYLibrary Fundamentals TS
N4100 File SystemY Link with -lstdc++fs

Implementation Specific Behavior

Filesystem TS

2.1 POSIX conformance [fs.conform.9945] The behavior of the filesystem library implementation will depend on the target operating system. Some features will not be supported on some targets. Symbolic links and file permissions are not supported on Windows.

15.30 Rename [fs.op.rename] On Windows, experimental::filesystem::rename is implemented by calling MoveFileExW and so does not meet the requirements of POSIX rename when one or both of the paths resolves to an existing directory. Specifically, it is possible to rename a directory so it replaces a non-directory (POSIX requires an error in that case), and it is not possible to rename a directory to replace another directory (POSIX requires that to work if the directory being replaced is empty).

C++ 2017

In this implementation the -std=gnu++17 or -std=c++17 flag must be used to enable language and library features. See dialect options. The pre-defined symbol __cplusplus is used to check for the presence of the required flag. GCC 9.1 was the first release with non-experimental C++17 support, so the API and ABI of features added in C++17 is only stable since that release.

This section describes the C++17 and library TS support in the GCC 10 release series.

The following table lists new library features that are included in the C++17 standard. The "Proposal" column provides a link to the ISO C++ committee proposal that describes the feature, while the "Status" column indicates the first version of GCC that contains an implementation of this feature (if it has been implemented). The "SD-6 Feature Test" column shows the corresponding macro or header from SD-6: Feature-testing recommendations for C++.

Table 1.5. C++ 2017 Library Features

Library FeatureProposalStatusSD-6 Feature Test
constexpr std::hardware_{constructive,destructive}_interference_size P0154R1 No __cpp_lib_hardware_interference_size >= 201603
Core Issue 1776: Replacement of class objects containing reference members P0137R1 7.1 __cpp_lib_launder >= 201606
Wording for std::uncaught_exceptions N4259 6.1__cpp_lib_uncaught_exceptions >= 201411
C++17 should refer to C11 instead of C99 P0063R3 9.1  
Variant: a type-safe union for C++17 P0088R3 7.1 __has_include(<variant>), __cpp_lib_variant >= 201603 (since 7.3, see Note 1)
Library Fundamentals V1 TS Components: optional P0220R1 7.1 __has_include(<optional>), __cpp_lib_optional >= 201603 (since 7.3, see Note 1)
Library Fundamentals V1 TS Components: any P0220R1 7.1 __has_include(<any>), __cpp_lib_any >= 201603 (since 7.3, see Note 1)
Library Fundamentals V1 TS Components: string_view P0220R1 7.1 __has_include(<string_view>), __cpp_lib_string_view >= 201603 (since 7.3, see Note 1)
Library Fundamentals V1 TS Components: memory_resource P0220R1 9.1 __has_include(<memory_resource>), __cpp_lib_memory_resource >= 201603
Library Fundamentals V1 TS Components: apply P0220R1 7.1 __cpp_lib_apply >= 201603
Library Fundamentals V1 TS Components: shared_ptr<T[]> P0220R1 7.1 __cpp_lib_shared_ptr_arrays >= 201603
Library Fundamentals V1 TS Components: Searchers P0220R1 7.1 __cpp_lib_boyer_moore_searcher >= 201603
Library Fundamentals V1 TS Components: Sampling P0220R1 7.1 __cpp_lib_sample >= 201603
Constant View: A proposal for a std::as_const helper function template P0007R1 7.1 __cpp_lib_as_const >= 201510
Improving pair and tuple N4387 6.1 N/A
make_from_tuple: apply for construction P0209R2 7.1 __cpp_lib_make_from_tuple >= 201606
Removing auto_ptr, random_shuffle(), And Old <functional> Stuff N4190 No (kept for backwards compatibility) 
Deprecating Vestigial Library Parts in C++17 P0174R2 No (kept for backwards compatibility) 
Making std::owner_less more flexible P0074R0 7.1 __cpp_lib_transparent_operators >= 201510
std::addressof should be constexpr LWG2296 7.1 __cpp_lib_addressof_constexpr >= 201603
Safe conversions in unique_ptr<T[]> N4089 6  
LWG 2228: Missing SFINAE rule in unique_ptr templated assignment N4366 6  
Re-enabling shared_from_this P0033R1 7.1 __cpp_lib_enable_shared_from_this >= 201603
A proposal to add invoke function template N4169 6.1 __cpp_lib_invoke >= 201411
TriviallyCopyable reference_wrapper N4277 5.1  
Adopt not_fn from Library Fundamentals 2 for C++17 P0005R4 7.1 __cpp_lib_not_fn >= 201603
Fixes for not_fn P0358R1 7.1  
Fixing a design mistake in the searchers interface in Library Fundamentals P0253R1 7.1  
Extending memory management tools P0040R3 7.1 __cpp_lib_raw_memory_algorithms >= 201606L
shared_ptr::weak_type P0163R0 7.1 __cpp_lib_shared_ptr_weak_type >= 201606
Transformation Trait Alias void_t N3911 6.1 __cpp_lib_void_t >= 201411
Wording for bool_constant, revision 1 N4389 6.1 __cpp_lib_bool_constant >= 201505
Adopt Type Traits Variable Templates from Library Fundamentals TS for C++17 P0006R0 7.1 __cpp_lib_type_trait_variable_templates >= 201510
Logical Operator Type Traits P0013R1 6.1 __cpp_lib_logical_traits >= 201510
Adding [nothrow-]swappable traits P0185R1 7 (__is_swappable available since 6.1) __cpp_lib_is_swappable >= 201603
is_callable, the missing INVOKE related trait P0077R2 7.1 __cpp_lib_is_invocable >= 201703
has_unique_object_representations P0258R2 7.1 __cpp_lib_has_unique_object_representations >= 201606
Polishing <chrono> P0092R1 7.1 __cpp_lib_chrono >= 201510
Adding more constexpr to <chrono> P0505R0 7.1 __cpp_lib_chrono >= 201611 (since 7.3, see Note 2)
Constexpr for std::char_traits P0426R1 8.1 __cpp_lib_constexpr_char_traits >= 201611
Integrating std::string_view and std::string P0254R2 7.1
Give 'std::string' a non-const '.data()' member function P0272R1 7.1
Cleaning-up noexcept in the Library N4258 6.1 __cpp_lib_allocator_traits_is_always_equal >= 201411
Contiguous Iterators N4284 N/A 
Minimal incomplete type support for standard containers N4510 3.0 __cpp_lib_incomplete_container_elements >= 201505 (since 6.2, see Note 2)
Emplace return type P0084R2 7.1  
Improved insertion interface for unique-key maps N4279 6.1 __cpp_lib_map_try_emplace >= 201411, __cpp_lib_unordered_map_try_emplace >= 201411
Splicing Maps and Sets P0083R3 7.1 __cpp_lib_node_extract >= 201606
Non-member size() and more N4280 6.1 __cpp_lib_nonmember_container_access >= 201411
A Proposal to Add Constexpr Modifiers to reverse_iterator, move_iterator, array and Range Access P0031R0 7.1 __cpp_lib_array_constexpr >= 201603
The Parallelism TS Should be Standardized P0024R2 9.1 __has_include(<execution>) , __cpp_lib_execution >= 201603 , __cpp_lib_parallel_algorithm >= 201603 (requires linking with -ltbb, see Note 3)
An algorithm to "clamp" a value between a pair of boundary values P0025R0 7.1 __cpp_lib_clamp >= 201603
Adopt Selected Library Fundamentals V2 Components for C++17 P0295R0 7.1 __cpp_lib_gcd_lcm >= 201606
Proposal to Introduce a 3-Argument Overload to std::hypot P0030R1 7.1 __cpp_lib_hypot >= 201603
Mathematical Special Functions for C++17 P0226R1 7.1 __cpp_lib_math_special_functions >= 201603 (see Note 4)
Adopt the File System TS for C++17 P0218R1 8.1 __has_include(<filesystem>) , __cpp_lib_filesystem >= 201603 (GCC 8.x requires linking with -lstdc++fs)
Relative Paths for Filesystem P0219R1 8.1 __cpp_lib_filesystem >= 201606
Adapting string_view by filesystem paths P0392R0 8.1 __cpp_lib_filesystem >= 201606
Directory Entry Caching for Filesystem P0317R1 8.1 __cpp_lib_filesystem >= 201703
constexpr atomic<T>::is_always_lock_free P0152R1 7.1 __cpp_lib_atomic_is_always_lock_free >= 201603
A proposal to add shared_mutex (untimed) (Revision 4) N4508 6.1 __cpp_lib_shared_mutex >= 201505
Variadic lock_guard (Rev. 5) P0156R2 7.1 __cpp_lib_scoped_lock >= 201703
A byte type definition P0298R3 7.1 __cpp_lib_byte >= 201603 (since 7.3, see Note 2)
Elementary string conversions P0067R5 8.1 (only integral types supported) __has_include(<charconv>) __cpp_lib_to_chars >= 201611
Homogeneous interface for variant, any and optional P0032R3 7.1 __cpp_lib_any >= 201606 , __cpp_lib_optional >= 201606 , __cpp_lib_variant >= 201606
Making Optional Greater Equal Again P0307R2 7.1 __cpp_lib_optional >= 201606

Note 1: This feature is supported in GCC 7.1 and 7.2 but before GCC 7.3 the __cpp_lib macro is not defined, and compilation will fail if the header is included without using -std to enable C++17 support.

Note 2: This feature is supported in older releases but the __cpp_lib macro is not defined to the right value (or not defined at all) until the version shown in parentheses.

Note 3: The Parallel Algorithms have an external dependency on Intel TBB 2018 or later. If the <execution> header is included then -ltbb must be used to link to TBB.

Note 4: The mathematical special functions are enabled in C++17 mode from GCC 7.1 onwards. For GCC 6.x or for C++11/C++14 define __STDCPP_WANT_MATH_SPEC_FUNCS__ to a non-zero value and test for __STDCPP_MATH_SPEC_FUNCS__ >= 201003L.

The following status table is based on the table of contents of ISO/IEC 14882:2017. Some subclauses are not shown in the table where the content is unchanged since C++14 and the implementation is complete.

Table 1.6. C++ 2017 Implementation Status

SectionDescriptionStatusComments
21 Language support
21.1General  
21.2Common definitions  
21.3Implementation properties  
21.3.1General  
21.3.2Header <limits> synopsis  
21.3.3Floating-point type properties  
21.3.3.1float_round_styleN 
21.3.3.2float_denorm_styleN 
21.3.4Class template numeric_limitsY 
21.3.5Header <climits> synopsisY 
21.3.6Header <cfloat> synopsisY 
21.4Integer types  
21.4.1Header <cstdint> synopsisY 
21.5Start and terminationPartialC library dependency for quick_exit, at_quick_exit
21.6Dynamic memory management  
21.6.1Header <new> synopsis  
21.6.2Storage allocation and deallocationY 
21.6.3Storage allocation errorsY 
21.6.4Pointer optimization barrierY 
21.6.5Hardware interference sizeN 
21.7Type identificationY 
21.8Exception handling  
21.8.1Header <exception> synopsis  
21.8.2Class exceptionY 
21.8.3Class bad_exceptionY 
21.8.4Abnormal terminationY 
21.8.5uncaught_exceptionsY 
21.8.6Exception PropagationY 
21.8.7nested_exceptionY 
21.9Initializer listsY 
21.10Other runtime supportY 
22 Diagnostics
22.1General  
22.2Exception classesY 
22.3AssertionsY 
22.4Error numbersY 
22.5System error support  
23 General utilities
23.1General  
23.2Utility components  
23.2.1Header <utility> synopsis  
23.2.2OperatorsY 
23.2.3swapY 
23.2.4exchangeY 
23.2.5Forward/move helpersY 
23.2.6Function template as_constY 
23.2.7Function template declvalY 
23.2.8Primitive numeric output conversionPartialOnly integer types supported, not floating-point types
23.2.9Primitive numeric input conversionPartialOnly integer types supported, not floating-point types
23.3Compile-time integer sequences  
23.4PairsY 
23.5TuplesY 
23.6Optional objectsY 
23.7VariantsY 
23.8Storage for any typeY 
23.9BitsetsY 
23.10MemoryY 
23.10.1In general  
23.10.2Header <memory> synopsisY 
23.10.3Pointer traitsY 
23.10.4Pointer safetyY 
23.10.5AlignY 
23.10.6Allocator argument tagY 
23.10.7uses_allocatorY 
23.10.8Allocator traitsY 
23.10.9The default allocatorY 
23.10.10Specialized algorithmsY 
23.10.11C library memory allocationY 
23.11Smart pointers  
23.11.1Class template unique_ptrY 
23.11.2Shared-ownership pointersY 
23.12Memory resources  
23.12.1Header <memory_resource> synopsisY 
23.12.2Class memory_resourceY 
23.12.3Class template polymorphic_allocatorY 
23.12.4Access to program-wide memory_resource objectsY 
23.12.5Pool resource classesY 
23.12.6Class monotonic_buffer_resourceY 
23.13Class template scoped_allocator_adaptorY 
23.14Function objects  
23.14.1Header <functional> synopsis  
23.14.2Definitions  
23.14.3Requirements  
23.14.4Function template invokeY 
23.14.5Class template reference_wrapperY 
23.14.6Arithmetic operationY 
23.14.7ComparisonsY 
23.14.8Logical operationsY 
23.14.9Bitwise operationsY 
23.14.10Function template not_fnY 
23.14.11Function object bindersY 
23.14.12Function template mem_fnY 
23.14.13Polymorphic function wrappersY 
23.14.14SearchersY 
23.14.15Class template hashY 
23.15Metaprogramming and type traits  
23.15.1Requirements  
23.15.2Header <type_traits> synopsisY 
23.15.3Helper classesY 
23.15.4Unary Type TraitsY 
23.15.5Type property queriesY 
23.15.6Relationships between typesY 
23.15.7Transformations between typesY 
23.15.8Logical operator traitsY 
23.16Compile-time rational arithmeticY 
23.17.1In general  
23.17.2Header <chrono> synopsis  
23.17Time utilities  
23.17.3Clock requirementsY 
23.17.4Time-related traitsY 
23.17.5Class template durationY 
23.17.6Class template time_pointY 
23.17.7ClocksY 
23.17.8Header <ctime> synopsisY 
23.18Class type_indexY 
23.19Execution policies  
23.19.1In general  
23.19.2Header <execution> synopsis  
23.19.3Execution policy type traitY 
23.19.4Sequenced execution policyY 
23.19.5Parallel execution policyY 
23.19.6Parallel and unsequenced execution policyY 
23.19.7Execution policy objectsY 
24 Strings
24.1General  
24.2Character traitsY 
24.3String classesY 
24.4String view classesY 
24.4.1Header <string_view> synopsisY 
24.4.2Class template basic_string_viewY 
24.4.3Non-member comparison functionsY 
24.4.4Inserters and extractorsY 
24.4.5Hash supportY 
24.4.6Suffix for basic_string_view literalsY 
24.5Null-terminated sequence utilitiesPartialC library dependency.
25 Localization
25.1GeneralY 
25.2Header <locale> synopsisY 
25.3LocalesY 
25.4Standard locale categoriesY 
25.5C Library LocalesY 
26 Containers
26.1General  
26.2Container requirementsY 
26.3Sequence containersY 
26.4Associative containersY 
26.5Unordered associative containersY 
26.6Container adaptorsY 
27 Iterators
27.1GeneralY 
27.2Iterator requirementsY 
27.3Header <iterator> synopsisY 
27.4Iterator primitivesY 
27.5Iterator adaptorsY 
27.6Stream iteratorsY 
27.7Range accessY 
27.8Container accessY 
28 Algorithms
28.1General  
28.2Header <algorithm> synopsis  
28.3Algorithms requirements  
28.4Parallel algorithms Using PSTL
28.5Non-modifying sequence operationsY 
28.6Mutating sequence operationsY 
28.7Sorting and related operationsY 
28.8C library algorithmsY 
29 Numerics
29.1General  
29.2Definitions  
29.3Numeric type requirementsY 
29.4The floating-point environmentY 
29.5Complex numbersY 
29.6Random number generationY 
29.7Numeric arraysY 
29.8Generalized numeric operations  
29.8.1Header <numeric> synopsis  
29.8.2AccumulateY 
29.8.3ReduceY 
29.8.4Inner productY 
29.8.5Transform reduceY 
29.8.6Partial sumY 
29.8.7Exclusive scanY 
29.8.8Inclusive scanY 
29.8.9Transform exclusive scanY 
29.8.10Transform inclusive scanY 
29.8.11Adjacent differenceY 
29.8.12IotaY 
29.8.13Greatest common divisorY 
29.8.14Least common multipleY 
29.9Mathematical functions for floating-point types  
29.9.1Header <cmath> synopsis  
29.9.2Absolute valuesY 
29.9.3Three-dimensional hypotenuseY 
29.9.4Classification / comparison functionsY 
29.9.5Mathematical special functionsY 
30 Input/output library
30.1GeneralY 
30.2Iostreams requirementsY 
30.2.1Imbue LimitationsY 
30.2.2Positioning Type LimitationsY 
30.2.3Thread safetyPartial 
30.3Forward declarationsY 
30.4Standard iostream objectsY 
30.5Iostreams base classesY 
30.6Stream buffersY 
30.7Formatting and manipulatorsY 
30.8String-based streamsY 
30.9File-based streamsY 
30.10File systemssY 
30.11C library filesY 
31 Regular expressions
31.1GeneralY 
31.2DefinitionsY 
31.3RequirementsY 
31.4Header <regex> synopsisY 
31.5Namespace std::regex_constantsY 
31.6Class regex_errorY 
31.7Class template regex_traitsPartialtransform_primary is not correctly implemented 
31.8Class template basic_regexY 
31.9Class template sub_matchY 
31.10Class template match_resultsY 
31.11Regular expression algorithmsY 
31.12Regular expression IteratorsY 
31.13Modified ECMAScript regular expression grammarY 
32 Atomic operations
32.1GeneralY 
32.2Header <atomic> synopsisY 
32.3Type aliasesY 
32.4Order and consistencyY 
32.5Lock-free propertyY 
32.6Class template <atomic>Y 
32.7Non-member functionsY 
32.8Flag Type and operationsY 
32.9FencesY 
33 Thread support
33.1GeneralY 
33.2RequirementsY 
33.3Threads  
33.3.1Header thread synopsis  
33.3.2Class threadY 
33.3.2.1Class threadPartialthread::id comparisons not well-defined
33.3.3Namespace this_threadY 
33.4Mutual exclusion  
33.4.3Mutex requirements  
33.4.3.1In general  
33.4.3.2Mutex types  
33.4.3.2.1Class mutexY 
33.4.3.2.2Class recursive_mutexY 
33.4.3.3Timed mutex types  
33.4.3.3.1Class timed_mutexY 
33.4.3.3.2Class recursive_timed_mutexY 
33.4.3.4Shared mutex types  
33.4.3.4.1Class shared_mutexY 
33.4.3.5Shared timed mutex types  
33.4.3.5.1Class shared_timed_mutexY 
33.4.4Locks  
33.4.4.1Class template lock_guardY 
33.4.4.2Class template scoped_guardY 
33.4.4.3Class template unique_lockY 
33.4.4.4Class template shared_lockY 
33.4.5Generic locking algorithmsY 
33.4.6Call once  
33.4.6.1Struct once_flagY 
33.4.6.2Function call_onceBrokenSee PR 66146
33.5Condition variablesY 
33.5.1Class condition_variableY 
33.5.2Class condition_variable_anyY 
33.6Futures  
33.6.1Overview  
33.6.2Header <future>  
33.6.3Error handlingY 
33.6.4Class future_errorY 
33.6.5Shared stateY 
33.6.6Class template promiseY 
33.6.7Class template futureY 
33.6.8Class template shared_futureY 
33.6.9Function template asyncY 
33.6.10Class template packaged_taskY 
Appendix D Compatibility features
D.4C++ standard library headersY 
D.4.1Header <ccomplex> synopsisY 
D.4.1Header <cstdalign> synopsisY 
D.4.1Header <cstdbool> synopsisY 
D.4.1Header <ctgmath> synopsisY 
D.5C standard library headersY 
D.6char* streamsY 
D.7uncaught_exceptionY 
D.8Old adaptable function bindingsY 
D.9The default allocatorY 
D.10Raw storage iteratorY 
D.11Temporary buffersY 
D.12Deprecated type traitsY 
D.13Deprecated iterator primitivesY 
D.14Deprecated shared_ptr observersY 
D.15Deprecated standard code conversion facetsY 
D.16Deprecated convenience conversion interfacesY 

Table 1.7. C++ Technical Specifications Implementation Status

PaperTitleStatusComments
N4076 A generalized callable negatorYLibrary Fundamentals 2 TS
N4273 Uniform Container ErasureYLibrary Fundamentals 2 TS
N4061 Greatest Common Divisor and Least Common MultipleYLibrary Fundamentals 2 TS
N4066 Delimited iteratorsYLibrary Fundamentals 2 TS
N4282 The World's Dumbest Smart PointerYLibrary Fundamentals 2 TS
N4388 Const-Propagating WrapperYLibrary Fundamentals 2 TS
N4391 make_array, revision 4 YLibrary Fundamentals 2 TS
N4502 Support for the C++ Detection Idiom, V2 YLibrary Fundamentals 2 TS
N4519 Source-Code Information Capture YLibrary Fundamentals 2 TS
N4521 Merge Fundamentals V1 into V2 N (components from V1 are still in namespace fundamentals_v1) Library Fundamentals 2 TS
P0013R1 Logical Operator Type Traits (revision 1)YLibrary Fundamentals 2 TS
N4531 std::rand replacement, revision 3YLibrary Fundamentals 2 TS

Implementation Specific Behavior

For behaviour which is also specified by previous standards, see C++ 1998/2003 Implementation Specific Behavior and C++ 2011 Implementation Specific Behavior. This section only documents behaviour which is new in the 2017 standard.

20.5.1.2 [headers] Whether names from Annex K are declared by C++ headers depends on whether the underlying C library supports Annex K and declares the names. For the GNU C library, there is no Annex K support and so none of its names are declared by C++ headers.

23.6.5 [optional.bad_optional_access] what() returns "bad optional access".

23.7.3 [variant.variant] variant supports over-aligned types.

23.7.10 [variant.bad.access] what() returns one of the strings "std::get: variant is valueless", "std::get: wrong index for variant", "std::visit: variant is valueless", or "std::visit<R>: variant is valueless".

23.12.5.2 [memory.resource.pool.options] Let S equal numeric_limits<size_t>::digits. The limit for maximum number of blocks in a chunk is given by 2N-1, where N is min(19, 3 + S/2). The largest allocation size that will be allocated from a pool is 222 when S > 20, otherwise 3072 when S > 16, otherwise 768.

23.12.6.1 [memory.resource.monotonic.buffer.ctor] The default next_buffer_size is 128 * sizeof(void*). The default growth factor is 1.5.

23.15.4.3 [meta.unary.prop] The predicate condition for has_unique_object_representations is true for all scalar types except floating point types.

23.19.3 [execpol.type], 28.4.3 [algorithms.parallel.exec] There are no implementation-defined execution policies.

24.4.2 [string.view.template] basic_string_view<C, T>::iterator is C* and basic_string_view<C, T>::const_iterator is const C*.

28.4.3 [algorithms.parallel.exec] Threads of execution created by std::thread provide concurrent forward progress guarantees, so threads of execution implicitly created by the library will provide parallel forward progress guarantees.

29.4.1 [cfenv.syn] The effects of the <cfenv> functions depends on whether the FENV_ACCESS pragma is supported, and on the C library that provides the header.

29.6.9 [c.math.rand] Whether the rand function may introduce data races depends on the target C library that provides the function.

29.9.5 [sf.cmath] The effect of calling the mathematical special functions with large inputs should be documented here.

30.10.2.1 [fs.conform.9945] The behavior of the filesystem library implementation will depend on the target operating system. Some features will not be supported on some targets. Symbolic links and file permissions are not supported on Windows.

30.10.5 [fs.filesystem.syn] The clock used for file times is an unspecified type with a signed 64-bit representation, capable of representing timestamps with nanosecond resolution. The clock's epoch is unspecified, but is not the same as the system clock's epoch.

30.10.7.1 [fs.path.generic] dot-dot in the root-directory refers to the root-directory itself. On Windows, a drive specifier such as "C:" or "z:" is treated as a root-name. On Cygwin, a path that begins with two successive directory separators is a root-name. Otherwise (for POSIX-like systems other than Cygwin), the implementation-defined root-name is an unspecified string which does not appear in any pathnames.

30.10.10.1 [fs.enum.path.format] The character sequence is always interpreted in the native pathname format.

30.10.15.4 [fs.op.file_size] If !is_regular_file(p), an error is reported.

30.10.15.32 [fs.op.rename] On Windows, filesystem::rename is implemented by calling MoveFileExW and so does not meet the requirements of POSIX rename when one or both of the paths resolves to an existing directory. Specifically, it is not possible to rename a directory to replace another directory (POSIX requires that to work if the directory being replaced is empty).

C++ 2020

In this implementation the -std=gnu++2a or -std=c++2a flag must be used to enable language and library features. See dialect options. The pre-defined symbol __cplusplus is used to check for the presence of the required flag.

This section describes the C++20 and library TS support in the GCC 10 release series.

The following table lists new library features that have been accepted into the C++20 working draft. The "Proposal" column provides a link to the ISO C++ committee proposal that describes the feature, while the "Status" column indicates the first version of GCC that contains an implementation of this feature (if it has been implemented). A dash (—) in the status column indicates that the changes in the proposal either do not affect the code in libstdc++, or the changes are not required for conformance. The "SD-6 Feature Test / Notes" column shows the corresponding macro or header from SD-6: Feature-testing recommendations for C++ (where applicable) or any notes about the implementation.

Table 1.8. C++ 2020 Library Features

Library FeatureProposalStatusSD-6 Feature Test / Notes
Compile-time programming
Add constexpr modifiers to functions in <algorithm> and <utility> Headers P0202R3 10.1 __cpp_lib_constexpr_algorithms >= 201703L
Constexpr for swap and swap related functions P0879R0 10.1 __cpp_lib_constexpr_algorithms >= 201806L
Constexpr for std::complex P0415R1 9.1 __cpp_lib_constexpr_complex >= 201711L (since 9.4, see Note 1)
P0595R2 std::is_constant_evaluated() P0595R2 9.1 __cpp_lib_is_constant_evaluated >= 201811L
More constexpr containers P0784R7 10.1 __cpp_lib_constexpr_dynamic_alloc >= 201907L
Making std::string constexpr P0980R1   __cpp_lib_constexpr_string >= 201907L
Making std::vector constexpr P1004R2   __cpp_lib_constexpr_vector >= 201907L
Constexpr in std::pointer_traits P1006R1 9.1 __cpp_lib_constexpr_memory >= 201811L (since 9.4, see Note 1)
constexpr for <numeric> algorithms P1645R1 10.1 __cpp_lib_constexpr_numeric >= 201911L
Constexpr iterator requirements P0858R0 9.1
__cpp_lib_array_constexpr >= 201803L
__cpp_lib_string_view >= 201803L
(both since 9.4, see Note 1)
constexpr comparison operators for std::array P1023R0 10.1 __cpp_lib_array_constexpr >= 201806
Misc constexpr bits P1032R1 10.1
__cpp_lib_array_constexpr >= 201811L
__cpp_lib_constexpr_functional >= 201811L
__cpp_lib_constexpr_iterator >= 201811L
__cpp_lib_constexpr_string_view >= 201811L
__cpp_lib_constexpr_tuple >= 201811L
__cpp_lib_constexpr_utility >= 201811L
constexpr INVOKE P1065R2 10.1 __cpp_lib_constexpr_functional >= 201907L
Transformation Trait remove_cvref P0550R2 9.1 __cpp_lib_remove_cvref >= 201711L (since 9.4, see Note 1)
Implicit conversion traits and utility functions P0758R1 9.1 __cpp_lib_is_nothrow_convertible >= 201806L (since 9.4, see Note 1)
The identity metafunction P0887R1 9.1 __cpp_lib_type_identity >= 201806L (since 9.4, see Note 1)
unwrap_ref_decay and unwrap_reference P0318R1 9.1 __cpp_lib_unwrap_ref >= 201811L (since 9.4, see Note 1)
Improving Completeness Requirements for Type Traits P1285R0 Partial  
Missing feature test macros P1353R0 9.1  
Making std::underlying_type SFINAE-friendly P0340R3 9.1  
Traits for [Un]bounded Arrays P1357R1 9.1 __cpp_lib_bounded_array_traits >= 201902L
Layout-compatibility and pointer-interconvertibility traits P0466R5
__cpp_lib_is_layout_compatible >= 201907L
__cpp_lib_is_pointer_interconvertible >= 201907L
Integrating feature-test macros into the C++ WD P0941R2 5.1  
<version> P0754R2 9.1 __has_include(<version>)
Synchronization
Atomic Ref P0019R8 10.1 __cpp_lib_atomic_ref >= 201806L
Floating Point Atomic P0020R6 10.1 __cpp_lib_atomic_float >= 201711L
C++ Synchronized Buffered Ostream P0053R7 __cpp_lib_syncbuf >= 201711L
Manipulators for C++ Synchronized Buffered Ostream P0753R2 __cpp_lib_syncbuf >= 201803L
Make std::memory_order a scoped enumeration P0439R0 9.1  
The Curious Case of Padding Bits, Featuring Atomic Compare-and-Exchange P0528R3  
Atomic shared_ptr P0718R2 __cpp_lib_atomic_shared_ptr >= 201711L
std::stop_token and std::jthread P0660R10 10.1 __cpp_lib_jthread >= 201907L
Rename condition_variable_any interruptible wait methods P1869R1 10.1 __cpp_lib_jthread >= 201911L
Atomic waiting and notifying, std::semaphore, std::latch and std::barrier P1135R6
__cpp_lib_atomic_lock_free_type_aliases >= 201907L
__cpp_lib_atomic_flag_test >= 201907L
__cpp_lib_atomic_wait >= 201907L
__cpp_lib_semaphore >= 201907L
__cpp_lib_latch >= 201907L
__cpp_lib_barrier >= 201907L
Fixing Atomic Initialization P0883R2 10.1 __cpp_lib_atomic_value_initialization >= 201911L
Ranges and Concepts
Standard Library Concepts P0898R3 10.1 __cpp_lib_concepts >= 201806L
Rename concepts to standard_case for C++20, while we still can P1754R1 10.1 __cpp_lib_concepts >= 201907L
Wording for boolean-testable P1964R2 10.1 __cpp_lib_concepts >= 202002L
The One Ranges Proposal P0896R4 10.1 __cpp_lib_ranges >= 201811L
Input Range Adaptors P1035R7 10.1 __cpp_lib_ranges >= 201907L
ranges compare algorithm are over-constrained P1716R3 10.1 __cpp_lib_ranges >= 201911L
Remove CommonReference requirement from StrictWeakOrdering (a.k.a Fixing Relations) P1248R1 10.1  
Ranges Design Cleanup P1252R2 10.1  
Avoid template bloat for safe_ranges in combination with ‘subrange-y’ view adaptors. P1739R4  
Time, dates, calendars, time zones
Extending chrono to Calendars and Time Zones P0355R7   __cpp_lib_chrono >= 201803L
Miscellaneous minor fixes for chrono P1466R3   __cpp_lib_chrono >= 201907L
<chrono> zero(), min(), and max() should be noexcept P0972R0 9.1  
Three-way comparison
Library Support for the Spaceship (Comparison) Operator P0768R1 10.1 __cpp_lib_three_way_comparison >= 201711L
Symmetry for spaceship P0905R1 10.1  
Adding <=> to the standard library P1614R2 10.1 __cpp_lib_three_way_comparison >= 201907L
Strings and text
string::reserve Should Not Shrink P0966R1  
char8_t: A type for UTF-8 characters and strings P0482R6 9.1 __cpp_lib_char8_t >= 201811L
char8_t backward compatibility remediation P1423R3 10.1 __cpp_lib_char8_t >= 201907L
Text formatting P0645R10 __cpp_lib_format >= 201907L
Integration of chrono with text formatting P1361R2 __cpp_lib_format >= 201907L
Printf corner cases in std::format P1652R1 __cpp_lib_format >= 201907L
String Prefix and Suffix Checking P0457R2 9.1 __cpp_lib_starts_ends_with >= 201711L (since 9.4, see Note 1)
Update The Reference To The Unicode Standard P1025R1  
Containers
span: bounds-safe views for sequences of objects P0122R7 10.1 __cpp_lib_span >= 201803L
Usability Enhancements for std::span P1024R3 10.1 __cpp_lib_span >= 201902L
Should Span be Regular? P1085R2 10.1  
Fixed-size <span> construction from dynamic range P1976R2 10.1 __cpp_lib_span >= 202002L
std::to_array P0325R4 10.1 __cpp_lib_to_array >= 201907L
Checking for Existence of an Element in Associative Containers P0458R2 9.1  
Comparing Unordered Containers P0809R0  
Heterogeneous lookup for unordered containers P0919R3 __cpp_lib_generic_unordered_lookup >= 201811
Adopt Consistent Container Erasure from Library Fundamentals 2 for C++20 P1209R0 9.1 __cpp_lib_erase_if >= 201811L
Improving the Return Value of Erase-Like Algorithms P0646R1 9.1 __cpp_lib_list_remove_return_type >= 201806L
Improving the Return Value of Erase-Like Algorithms II: Free erase/erase_if P1115R3 9.1
__cpp_lib_erase_if >= 202002L
(defined to 201900L for GCC 9.1 and 9.2 so use > 201811L)
Signed ssize() functions, unsigned size() functions P1227R2 10.1 __cpp_lib_ssize >= 201902L
Memory management
Utility to convert a pointer to a raw pointer P0653R2 8.1 __cpp_lib_to_address >= 201711L (since 9.4, see Note 1)
Extending make_shared to Support Arrays P0674R1 __cpp_lib_shared_ptr_arrays >= 201707L
Efficient sized delete for variable sized classes P0722R3 9.1 __cpp_lib_destroying_delete >= 201806L
Utility functions to implement uses-allocator construction P0591R4 9.1 std::scoped_allocator_adaptor changes missing in 9.1.0
std::assume_aligned P1007R3 9.1 __cpp_lib_assume_aligned >= 201811L (since 9.4, see Note 1)
Smart pointer creation with default initialization P1020R1 __cpp_lib_smart_ptr_for_overwrite >= 201811L
Make stateful allocator propagation more consistent for operator+(basic_string) P1165R1 10.1  
polymorphic_allocator<> as a vocabulary type P0339R6 9.1 __cpp_lib_polymorphic_allocator >= 201902L (since 9.4, see Note 1)
LWG 2511: guaranteed copy elision for piecewise construction P0475R1 7.1  
Miscellaneous
nodiscard in the Library P0600R1 9.1  
de-pessimize legacy algorithms with std::move P0616R0 9.1  
Deprecate POD P0767R1 10.1  
Treating Unnecessary decay P0777R1 9.1  
Thou Shalt Not Specialize std Function Templates! P0551R3  
Bit-casting object representations P0476R2 __cpp_lib_bit_cast >= 201806L
Integral power-of-2 operations P0556R3 9.1 __cpp_lib_int_pow2 >= 201806L (since 9.4, see Note 1)
On the names of low-level bit manipulation functions P1956R1 10.1 __cpp_lib_int_pow2 >= 202002L
Safe integral comparisons P0586R2 10.1 __cpp_lib_integer_comparison_functions >= 202002L
Reviewing Deprecated Facilities of C++17 for C++20 P0619R4  
fpos Requirements P0759R1  
Add shift to <algorithm> P0769R2 10.1 __cpp_lib_shift >= 201806L
Standard Library Specification in a Concepts and Contracts World P0788R3  
explicit(bool) P0892R2  
Eradicating unnecessarily explicit default constructors from the standard library P0935R0 9.1  
std::function move constructor should be noexcept P0771R1 7.2  
Simplified partial function application P0356R5 9.1 __cpp_lib_bind_front >= 201811L
bind_front should not unwrap reference_wrapper P1651R0 9.3 __cpp_lib_bind_front >= 201907L
reference_wrapper for incomplete types P0357R3 9.1  
Fixing operator>>(basic_istream&, CharT*) (LWG 2499) P0487R1  
variant and optional should propagate copy/move triviality P0602R4 8.3  
A sane variant converting constructor P0608R3 10.1  
visit<R>: Explicit Return Type for visit P0655R1 9.1  
P0899R1 - LWG 3016 is not a defect P0899R1 7.1  
Editorial Guidance for merging P0019r8 and P0528r3 P1123R0  
Cleaning up Clause 20 P1148R0  
Completing the Rebase of Library Fundamentals, Version 3, Working Draft P1210R0  
Alternative Wording for P0907R4 Signed Integers are Two's Complement P1236R1  
I Stream, You Stream, We All Stream for istream_iterator P0738R2 10.1  
Mandating the Standard Library: Clause 16 - Language support library P1458R1  
Mandating the Standard Library: Clause 18 - Diagnostics library P1459R1  
Mandating the Standard Library: Clause 20 - Strings library P1462R1  
Mandating the Standard Library: Clause 21 - Containers library P1463R1 10.1  
Mandating the Standard Library: Clause 22 - Iterators library P1464R1  
Make create_directory() Intuitive P1164R1 8.3 Treated as a DR for C++17
Target Vectorization Policies from Parallelism V2 TS to C++20 P1001R2 9.1 __cpp_lib_execution >= 201902L (since 9.4, see Note 1)
Merge Coroutines TS into C++20 working draft P0912R5 10.1 __cpp_lib_coroutines >= 201902L
Endian just Endian P0463R1 8.1 __cpp_lib_endian >= 201907L
Bit operations P0553R4 9.1 __cpp_lib_bitops >= 201907L (since 9.4, see Note 1)
Well-behaved interpolation for numbers and pointers P0811R3 9.1 __cpp_lib_interpolate >= 201902L
Mathematical constants P0631R8 10.1 __cpp_lib_math_constants >= 201907L
std::source_location P1208R6 __cpp_lib_source_location >= 201907L
Efficient access to std::basic_stringbuf's Buffer P0408R7  

Note 1: This feature is supported in older releases but the __cpp_lib macro is not defined to the right value (or not defined at all) until the version shown in parentheses.

C++ TR1

This table is based on the table of contents of ISO/IEC DTR 19768 Doc No: N1836=05-0096 Date: 2005-06-24 Draft Technical Report on C++ Library Extensions

In this implementation the header names are prefixed by tr1/, for instance <tr1/functional>, <tr1/memory>, and so on.

This page describes the TR1 support in the GCC 10 release series.

Table 1.9. C++ TR1 Implementation Status

SectionDescriptionStatusComments
2General Utilities
2.1Reference wrappers  
2.1.1Additions to header <functional> synopsisY 
2.1.2Class template reference_wrapper  
2.1.2.1reference_wrapper construct/copy/destroyY 
2.1.2.2reference_wrapper assignmentY 
2.1.2.3reference_wrapper accessY 
2.1.2.4reference_wrapper invocationY 
2.1.2.5reference_wrapper helper functionsY 
2.2Smart pointers  
2.2.1Additions to header <memory> synopsisY 
2.2.2Class bad_weak_ptrY 
2.2.3Class template shared_ptr 

Uses code from boost::shared_ptr.

2.2.3.1shared_ptr constructorsY 
2.2.3.2shared_ptr destructorY 
2.2.3.3shared_ptr assignmentY 
2.2.3.4shared_ptr modifiersY 
2.2.3.5shared_ptr observersY 
2.2.3.6shared_ptr comparisonY 
2.2.3.7shared_ptr I/OY 
2.2.3.8shared_ptr specialized algorithmsY 
2.2.3.9shared_ptr castsY 
2.2.3.10get_deleterY 
2.2.4Class template weak_ptr  
2.2.4.1weak_ptr constructorsY 
2.2.4.2weak_ptr destructorY 
2.2.4.3weak_ptr assignmentY 
2.2.4.4weak_ptr modifiersY 
2.2.4.5weak_ptr observersY 
2.2.4.6weak_ptr comparisonY 
2.2.4.7weak_ptr specialized algorithmsY 
2.2.5Class template enable_shared_from_thisY 
3Function Objects
3.1DefinitionsY 
3.2Additions to <functional> synopsisY 
3.3RequirementsY 
3.4Function return typesY 
3.5Function template mem_fnY 
3.6Function object binders  
3.6.1Class template is_bind_expressionY 
3.6.2Class template is_placeholderY 
3.6.3Function template bindY 
3.6.4PlaceholdersY 
3.7Polymorphic function wrappers  
3.7.1Class bad_function_callY 
3.7.1.1bad_function_call constructorY 
3.7.2Class template function  
3.7.2.1function construct/copy/destroyY 
3.7.2.2function modifiersY 
3.7.2.3function capacityY 
3.7.2.4function invocationY 
3.7.2.5function target accessY 
3.7.2.6undefined operatorsY 
3.7.2.7null pointer comparison operatorsY 
3.7.2.8specialized algorithmsY 
4Metaprogramming and type traits
4.1RequirementsY 
4.2Header <type_traits> synopsisY 
4.3Helper classesY 
4.4General RequirementsY 
4.5Unary Type Traits  
4.5.1Primary Type CategoriesY 
4.5.2Composite type traitsY 
4.5.3Type propertiesY 
4.6Relationships between typesY 
4.7Transformations between types  
4.7.1Const-volatile modificationsY 
4.7.2Reference modificationsY 
4.7.3Array modificationsY 
4.7.4Pointer modificationsY 
4.8Other transformationsY 
4.9Implementation requirementsY 
5Numerical Facilities
5.1Random number generation  
5.1.1RequirementsY 
5.1.2Header <random> synopsisY 
5.1.3Class template variate_generatorY 
5.1.4Random number engine class templatesY 
5.1.4.1Class template linear_congruentialY 
5.1.4.2Class template mersenne_twisterY 
5.1.4.3Class template subtract_with_carryY 
5.1.4.4Class template subtract_with_carry_01Y 
5.1.4.5Class template discard_blockY 
5.1.4.6Class template xor_combineYoperator()() per N2079
5.1.5Engines with predefined parametersY 
5.1.6Class random_deviceY 
5.1.7Random distribution class templatesY 
5.1.7.1Class template uniform_intY 
5.1.7.2Class bernoulli_distributionY 
5.1.7.3Class template geometric_distributionY 
5.1.7.4Class template poisson_distributionY 
5.1.7.5Class template binomial_distributionY 
5.1.7.6Class template uniform_realY 
5.1.7.7Class template exponential_distributionY 
5.1.7.8Class template normal_distributionY 
5.1.7.9Class template gamma_distributionY 
5.2Mathematical special functionsY 
5.2.1Additions to header <cmath> synopsisY 
5.2.1.1associated Laguerre polynomialsY 
5.2.1.2associated Legendre functionsY 
5.2.1.3beta functionY 
5.2.1.4(complete) elliptic integral of the first kindY 
5.2.1.5(complete) elliptic integral of the second kindY 
5.2.1.6(complete) elliptic integral of the third kindY 
5.2.1.7confluent hypergeometric functionsY 
5.2.1.8regular modified cylindrical Bessel functionsY 
5.2.1.9cylindrical Bessel functions (of the first kind)Y 
5.2.1.10irregular modified cylindrical Bessel functionsY 
5.2.1.11cylindrical Neumann functionsY 
5.2.1.12(incomplete) elliptic integral of the first kindY 
5.2.1.13(incomplete) elliptic integral of the second kindY 
5.2.1.14(incomplete) elliptic integral of the third kindY 
5.2.1.15exponential integralY 
5.2.1.16Hermite polynomialsY 
5.2.1.17hypergeometric functionsY 
5.2.1.18Laguerre polynomialsY 
5.2.1.19Legendre polynomialsY 
5.2.1.20Riemann zeta functionY 
5.2.1.21spherical Bessel functions (of the first kind)Y 
5.2.1.22spherical associated Legendre functionsY 
5.2.1.23spherical Neumann functionsY 
5.2.2Additions to header <math.h> synopsisY 
6Containers
6.1Tuple typesY 
6.1.1Header <tuple> synopsisY 
6.1.2Additions to header <utility> synopsisY 
6.1.3Class template tupleY 
6.1.3.1ConstructionY 
6.1.3.2Tuple creation functionsY 
6.1.3.3Tuple helper classesY 
6.1.3.4Element accessY 
6.1.3.5Relational operatorsY 
6.1.4PairsY 
6.2Fixed size arrayY 
6.2.1Header <array> synopsisY 
6.2.2Class template arrayY 
6.2.2.1array constructors, copy, and assignmentY 
6.2.2.2array specialized algorithmsY 
6.2.2.3array sizeY 
6.2.2.4Zero sized arraysY 
6.2.2.5Tuple interface to class template arrayY 
6.3Unordered associative containersY 
6.3.1Unordered associative container requirementsY 
6.3.1.1Exception safety guaranteesY 
6.3.2Additions to header <functional> synopsisY 
6.3.3Class template hashY 
6.3.4Unordered associative container classesY 
6.3.4.1Header <unordered_set> synopsisY 
6.3.4.2Header <unordered_map> synopsisY 
6.3.4.3Class template unordered_setY 
6.3.4.3.1unordered_set constructorsY 
6.3.4.3.2unordered_set swapY 
6.3.4.4Class template unordered_mapY 
6.3.4.4.1unordered_map constructorsY 
6.3.4.4.2unordered_map element accessY 
6.3.4.4.3unordered_map swapY 
6.3.4.5Class template unordered_multisetY 
6.3.4.5.1unordered_multiset constructorsY 
6.3.4.5.2unordered_multiset swapY 
6.3.4.6Class template unordered_multimapY 
6.3.4.6.1unordered_multimap constructorsY 
6.3.4.6.2unordered_multimap swapY 
7Regular Expressions
7.1DefinitionsN 
7.2RequirementsN 
7.3Regular expressions summaryN 
7.4Header <regex> synopsisN 
7.5Namespace tr1::regex_constantsN 
7.5.1Bitmask Type syntax_option_typeN 
7.5.2Bitmask Type regex_constants::match_flag_typeN 
7.5.3Implementation defined error_typeN 
7.6Class regex_errorN 
7.7Class template regex_traitsN 
7.8Class template basic_regexN 
7.8.1basic_regex constantsN 
7.8.2basic_regex constructorsN 
7.8.3basic_regex assignN 
7.8.4basic_regex constant operationsN 
7.8.5basic_regex localeN 
7.8.6basic_regex swapN 
7.8.7basic_regex non-member functionsN 
7.8.7.1basic_regex non-member swapN 
7.9Class template sub_matchN 
7.9.1sub_match membersN 
7.9.2sub_match non-member operatorsN 
7.10Class template match_resultsN 
7.10.1match_results constructorsN 
7.10.2match_results sizeN 
7.10.3match_results element accessN 
7.10.4match_results formattingN 
7.10.5match_results allocatorN 
7.10.6match_results swapN 
7.11Regular expression algorithmsN 
7.11.1exceptionsN 
7.11.2regex_matchN 
7.11.3regex_searchN 
7.11.4regex_replaceN 
7.12Regular expression IteratorsN 
7.12.1Class template regex_iteratorN 
7.12.1.1regex_iterator constructorsN 
7.12.1.2regex_iterator comparisonsN 
7.12.1.3regex_iterator dereferenceN 
7.12.1.4regex_iterator incrementN 
7.12.2Class template regex_token_iteratorN 
7.12.2.1regex_token_iterator constructorsN 
7.12.2.2regex_token_iterator comparisonsN 
7.12.2.3regex_token_iterator dereferenceN 
7.12.2.4regex_token_iterator incrementN 
7.13Modified ECMAScript regular expression grammarN 
8C Compatibility
8.1Additions to header <complex>Y 
8.1.1SynopsisY 
8.1.2Function acosY 
8.1.3Function asinY 
8.1.4Function atanY 
8.1.5Function acoshY 
8.1.6Function asinhY 
8.1.7Function atanhY 
8.1.8Function fabsY 
8.1.9Additional OverloadsY 
8.2Header <ccomplex>NDR 551
8.3Header <complex.h>NDR 551
8.4Additions to header <cctype>Y 
8.4.1SynopsisY 
8.4.2Function isblankY 
8.5Additions to header <ctype.h>Y 
8.6Header <cfenv>Y 
8.6.1SynopsisY 
8.6.2DefinitionsY 
8.7Header <fenv.h>Y 
8.8Additions to header <cfloat>Y 
8.9Additions to header <float.h>Y 
8.10Additions to header <ios>N 
8.10.1SynopsisN 
8.10.2Function hexfloatN 
8.11Header <cinttypes>Y 
8.11.1SynopsisYDR 557
8.11.2DefinitionsY 
8.12Header <inttypes.h>Y 
8.13Additions to header <climits>Y 
8.14Additions to header <limits.h>Y 
8.15Additions to header <locale>N 
8.16Additions to header <cmath>Y 
8.16.1SynopsisY 
8.16.2DefinitionsY 
8.16.3Function template definitionsY 
8.16.4Additional overloadsYDR 568; DR 550
8.17Additions to header <math.h>Y 
8.18Additions to header <cstdarg>Y 
8.19Additions to header <stdarg.h>Y 
8.20The header <cstdbool>Y 
8.21The header <stdbool.h>Y 
8.22The header <cstdint>Y 
8.22.1SynopsisY 
8.22.2DefinitionsY 
8.23The header <stdint.h>Y 
8.24Additions to header <cstdio>Y 
8.24.1SynopsisY 
8.24.2DefinitionsY 
8.24.3Additional format specifiersYC library dependency
8.24.4Additions to header <stdio.h>Y 
8.25Additions to header <cstdlib>Y 
8.25.1SynopsisY 
8.25.2DefinitionsY 
8.25.3Function absY 
8.25.4Function divY 
8.26Additions to header <stdlib.h>Y 
8.27Header <ctgmath>YDR 551
8.28Header <tgmath.h>YDR 551
8.29Additions to header <ctime>YC library dependency
8.30Additions to header <cwchar>Y 
8.30.1SynopsisY 
8.30.2DefinitionsY 
8.30.3Additional wide format specifiersYC library dependency
8.31Additions to header <wchar.h>Y 
8.32Additions to header <cwctype>Y 
8.32.1SynopsisY 
8.32.2Function iswblankY 
8.33Additions to header <wctype.h>Y 

Implementation Specific Behavior

For behaviour which is specified by the 1998 and 2003 standards, see C++ 1998/2003 Implementation Specific Behavior. This section documents behaviour which is required by TR1.

3.6.4 [tr.func.bind.place]/1 There are 29 placeholders defined and the placeholder types are Assignable.

C++ TR 24733

This table is based on the table of contents of ISO/IEC TR 24733 Date: 2009-08-28 Extension for the programming language C++ to support decimal floating-point arithmetic

This page describes the TR 24733 support in the GCC 10 release series.

Table 1.10. C++ TR 24733 Implementation Status

SectionDescriptionStatusComments
0 Introduction
1 Normative references
2 Conventions
3 Decimal floating-point types
3.1Characteristics of decimal floating-point types  
3.2Decimal Types  
3.2.1Class decimal synopsisPartialMissing declarations for formatted input/output; non-conforming extension for functions converting to integral type
3.2.2Class decimal32PartialMissing 3.2.2.5 conversion to integral type; conforming extension for conversion from scalar decimal floating-point
3.2.3Class decimal64PartialMissing 3.2.3.5 conversion to integral type; conforming extension for conversion from scalar decimal floating-point
3.2.4Class decimal128PartialMissing 3.2.4.5 conversion to integral type; conforming extension for conversion from scalar decimal floating-point
3.2.5Initialization from coefficient and exponentY 
3.2.6Conversion to generic floating-point typeY 
3.2.7Unary arithmetic operatorsY 
3.2.8Binary arithmetic operatorsY 
3.2.9Comparison operatorsY 
3.2.10Formatted inputN 
3.2.11Formatted outputN 
3.3Additions to header limitsN 
3.4Headers cfloat and float.h  
3.4.2Additions to header cfloat synopsisY 
3.4.3Additions to header float.h synopsisN 
3.4.4Maximum finite valueY 
3.4.5EpsilonY 
3.4.6Minimum positive normal valueY 
3.4.7Minimum positive subnormal valueY 
3.4.8Evaluation formatY 
3.5Additions to cfenv and fenv.hOutside the scope of GCC 
3.6Additions to cmath and math.hOutside the scope of GCC 
3.7Additions to cstdio and stdio.hOutside the scope of GCC 
3.8Additions to cstdlib and stdlib.hOutside the scope of GCC 
3.9Additions to cwchar and wchar.hOutside the scope of GCC 
3.10FacetsN 
3.11Type traitsN 
3.12Hash functionsN 
4 Notes on C compatibility

C++ IS 29124

This table is based on the table of contents of ISO/IEC FDIS 29124 Doc No: N3060 Date: 2010-03-06 Extensions to the C++ Library to support mathematical special functions

Complete support for IS 29124 is in GCC 6.1 and later releases, when using at least C++11 (for older releases or C++98/C++03 use TR1 instead). For C++11 and C++14 the additions to the library are not declared by their respective headers unless __STDCPP_WANT_MATH_SPEC_FUNCS__ is defined as a macro that expands to a non-zero integer constant. For C++17 the special functions are always declared (since GCC 7.1).

When the special functions are declared the macro __STDCPP_MATH_SPEC_FUNCS__ is defined to 201003L.

In addition to the special functions defined in IS 29124, for non-strict modes (i.e. -std=gnu++NN modes) the hypergeometric functions and confluent hypergeometric functions from TR1 are also provided, defined in namespace __gnu_cxx.

Table 1.11. C++ Special Functions Implementation Status

SectionDescriptionStatusComments
7Macro namesPartialNo diagnostic for inconsistent definitions of __STDCPP_WANT_MATH_SPEC_FUNCS__
8Mathematical special functionsY 
8.1Additions to header <cmath> synopsisY 
8.1.1associated Laguerre polynomialsY 
8.1.2associated Legendre functionsY 
8.1.3beta functionY 
8.1.4(complete) elliptic integral of the first kindY 
8.1.5(complete) elliptic integral of the second kindY 
8.1.6(complete) elliptic integral of the third kindY 
8.1.7regular modified cylindrical Bessel functionsY 
8.1.8cylindrical Bessel functions (of the first kind)Y 
8.1.9irregular modified cylindrical Bessel functionsY 
8.1.10cylindrical Neumann functionsY 
8.1.11(incomplete) elliptic integral of the first kindY 
8.1.12(incomplete) elliptic integral of the second kindY 
8.1.13(incomplete) elliptic integral of the third kindY 
8.1.14exponential integralY 
8.1.15Hermite polynomialsY 
8.1.16Laguerre polynomialsY 
8.1.17Legendre polynomialsY 
8.1.18Riemann zeta functionY 
8.1.19spherical Bessel functions (of the first kind)Y 
8.1.20spherical associated Legendre functionsY 
8.1.21spherical Neumann functionsY 
8.2Additions to header <math.h>Y 
8.3The header <ctgmath>PartialConflicts with C++ 2011 requirements.
8.4The header <tgmath.h>NConflicts with C++ 2011 requirements.

Implementation Specific Behavior

For behaviour which is specified by the 2011 standard, see C++ 2011 Implementation Specific Behavior. This section documents behaviour which is required by IS 29124.

7.2 [macro.user]/3 /4 The functions declared in Clause 8 are only declared when __STDCPP_WANT_MATH_SPEC_FUNCS__ == 1 (or in C++17 mode, for GCC 7.1 and later).

8.1.1 [sf.cmath.Lnm]/1 The effect of calling these functions with n >= 128 or m >= 128 should be described here.

8.1.2 [sf.cmath.Plm]/3 The effect of calling these functions with l >= 128 should be described here.

8.1.3 [sf.cmath.I]/3 The effect of calling these functions with nu >= 128 should be described here.

8.1.8 [sf.cmath.J]/3 The effect of calling these functions with nu >= 128 should be described here.

8.1.9 [sf.cmath.K]/3 The effect of calling these functions with nu >= 128 should be described here.

8.1.10 [sf.cmath.N]/3 The effect of calling these functions with nu >= 128 should be described here.

8.1.15 [sf.cmath.Hn]/3 The effect of calling these functions with n >= 128 should be described here.

8.1.16 [sf.cmath.Ln]/3 The effect of calling these functions with n >= 128 should be described here.

8.1.17 [sf.cmath.Pl]/3 The effect of calling these functions with l >= 128 should be described here.

8.1.19 [sf.cmath.j]/3 The effect of calling these functions with n >= 128 should be described here.

8.1.20 [sf.cmath.Ylm]/3 The effect of calling these functions with l >= 128 should be described here.

8.1.21 [sf.cmath.n]/3 The effect of calling these functions with n >= 128 should be described here.