Movatterモバイル変換

Section	Description	Status	Comments
18	Language support
18.1	Types	Y
18.2	Implementation properties	Y
18.2.1	Numeric Limits
18.2.1.1	Class template`numeric_limits`	Y
18.2.1.2	`numeric_limits` members	Y
18.2.1.3	`float_round_style`	Y
18.2.1.4	`float_denorm_style`	Y
18.2.1.5	`numeric_limits` specializations	Y
18.2.2	C Library	Y
18.3	Start and termination	Y
18.4	Dynamic memory management	Y
18.5	Type identification
18.5.1	Class type_info	Y
18.5.2	Class bad_cast	Y
18.5.3	Class bad_typeid	Y
18.6	Exception handling
18.6.1	Class exception	Y
18.6.2	Violation exception-specifications	Y
18.6.3	Abnormal termination	Y
18.6.4	`uncaught_exception`	Y
18.7	Other runtime support	Y
19	Diagnostics
19.1	Exception classes	Y
19.2	Assertions	Y
19.3	Error numbers	Y
20	General utilities
20.1	Requirements	Y
20.2	Utility components
20.2.1	Operators	Y
20.2.2	`pair`	Y
20.3	Function objects
20.3.1	Base	Y
20.3.2	Arithmetic operation	Y
20.3.3	Comparisons	Y
20.3.4	Logical operations	Y
20.3.5	Negators	Y
20.3.6	Binders	Y
20.3.7	Adaptors for pointers to functions	Y
20.3.8	Adaptors for pointers to members	Y
20.4	Memory
20.4.1	The default allocator	Y
20.4.2	Raw storage iterator	Y
20.4.3	Temporary buffers	Y
20.4.4	Specialized algorithms	Y
20.4.4.1	`uninitialized_copy`	Y
20.4.4.2	`uninitialized_fill`	Y
20.4.4.3	`uninitialized_fill_n`	Y
20.4.5	Class template`auto_ptr`	Y
20.4.6	C library	Y
21	Strings
21.1	Character traits
21.1.1	Character traits requirements	Y
21.1.2	traits typedef	Y
21.1.3	`char_traits` specializations
21.1.3.1	struct`char_traits<char>`	Y
21.1.3.2	struct`char_traits<wchar_t>`	Y
21.2	String classes	Y
21.3	Class template`basic_string`	Y
21.4	Null-terminated sequence utilities	Y	C library dependency
22	Localization
22.1	Locales
22.1.1	Class`locale`	Y
22.1.2	`locale` globals	Y
22.1.3	Convenience interfaces
22.1.3.1	Character classification	Y
22.1.3.2	Character conversions	Y
22.2	Standard locale categories
22.2.1	`ctype`	Y
22.2.2	Numeric
22.2.2.1	`num_get`	Y
22.2.2.2	`num_put`	Y
22.2.3	`num_punct`	Y
22.2.4	`collate`	Y
22.2.5	Time
22.2.5.1	`time_get`	Y
22.2.5.2	`time_get_byname`	Y
22.2.5.3	`time_put`	Y
22.2.5.3	`time_put_byname`	Y
22.2.6	Monetary
22.2.6.1	`money_get`	Y
22.2.6.2	`money_put`	Y
22.2.6.3	`money_punct`	Y
22.2.6.4	`money_punct_byname`	Y
22.2.7	`messages`	Y
22.2.8	Program-defined facets	Y
22.3	C Library Locales	Y
23	Containers
23.1	Container requirements	Y
23.2	Sequence containers
23.2.1	Class template`deque`	Y
23.2.2	Class template`list`	Y
23.2.3	Adaptors
23.2.3.1	Class template`queue`	Y
23.2.3.2	Class template`priority_queue`	Y
23.2.3.3	Class template`stack`	Y
23.2.4	Class template`vector`	Y
23.2.5	Class`vector<bool>`	Y
23.3	Associative containers
23.3.1	Class template`map`	Y
23.3.2	Class template`multimap`	Y
23.3.3	Class template`set`	Y
23.3.4	Class template`multiset`	Y
24	Iterators
24.1	Requirements	Y
24.2	Header`<iterator>` synopsis	Y
24.3	Iterator primitives	Y
24.4	Predefined iterators and Iterator adaptors
24.4.1	Reverse iterators	Y
24.4.2	Insert iterators	Y
24.5	Stream iterators
24.5.1	Class template`istream_iterator`	Y
24.5.2	Class template`ostream_iterator`	Y
24.5.3	Class template`istreambuf_iterator`	Y
24.5.4	Class template`ostreambuf_iterator`	Y
25	Algorithms
25.1	Non-modifying sequence operations	Y
25.2	Mutating sequence operations	Y
25.3	Sorting and related operations	Y
25.4	C library algorithms	Y
26	Numerics
26.1	Numeric type requirements	Y
26.2	Complex numbers	Y
26.3	Numeric arrays
26.3.1	Header`<valarray>` synopsis	Y
26.3.2	Class template`valarray`	Y
26.3.3	`valarray` non-member operations	Y
26.3.4	Class`slice`	Y
26.3.5	Class template`slice_array`	Y
26.3.6	Class`gslice`	Y
26.3.7	Class template`gslice_array`	Y
26.3.8	Class template`mask_array`	Y
26.3.9	Class template`indirect_array`	Y
26.4	Generalized numeric operations
26.4.1	`accumulate`	Y
26.4.2	`inner_product`	Y
26.4.3	`partial_sum`	Y
26.4.4	`adjacent_difference`	Y
26.4.5	iota	Y
26.5	C Library	Y
27	Input/output
27.1	Requirements	Y
27.2	Forward declarations	Y
27.3	Standard iostream objects	Y
27.3.1	Narrow stream objects	Y
27.3.2	Wide stream objects	Y
27.4	Iostreams base classes	Y
27.5	Stream buffers	Y
27.6	Formatting and manipulators	Y
27.7	String-based streams	Y
27.8	File-based streams	Y
Appendix D	Compatibility features
D.1	Increment operator with bool operand
D.2	`static` keyword
D.3	Access declarations
D.4	Implicit conversion from const strings
D.5	C standard library headers
D.6	Old iostreams members
D.7	char* 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 implementationand 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 [intro.execution]/11 #3 Ifisatty(3) is true, then interactive stream support is implied.

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

18.1 [lib.support.types]/4 The type ofNULL is described underSupport.

18.3 [lib.support.start.term]/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 [lib.bad.alloc]/5 (bad_alloc),18.5.2 [lib.bad.cast]/5 (bad_cast),18.5.3 [lib.bad.typeid]/5 (bad_typeid),18.6.1 [lib.exception]/8 (exception),18.6.2.1 [lib.bad.exception]/5 (bad_exception): Thewhat() member function of classstd::exception, and these other classes publicly derived from it, returns the name of the class, e.g."std::bad_alloc".

18.5.1 [lib.type.info]/7 The return value ofstd::type_info::name() is the mangled type name. You will need to callc++filt and pass the names as command-line parameters to demangle them, or call aruntime demangler function.

20.1.5 [lib.allocator.requirements]/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 [lib.char.traits.specializations.char]/3,4,21.1.3.2 [lib.char.traits.specializations.wchar.t]/2,21.3 [lib.basic.string]/6 basic_string::iterator, basic_string::const_iterator,23.* [lib.containers]'s foo::iterator,27.* [lib.input.output]'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 [lib.char.traits.specializations.char]/5 I don't really know about thembstate_t stuff... see thecodecvt notes for what does exist.

22.* [lib.localization] Anything and everything we have on locale implementation will be described underLocalization.

23.* [lib.containers] All of the containers in this clause definesize_type asstd::size_t anddifference_type asstd::ptrdiff_t.

26.2.8 [lib.complex.transcendentals/9 I have no idea whatcomplex<T>'spow(0,0) returns.

27.4.2.4 [lib.ios.members.static/2 Callingstd::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 [lib.istream::sentry],27.6.2.3 [lib.ostream::sentry] 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 [lib.stringbuf.virtuals]/16,27.8.1.4 [lib.filebuf.virtuals]/10 The effects ofpubsetbuf/setbuf are described in theInput and Output chapter.

27.8.1.4 [lib.filebuf.virtuals]/16 Callingfstream::sync when a get area exists will... whateverfflush() does, I think.

C++ 2011

This table is based on the table of contents of ISO/IECJTC1 SC22 WG21 Doc No: N3290 Date: 2011-04-11Final 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 languageand libraryfeatures. Seedialectoptions. The pre-defined symbol__cplusplus is used to check for thepresence 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 stablesince that release.

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

This section describes the C++11 support inmainline GCC, not in any particular release.

Table 1.2. C++ 2011 Implementation Status

Section	Description	Status	Comments
18	Language support
18.1	General
18.2	Types	Y
18.3	Implementation properties
18.3.2	Numeric Limits
18.3.2.3	Class template`numeric_limits`	Y
18.3.2.4	`numeric_limits` members	Y
18.3.2.5	`float_round_style`	N
18.3.2.6	`float_denorm_style`	N
18.3.2.7	`numeric_limits` specializations	Y
18.3.3	C Library	Y
18.4	Integer types
18.4.1	Header`<cstdint>` synopsis	Y
18.5	Start and termination	Partial	C library dependency for quick_exit, at_quick_exit
18.6	Dynamic memory management	Y
18.7	Type identification
18.7.1	Class type_info	Y
18.7.2	Class bad_cast	Y
18.7.3	Class bad_typeid	Y
18.8	Exception handling
18.8.1	Class exception	Y
18.8.2	Class bad_exception	Y
18.8.3	Abnormal termination	Y
18.8.4	`uncaught_exception`	Y
18.8.5	Exception Propagation	Y
18.8.6	`nested_exception`	Y
18.9	Initializer lists
18.9.1	Initializer list constructors	Y
18.9.2	Initializer list access	Y
18.9.3	Initializer list range access	Y
18.10	Other runtime support	Y
19	Diagnostics
19.1	General
19.2	Exception classes	Y
19.3	Assertions	Y
19.4	Error numbers	Y
19.5	System error support
19.5.1	Class`error_category`	Y
19.5.2	Class`error_code`	Y
19.5.3	Class`error_condition`	Y
19.5.4	Comparison operators	Y
19.5.5	Class`system_error`	Y
20	General utilities
20.1	General
20.2	Utility components
20.2.1	Operators	Y
20.2.2	swap	Y
20.2.3	forward/move helpers	Y
20.2.4	Function template`declval`	Y
20.3	Pairs
20.3.1	In general
20.3.2	Class template`pair`	Y
20.3.3	Specialized algorithms	Y
20.3.4	Tuple-like access to`pair`	Y
20.3.5	Piecewise construction	Y
20.4	Tuples
20.4.1	In general
20.4.2	Class template`tuple`
20.4.2.1	Construction	Y
20.4.2.2	Assignment	Y
20.4.2.3	Swap	Y
20.4.2.4	Tuple creation functions	Y
20.4.2.5	Tuple helper classes	Y
20.4.2.6	Element access	Y
20.4.2.7	Relational operators	Y
20.4.2.8	Tuple traits	Y
20.4.2.9	Tuple specialized algorithms	Y
20.5	Class template`bitset`	Y
20.5.1	`bitset` constructors	Y
20.5.2	`bitset` members	Y
20.5.3	`bitset` hash support	Y
20.5.4	`bitset` operators	Y
20.6	Memory
20.6.1	In general
20.6.2	Header`<memory>` synopsis
20.6.3	Pointer traits	Y
20.6.4	Pointer safety	Y
20.6.5	Align	Y
20.6.6	Allocator argument tag	Y
20.6.7	`uses_allocator`	Y
20.6.8	Allocator traits	Y
20.6.9	The default allocator	Y
20.6.10	Raw storage iterator	Y
20.6.11	Temporary buffers	Y
20.6.12	Specialized algorithms
20.6.12.1	`addressof`	Y
20.6.12.2	`uninitialized_copy`	Y
20.6.12.3	`uninitialized_fill`	Y
20.6.12.4	`uninitialized_fill_n`	Y
20.6.13	C library	Y
20.7	Smart pointers
20.7.1	Class template`unique_ptr`	Y
20.7.2	Shared-ownership pointers
20.7.2.1	Class`bad_weak_ptr`	Y
20.7.2.2	Class template`shared_ptr`	Y	Uses code fromboost::shared_ptr.
20.7.2.3	Class template`weak_ptr`	Y
20.7.2.4	Class template`enable_shared_from_this`	Y
20.7.2.5	`shared_ptr` atomic access	Y
20.7.2.6	Smart pointer hash support	Y
20.8	Function objects
20.8.1	Definitions
20.8.2	Requirements
20.8.3	Class template`reference_wrapper`	Y
20.8.4	Arithmetic operation	Y
20.8.5	Comparisons	Y
20.8.6	Logical operations	Y
20.8.7	Bitwise operations	Y
20.8.8	Negators	Y
20.8.9	Function template`bind`	Y
20.8.10	Function template`mem_fn`	Y
20.8.11	Polymorphic function wrappers
20.8.11.1	Class`bad_function_call`	Y
20.8.11.2	Class template`function`	Partial	Missing allocator support
20.8.12	Class template`hash`	Y
20.9	Metaprogramming and type traits
20.9.1	Requirements	Y
20.9.2	Header`<type_traits>` synopsis
20.9.3	Helper classes	Y
20.9.4	Unary Type Traits	Y
20.9.4.1	Primary type categories	Y
20.9.4.2	Composite type traits	Y
20.9.4.3	Type properties	Y
20.9.5	Type property queries	Y
20.9.6	Relationships between types	Y
20.9.7	Transformations between types
20.9.7.1	Const-volatile modifications	Y
20.9.7.2	Reference modifications	Y
20.9.7.3	Sign modifications	Y
20.9.7.4	Array modifications	Y
20.9.7.5	Pointer modifications	Y
20.9.7.6	Other transformations	Y
20.10	Compile-time rational arithmetic
20.10.1	In general
20.10.2	Header`<ratio>` synopsis
20.10.3	Class template`ratio`	Y
20.10.4	Arithmetic on`ratio`s	Y
20.10.5	Comparison of`ratio`s	Y
20.10.6	SI types for`ratio`	Y
20.11	Time utilities
20.11.3	Clock requirements	Y
20.11.4	Time-related traits
20.11.4.1	`treat_as_floating_point`	Y
20.11.4.2	`duration_values`	Y
20.11.4.3	Specializations of`common_type`	Y
20.11.5	Class template`duration`	Y
20.11.6	Class template`time_point`	Y
20.11.7	Clocks
20.11.7.1	Class`system_clock`	Y
20.11.7.2	Class`steady_clock`	Y
20.11.7.3	Class`high_resolution_clock`	Y
20.11.8	Date and time functions	Y
20.12	Scoped allocator adaptor	Y
20.12.1	Header`<scoped_allocator>` synopsis
20.12.2	Scoped allocator adaptor member types	Y
20.12.3	Scoped allocator adaptor constructors	Y
20.12.4	Scoped allocator adaptor members	Y
20.12.5	Scoped allocator operators	Y
20.13	Class`type_index`	Y
21	Strings
21.1	General	Y
21.2	Character traits
21.2.1	Character traits requirements	Y
21.2.2	traits typedefs	Y
21.2.3	`char_traits` specializations
21.2.3.1	struct`char_traits<char>`	Y
21.2.3.2	struct`char_traits<char16_t>`	Y
21.2.3.3	struct`char_traits<char32_t>`	Y
21.2.3.4	struct`char_traits<wchar_t>`	Y
21.3	String classes	Y
21.4	Class template`basic_string`	Y
21.5	Numeric Conversions	Y
21.6	Hash support	Y
21.7	Null-terminated sequence utilities	Partial	C library dependency.
22	Localization
22.1	General	Y
22.2	Header`<locale>` synopsis	Y
22.3	Locales
22.3.1	Class`locale`	Y
22.3.2	`locale` globals	Y
22.3.3	Convenience interfaces
22.3.3.1	Character classification	Y
22.3.3.2	Conversions
22.3.3.2.1	Character conversions	Y
22.3.3.2.2	`string` conversions	Y
22.3.3.2.3	Buffer conversions	Y
22.4	Standard`locale` categories
22.4.1	The`ctype` category	Y
22.4.2	The numeric category
22.4.2.1	`num_get`	Y
22.4.2.2	`num_put`	Y
22.4.3	The numeric punctuation facet	Y
22.4.4	The collate category	Y
22.4.5	The time category
22.4.5.1	Class template`time_get`	Y
22.4.5.2	Class template`time_get_byname`	Y
22.4.5.3	Class template`time_put`	Y
22.4.5.3	Class template`time_put_byname`	Y
22.4.6	The monetary category
22.4.6.1	Class template`money_get`	Y
22.4.6.2	Class template`money_put`	Y
22.4.6.3	Class template`money_punct`	Y
22.4.6.4	Class template`money_punct_byname`	Y
22.4.7	The message retrieval category	Y
22.4.8	Program-defined facets	Y
22.5	Standard code conversion facets	Y
22.6	C Library Locales	Y
23	Containers
23.1	General
23.2	Container requirements
23.2.1	General container requirements	Y
23.2.2	Container data races	Y
23.2.3	Sequence containers	Y
23.2.4	Associative containers	Y
23.2.5	Unordered associative containers	Y
23.3	Sequence containers
23.3.2	Class template`array`	Y
23.3.3	Class template`deque`	Y
23.3.4	Class template`forward_list`	Y
23.3.5	Class template`list`	Y
23.3.6	Class template`vector`	Y
23.3.7	Class`vector<bool>`	Y
23.4	Associative containers
23.4.4	Class template`map`	Y
23.4.5	Class template`multimap`	Y
23.4.6	Class template`set`	Y
23.4.7	Class template`multiset`	Y
23.5	Unordered associative containers
23.5.4	Class template`unordered_map`	Y
23.5.5	Class template`unordered_multimap`	Y
23.5.6	Class template`unordered_set`	Y
23.5.7	Class template`unordered_multiset`	Y
23.6	Container adaptors
23.6.1	Class template`queue`	Y
23.6.2	Class template`priority_queue`	Y
23.6.3	Class template`stack`	Y
24	Iterators
24.1	General	Y
24.2	Iterator requirements	Y
24.3	Header`<iterator>` synopsis	Y
24.4	Iterator primitives	Y
24.5	Iterator adaptors
24.5.1	Reverse iterators	Y
24.5.2	Insert iterators	Y
24.5.3	Move iterators	Y
24.6	Stream iterators
24.6.1	Class template`istream_iterator`	Y
24.6.2	Class template`ostream_iterator`	Y
24.6.3	Class template`istreambuf_iterator`	Y
24.6.4	Class template`ostreambuf_iterator`	Y
24.6.5	range access	Y
25	Algorithms
25.1	General
25.2	Non-modifying sequence operations	Y
25.3	Mutating sequence operations	Y
25.4	Sorting and related operations	Y
25.5	C library algorithms	Y
26	Numerics
26.1	General
26.2	Numeric type requirements	Y
26.3	The floating-point environment	Y
26.4	Complex numbers	Y
26.5	Random number generation
26.5.1	Requirements
26.5.2	Header`<random>` synopsis
26.5.3	Random number engine class templates
26.5.3.1	Class template`linear_congruential_engine`	Y
26.5.3.2	Class template`mersenne_twister_engine`	Y
26.5.3.3	Class template`subtract_with_carry_engine`	Y
26.5.4	Random number engine adaptor class templates
26.5.4.2	Class template`discard_block_engine`	Y
26.5.4.3	Class template`independent_bits_engine`	Y
26.5.4.4	Class template`shuffle_order_engine`	Y
26.5.5	Engines and engine adaptors with predefined parameters	Y
26.5.6	Class`random_device`	Y
26.5.7	Utilities
26.5.7.1	Class`seed_seq`	Y
26.5.7.2	Function template`generate_canonical`	Y
26.5.8	Random number distribution class templates
26.5.8.2	Uniform distributions
26.5.8.2.1	Class template`uniform_int_distribution`	Y
26.5.8.2.2	Class template`uniform_real_distribution`	Y
26.5.8.3	Bernoulli distributions
26.5.8.3.1	Class`bernoulli_distribution`	Y
26.5.8.3.2	Class template`binomial_distribution`	Y
26.5.8.3.3	Class template`geometric_distribution`	Y
26.5.8.3.4	Class template`negative_binomial_distribution`	Y
26.5.8.4	Poisson distributions
26.5.8.4.1	Class template`poisson_distribution`	Y
26.5.8.4.2	Class template`exponential_distribution`	Y
26.5.8.4.3	Class template`gamma_distribution`	Y
26.5.8.4.4	Class template`weibull_distribution`	Y
26.5.8.4.5	Class template`extreme_value_distribution`	Y
26.5.8.5	Normal distributions
26.5.8.5.1	Class template`normal_distribution`	Y
26.5.8.5.2	Class template`lognormal_distribution`	Y
26.5.8.5.3	Class template`chi_squared_distribution`	Y
26.5.8.5.4	Class template`cauchy_distribution`	Y
26.5.8.5.5	Class template`fisher_f_distribution`	Y
26.5.8.5.6	Class template`student_t_distribution`	Y
26.5.8.6	Sampling distributions
26.5.8.6.1	Class template`discrete_distribution`	Y
26.5.8.6.2	Class template`piecewise_constant_distribution`	Y
26.5.8.6.3	Class template`piecewise_linear_distribution`	Y
26.6	Numeric arrays
26.6.1	Header`<valarray>` synopsis	Y
26.6.2	Class template`valarray`	Y
26.6.3	`valarray` non-member operations	Y
26.6.4	Class`slice`	Y
26.6.5	Class template`slice_array`	Y
26.6.6	The`gslice` class	Y
26.6.7	Class template`gslice_array`	Y
26.6.8	Class template`mask_array`	Y
26.6.9	Class template`indirect_array`	Y
26.6.10	`valarray` range access	Y
26.7	Generalized numeric operations
26.7.1	Header`<numeric>` synopsis	Y
26.7.2	Accumulate>	Y
26.7.3	Inner product	Y
26.7.4	Partial sum	Y
26.7.5	Adjacent difference	Y
26.7.6	Iota	Y
26.8	C Library	Y
27	Input/output library
27.1	General	Y
27.2	Iostreams requirements	Y
27.2.1	Imbue Limitations	Y
27.2.2	Positioning Type Limitations	Y
27.2.3	Thread safety	Partial
27.3	Forward declarations	Y
27.4	Standard iostream objects	Y
27.4.1	Overview	Y
27.4.2	Narrow stream objects	Y
27.4.3	Wide stream objects	Y
27.5	Iostreams base classes	Y
27.6	Stream buffers	Y
27.7	Formatting and manipulators	Y
27.8	String-based streams	Y
27.9	File-based streams	Y
28	Regular expressions
28.1	General	Y
28.2	Definitions	Y
28.3	Requirements	Y
28.4	Header`<regex>` synopsis	Y
28.5	Namespace`std::regex_constants`	Y
28.6	Class`regex_error`	Y
28.7	Class template`regex_traits`	Partial	`transform_primary` is not correctly implemented
28.8	Class template`basic_regex`	Y
28.9	Class template`sub_match`	Y
28.10	Class template`match_results`	Y
28.11	Regular expression algorithms	Y
28.12	Regular expression Iterators	Y
28.13	Modified ECMAScript regular expression grammar	Y
29	Atomic operations
29.1	General	Y
29.2	Header`<atomic>` synopsis	Y
29.3	Order and consistency	Y
29.4	Lock-free property	Y
29.5	Atomic types	Y
29.6	Operations on atomic types	Y
29.7	Flag Type and operations	Y
29.8	Fences	Y
30	Thread support
30.1	General	Y
30.2	Requirements	Y
30.3	Threads
30.3.1	Class`thread`	Partial	`thread::id` comparisons not well-defined
30.3.2	Namespace`this_thread`	Y
30.4	Mutual exclusion
30.4.1	Mutex requirements
30.4.1.1	In general
30.4.1.2	Mutex types
30.4.1.2.1	Class`mutex`	Y
30.4.1.2.2	Class`recursive_mutex`	Y
30.4.1.3	Timed mutex types
30.4.1.3.1	Class`timed_mutex`	Y
30.4.1.3.2	Class`recursive_timed_mutex`	Y
30.4.2	Locks
30.4.2.1	Class template`lock_guard`	Y
30.4.2.2	Class template`unique_lock`	Y
30.4.3	Generic locking algorithms	Y
30.4.4	Call once
30.4.4.1	Struct`once_flag`	Y
30.4.4.2	Function`call_once`	Y	Exception support is broken.SeePR66146.
30.5	Condition variables	Y
30.5.1	Class`condition_variable`	Y
30.5.2	Class`condition_variable_any`	Y
30.6	Futures
30.6.1	Overview
30.6.2	Error handling	Y
30.6.3	Class`future_error`	Y
30.6.4	Shared state	Y
30.6.5	Class template`promise`	Y
30.6.6	Class template`future`	Y
30.6.7	Class template`shared_future`	Y
30.6.8	Function template`async`	Y
30.6.9	Class template`packaged_task`	Y
Appendix D	Compatibility features
D.1	Increment operator with`bool` operand
D.2	`register` keyword
D.3	Implicit declaration of copy functions
D.4	Dynamic exception specifications
D.5	C standard library headers	Y
D.6	Old iostreams members	Y
D.7	`char*` streams	Y
D.8	Function objects	Y
D.9	Binders	Y
D.10	`auto_ptr`	Y
D.11	Violating exception-specifications	Y

Implementation Specific Behavior

For behaviour which is also specified by the 1998 and 2003 standards, seeC++ 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] Theerror_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 bystd::allocator.

20.7.2.2.1 [util.smartptr.shared.const] When ashared_ptr constructor failsbad_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.11.1 [func.wrap.badcall]what() returns"bad_function_call".

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

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

20.15.7 [meta.trans]/2aligned_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 typesu16streampos andu32streampos are both synonyms forfpos<mbstate_t>. The functioneof returnsint_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 thatto_int_type never returns the same value aseof, 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 isT* andarray<T, N>::const_iterator isconst 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 ofrandom_shuffle usesrand as the source of randomness.

26.5.5 [rand.predef] The typedefault_random_engine is a synonym forminstd_rand0.

26.5.6 [rand.device] Thetoken parameter of therandom_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 MSVCRTrand_s function. This token is only valid for mingw-w64 targets.
"rdseed","rdrand" or"rdrnd": Use the IA-32RDSEED orRDRAND 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.
"darn": Use the Power ISA-3.0DARN ("Deliver A Random Number") instruction to read from an on-chip hardware random number generator. This token is only valid for 64-bit powerpc targets when both the assembler and CPU support the corresponding instruction.
"hw","hardware": Use any available CPU instruction to read from an on-chip hardware random number generator. This is equivalent to trying each of the following and using the first that is supported:"rdseed""rdrand""darn"
"arc4random","getentropy": Use the named C library function, if available on the target.
"/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 amersenne_twister_engine will be used. An integer seed value can be used as the token and will be converted to anunsigned long usingstrtoul. These tokens are only valid when no other source of random bytes is available.

An exception of typeruntime_error will be thrown if arandom_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 therand 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 thebasic_stringbuf move constructor should be documented here.

27.9.1.2 [filebuf.cons] Whether the sequence pointers are copied by thebasic_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 anderror_type are unscoped enumeration types.

28.7 [re.traits] Theblank character class corresponds to thectype_base::blank mask.

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

30.2.3 [thread.req.native]/1native_handle_type andnative_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 ofnative_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 theposix 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 theposix thread model.
recursive_mutex,recursive_timed_mutex: The native handle type is__gthread_recursive_mutex_t* i.e.pthread_mutex_t* for theposix thread model.
condition_variable: The native handle type is__gthread_cond_t* i.e.pthread_cond_t* for theposix thread model.

30.6.1 [futures.overview]/2launch 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 languageand libraryfeatures. Seedialectoptions. The pre-defined symbol__cplusplus is used to check for thepresence 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 stablesince 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 unchangedsince C++11 and the implementation is complete.

This section describes the C++14 and library TS support inmainline GCC, not in any particular release.

Table 1.3. C++ 2014 Implementation Status

Section	Description	Status	Comments
18	Language support
18.1	General
18.2	Types	Y
18.3	Implementation properties
18.3.2	Numeric Limits
18.3.2.3	Class template`numeric_limits`	Y
18.3.2.4	`numeric_limits` members	Y
18.3.2.5	`float_round_style`	N
18.3.2.6	`float_denorm_style`	N
18.3.2.7	`numeric_limits` specializations	Y
18.3.3	C Library	Y
18.4	Integer types
18.4.1	Header`<cstdint>` synopsis	Y
18.5	Start and termination	Partial	C library dependency for quick_exit, at_quick_exit
18.6	Dynamic memory management	Y
18.7	Type identification
18.7.1	Class type_info	Y
18.7.2	Class bad_cast	Y
18.7.3	Class bad_typeid	Y
18.8	Exception handling
18.8.1	Class exception	Y
18.8.2	Class bad_exception	Y
18.8.3	Abnormal termination	Y
18.8.4	`uncaught_exception`	Y
18.8.5	Exception Propagation	Y
18.8.6	`nested_exception`	Y
18.9	Initializer lists
18.9.1	Initializer list constructors	Y
18.9.2	Initializer list access	Y
18.9.3	Initializer list range access	Y
18.10	Other runtime support	Y
19	Diagnostics
19.1	General
19.2	Exception classes	Y
19.3	Assertions	Y
19.4	Error numbers	Y
19.5	System error support
19.5.1	Class`error_category`	Y
19.5.2	Class`error_code`	Y
19.5.3	Class`error_condition`	Y
19.5.4	Comparison operators	Y
19.5.5	Class`system_error`	Y
20	General utilities
20.1	General
20.2	Utility components
20.2.1	Operators	Y
20.2.2	swap	Y
20.2.3	exchange	Y
20.2.4	forward/move helpers	Y
20.2.5	Function template`declval`	Y
20.3	Pairs	Y
20.4	Tuples	Y
20.5	Compile-time integer sequences
20.5.2	Class template`integer_sequence`	Y
20.5.3	Alias template`make_integer_sequence`	Y
20.6	Class template`bitset`	Y
20.7	Memory	Y
20.8	Smart pointers
20.8.1	Class template`unique_ptr`	Y
20.8.1.1	Default deleters	Y
20.8.1.2	`unique_ptr` for single objects	Y
20.8.1.3	`unique_ptr` for array objects with a runtime length	Y
20.8.1.4	`unique_ptr` creation	Y
20.8.1.5	`unique_ptr` specialized algorithms	Y
20.8.2	Shared-ownership pointers
20.8.2.1	Class`bad_weak_ptr`	Y
20.8.2.2	Class template`shared_ptr`	Y	Uses code fromboost::shared_ptr.
20.8.2.3	Class template`weak_ptr`	Y
20.8.2.4	Class template`owner_less`	Y
20.8.2.5	Class template`enable_shared_from_this`	Y
20.8.2.6	`shared_ptr` atomic access	Y
20.8.2.7	Smart pointer hash support	Y
20.9	Function objects
20.9.1	Definitions
20.9.2	Requirements
20.9.3	Class template`reference_wrapper`	Y
20.9.4	Arithmetic operation	Y
20.9.5	Comparisons	Y
20.8.6	Logical operations	Y
20.9.7	Bitwise operations	Y
20.9.8	Negators	Y
20.9.9	Function object binders	Y
20.9.10	Function template`mem_fn`	Y
20.9.11	Polymorphic function wrappers
20.9.11.1	Class`bad_function_call`	Y
20.9.11.2	Class template`function`	Partial	Missing allocator support
20.9.12	Class template`hash`	Y
20.10	Metaprogramming and type traits
20.10.1	Requirements	Y
20.10.2	Header`<type_traits>` synopsis
20.10.3	Helper classes	Y
20.10.4	Unary Type Traits	Y
20.10.5	Type property queries	Y
20.10.6	Relationships between types	Y
20.10.7	Transformations between types	Y
20.11	Compile-time rational arithmetic	Y
20.12	Time utilities
20.12.3	Clock requirements	Y
20.12.4	Time-related traits	Y
20.12.5	Class template`duration`	Y
20.12.5.8	Suffixes for duration literals	Y
20.12.6	Class template`time_point`	Y
20.12.7	Clocks	Y
20.12.8	Date and time functions	Y
20.13	Scoped allocator adaptor	Y
20.14	Class`type_index`	Y
21	Strings
21.1	General	Y
21.2	Character traits	Y
21.3	String classes	Y
21.4	Class template`basic_string`	Y
21.5	Numeric Conversions	Y
21.6	Hash support	Y
21.7	Suffixes for`basic_string` literals	Y
21.7	Null-terminated sequence utilities	Partial	C library dependency.
22	Localization
22.1	General	Y
22.2	Header`<locale>` synopsis	Y
22.3	Locales	Y
22.4	Standard`locale` categories	Y
22.5	Standard code conversion facets	Y
22.6	C Library Locales	Y
23	Containers
23.1	General
23.2	Container requirements	Y
23.3	Sequence containers	Y
23.4	Associative containers	Y
23.5	Unordered associative containers	Y
23.6	Container adaptors	Y
24	Iterators
24.1	General	Y
24.2	Iterator requirements	Y
24.3	Header`<iterator>` synopsis	Y
24.4	Iterator primitives	Y
24.5	Iterator adaptors	Y
24.6	Stream iterators	Y
24.7	range access	Y
25	Algorithms
25.1	General
25.2	Non-modifying sequence operations	Y
25.3	Mutating sequence operations	Y
25.4	Sorting and related operations	Y
25.5	C library algorithms	Y
26	Numerics
26.1	General
26.2	Numeric type requirements	Y
26.3	The floating-point environment	Y
26.4	Complex numbers	Y
26.4.10	Suffixes for complex number literals	Y
26.5	Random number generation	Y
26.6	Numeric arrays	Y
26.7	Generalized numeric operations	Y
26.8	C Library	Y
27	Input/output library
27.1	General	Y
27.2	Iostreams requirements	Y
27.2.1	Imbue Limitations	Y
27.2.2	Positioning Type Limitations	Y
27.2.3	Thread safety	Partial
27.3	Forward declarations	Y
27.4	Standard iostream objects	Y
27.5	Iostreams base classes	Y
27.6	Stream buffers	Y
27.7	Formatting and manipulators	Y
27.7.6	Quoted manipulators	Y
27.8	String-based streams	Y
27.9	File-based streams	Y
28	Regular expressions
28.1	General	Y
28.2	Definitions	Y
28.3	Requirements	Y
28.4	Header`<regex>` synopsis	Y
28.5	Namespace`std::regex_constants`	Y
28.6	Class`regex_error`	Y
28.7	Class template`regex_traits`	Partial	`transform_primary` is not correctly implemented
28.8	Class template`basic_regex`	Y
28.9	Class template`sub_match`	Y
28.10	Class template`match_results`	Y
28.11	Regular expression algorithms	Y
28.12	Regular expression Iterators	Y
28.13	Modified ECMAScript regular expression grammar	Y
29	Atomic operations
29.1	General	Y
29.2	Header`<atomic>` synopsis	Y
29.3	Order and consistency	Y
29.4	Lock-free property	Y
29.5	Atomic types	Y
29.6	Operations on atomic types	Y
29.7	Flag Type and operations	Y
29.8	Fences	Y
30	Thread support
30.1	General	Y
30.2	Requirements	Y
30.3	Threads
30.3.1	Class`thread`	Partial	`thread::id` comparisons not well-defined
30.3.2	Namespace`this_thread`	Y
30.4	Mutual exclusion
30.4.1	Mutex requirements
30.4.1.1	In general
30.4.1.2	Mutex types
30.4.1.2.1	Class`mutex`	Y
30.4.1.2.2	Class`recursive_mutex`	Y
30.4.1.3	Timed mutex types
30.4.1.3.1	Class`timed_mutex`	Y
30.4.1.3.2	Class`recursive_timed_mutex`	Y
30.4.1.4	Shared timed mutex types
30.4.1.4.1	Class`shared_timed_mutex`	Y
30.4.2	Locks
30.4.2.1	Class template`lock_guard`	Y
30.4.2.2	Class template`unique_lock`	Y
30.4.2.3	Class template`shared_lock`	Y
30.4.3	Generic locking algorithms	Y
30.4.4	Call once
30.4.4.1	Struct`once_flag`	Y
30.4.4.2	Function`call_once`	Broken	Exception support is broken.SeePR66146.
30.5	Condition variables	Y
30.5.1	Class`condition_variable`	Y
30.5.2	Class`condition_variable_any`	Y
30.6	Futures
30.6.1	Overview
30.6.2	Error handling	Y
30.6.3	Class`future_error`	Y
30.6.4	Shared state	Y
30.6.5	Class template`promise`	Y
30.6.6	Class template`future`	Y
30.6.7	Class template`shared_future`	Y
30.6.8	Function template`async`	Y
30.6.9	Class template`packaged_task`	Y
Appendix D	Compatibility features
D.1	Increment operator with`bool` operand
D.2	`register` keyword
D.3	Implicit declaration of copy functions
D.4	Dynamic exception specifications
D.5	C standard library headers	Y
D.6	Old iostreams members	Y
D.7	`char*` streams	Y
D.8	Function objects	Y
D.9	Binders	Y
D.10	`auto_ptr`	Y
D.11	Violating exception-specifications	Y
D.12	Random shuffle	Y

Table 1.4. C++ Technical Specifications Implementation Status

Paper	Title	Status	Comments
N3662	C++ Dynamic Arrays	N	Array Extensions TS
N3793	A proposal to add a utility class to represent optional objects	Y	Library Fundamentals TS
N3804	Any library proposal	Y	Library Fundamentals TS
N3866	Invocation type traits, but dropping function_call_operator.	N	Library Fundamentals TS
N3905	Faster string searching (Boyer-Moore et al.)	Y	Library Fundamentals TS
N3915	apply() call a function with arguments from a tuple	Y	Library Fundamentals TS
N3916	Polymorphic memory resources	Partial (missing pool resource and buffer resource classes)	Library Fundamentals TS
N3920	Extending shared_ptr to support arrays	Y	Library Fundamentals TS
N3921	`string_view`: a non-owning reference to a string	Y	Library Fundamentals TS
N3925	A sample proposal	Y	Library Fundamentals TS
N3932	Variable Templates For Type Traits	Y	Library Fundamentals TS
N4100	File System	Y	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 callingMoveFileExW and so does not meet the requirements of POSIXrename 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 languageand libraryfeatures. Seedialectoptions. The pre-defined symbol__cplusplus is used to check for thepresence 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 stablesince that release.

This section describes the C++17 and library TS support inmainline GCC, not in any particular release.

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

Table 1.5. C++ 2017 Library Features

Library Feature	Proposal	Status	SD-6 Feature Test
`constexpr std::hardware_{constructive,destructive}_interference_size`	P0154R1	12.1	`__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	12.1
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.1 (`__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_string >= 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	11.1 (integral types supported since 8.1)	`__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 theheader 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 2018or 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 fromGCC 7.1 onwards. For GCC 6.x or for C++11/C++14 define__STDCPP_WANT_MATH_SPEC_FUNCS__ to a non-zero valueand test for__STDCPP_MATH_SPEC_FUNCS__ >= 201003L.

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

Table 1.6. C++ 2017 Implementation Status

Section	Description	Status	Comments
21	Language support
21.1	General
21.2	Common definitions
21.3	Implementation properties
21.3.1	General
21.3.2	Header`<limits>` synopsis
21.3.3	Floating-point type properties
21.3.3.1	`float_round_style`	N
21.3.3.2	`float_denorm_style`	N
21.3.4	Class template`numeric_limits`	Y
21.3.5	Header`<climits>` synopsis	Y
21.3.6	Header`<cfloat>` synopsis	Y
21.4	Integer types
21.4.1	Header`<cstdint>` synopsis	Y
21.5	Start and termination	Partial	C library dependency for quick_exit, at_quick_exit
21.6	Dynamic memory management
21.6.1	Header`<new>` synopsis
21.6.2	Storage allocation and deallocation	Y
21.6.3	Storage allocation errors	Y
21.6.4	Pointer optimization barrier	Y
21.6.5	Hardware interference size	Y
21.7	Type identification	Y
21.8	Exception handling
21.8.1	Header`<exception>` synopsis
21.8.2	Class exception	Y
21.8.3	Class bad_exception	Y
21.8.4	Abnormal termination	Y
21.8.5	`uncaught_exceptions`	Y
21.8.6	Exception Propagation	Y
21.8.7	`nested_exception`	Y
21.9	Initializer lists	Y
21.10	Other runtime support	Y
22	Diagnostics
22.1	General
22.2	Exception classes	Y
22.3	Assertions	Y
22.4	Error numbers	Y
22.5	System error support
23	General utilities
23.1	General
23.2	Utility components
23.2.1	Header`<utility>` synopsis
23.2.2	Operators	Y
23.2.3	`swap`	Y
23.2.4	`exchange`	Y
23.2.5	Forward/move helpers	Y
23.2.6	Function template`as_const`	Y
23.2.7	Function template`declval`	Y
23.2.8	Primitive numeric output conversion	Y	Floating-point types up to 64-bit are formatted usingRyu.Types with greater precision are formatted using the C library(`sprintf` and conditionally`strfromf128`).For powerpc64le-unknown-linux-gnu`__sprintfieee128`must be provided by Glibc.
23.2.9	Primitive numeric input conversion	Y	Floating-point types up to 64-bit are parsed usingfast_float.Types with greater precision are parsed using the C library(`strtold`).For powerpc64le-unknown-linux-gnu`__strtoieee128`must be provided by Glibc.
23.3	Compile-time integer sequences
23.4	Pairs	Y
23.5	Tuples	Y
23.6	Optional objects	Y
23.7	Variants	Y
23.8	Storage for any type	Y
23.9	Bitsets	Y
23.10	Memory	Y
23.10.1	In general
23.10.2	Header`<memory>` synopsis	Y
23.10.3	Pointer traits	Y
23.10.4	Pointer safety	Y
23.10.5	Align	Y
23.10.6	Allocator argument tag	Y
23.10.7	`uses_allocator`	Y
23.10.8	Allocator traits	Y
23.10.9	The default allocator	Y
23.10.10	Specialized algorithms	Y
23.10.11	C library memory allocation	Y
23.11	Smart pointers
23.11.1	Class template`unique_ptr`	Y
23.11.2	Shared-ownership pointers	Y
23.12	Memory resources
23.12.1	Header`<memory_resource>` synopsis	Y
23.12.2	Class`memory_resource`	Y
23.12.3	Class template`polymorphic_allocator`	Y
23.12.4	Access to program-wide`memory_resource` objects	Y
23.12.5	Pool resource classes	Y
23.12.6	Class`monotonic_buffer_resource`	Y
23.13	Class template`scoped_allocator_adaptor`	Y
23.14	Function objects
23.14.1	Header`<functional>` synopsis
23.14.2	Definitions
23.14.3	Requirements
23.14.4	Function template`invoke`	Y
23.14.5	Class template`reference_wrapper`	Y
23.14.6	Arithmetic operation	Y
23.14.7	Comparisons	Y
23.14.8	Logical operations	Y
23.14.9	Bitwise operations	Y
23.14.10	Function template`not_fn`	Y
23.14.11	Function object binders	Y
23.14.12	Function template`mem_fn`	Y
23.14.13	Polymorphic function wrappers	Y
23.14.14	Searchers	Y
23.14.15	Class template`hash`	Y
23.15	Metaprogramming and type traits
23.15.1	Requirements
23.15.2	Header`<type_traits>` synopsis	Y
23.15.3	Helper classes	Y
23.15.4	Unary Type Traits	Y
23.15.5	Type property queries	Y
23.15.6	Relationships between types	Y
23.15.7	Transformations between types	Y
23.15.8	Logical operator traits	Y
23.16	Compile-time rational arithmetic	Y
23.17.1	In general
23.17.2	Header`<chrono>` synopsis
23.17	Time utilities
23.17.3	Clock requirements	Y
23.17.4	Time-related traits	Y
23.17.5	Class template`duration`	Y
23.17.6	Class template`time_point`	Y
23.17.7	Clocks	Y
23.17.8	Header`<ctime>` synopsis	Y
23.18	Class`type_index`	Y
23.19	Execution policies
23.19.1	In general
23.19.2	Header`<execution>` synopsis
23.19.3	Execution policy type trait	Y
23.19.4	Sequenced execution policy	Y
23.19.5	Parallel execution policy	Y
23.19.6	Parallel and unsequenced execution policy	Y
23.19.7	Execution policy objects	Y
24	Strings
24.1	General
24.2	Character traits	Y
24.3	String classes	Y
24.4	String view classes	Y
24.4.1	Header`<string_view>` synopsis	Y
24.4.2	Class template`basic_string_view`	Y
24.4.3	Non-member comparison functions	Y
24.4.4	Inserters and extractors	Y
24.4.5	Hash support	Y
24.4.6	Suffix for`basic_string_view` literals	Y
24.5	Null-terminated sequence utilities	Partial	C library dependency.
25	Localization
25.1	General	Y
25.2	Header`<locale>` synopsis	Y
25.3	Locales	Y
25.4	Standard`locale` categories	Y
25.5	C Library Locales	Y
26	Containers
26.1	General
26.2	Container requirements	Y
26.3	Sequence containers	Y
26.4	Associative containers	Y
26.5	Unordered associative containers	Y
26.6	Container adaptors	Y
27	Iterators
27.1	General	Y
27.2	Iterator requirements	Y
27.3	Header`<iterator>` synopsis	Y
27.4	Iterator primitives	Y
27.5	Iterator adaptors	Y
27.6	Stream iterators	Y
27.7	Range access	Y
27.8	Container access	Y
28	Algorithms
28.1	General
28.2	Header`<algorithm>` synopsis
28.3	Algorithms requirements
28.4	Parallel algorithms		Uses code fromoneDPL
28.5	Non-modifying sequence operations	Y
28.6	Mutating sequence operations	Y
28.7	Sorting and related operations	Y
28.8	C library algorithms	Y
29	Numerics
29.1	General
29.2	Definitions
29.3	Numeric type requirements	Y
29.4	The floating-point environment	Y
29.5	Complex numbers	Y
29.6	Random number generation	Y
29.7	Numeric arrays	Y
29.8	Generalized numeric operations
29.8.1	Header`<numeric>` synopsis
29.8.2	Accumulate	Y
29.8.3	Reduce	Y
29.8.4	Inner product	Y
29.8.5	Transform reduce	Y
29.8.6	Partial sum	Y
29.8.7	Exclusive scan	Y
29.8.8	Inclusive scan	Y
29.8.9	Transform exclusive scan	Y
29.8.10	Transform inclusive scan	Y
29.8.11	Adjacent difference	Y
29.8.12	Iota	Y
29.8.13	Greatest common divisor	Y
29.8.14	Least common multiple	Y
29.9	Mathematical functions for floating-point types
29.9.1	Header`<cmath>` synopsis
29.9.2	Absolute values	Y
29.9.3	Three-dimensional hypotenuse	Y
29.9.4	Classification / comparison functions	Y
29.9.5	Mathematical special functions	Y
30	Input/output library
30.1	General	Y
30.2	Iostreams requirements	Y
30.2.1	Imbue Limitations	Y
30.2.2	Positioning Type Limitations	Y
30.2.3	Thread safety	Partial
30.3	Forward declarations	Y
30.4	Standard iostream objects	Y
30.5	Iostreams base classes	Y
30.6	Stream buffers	Y
30.7	Formatting and manipulators	Y
30.8	String-based streams	Y
30.9	File-based streams	Y
30.10	File systemss	Y
30.11	C library files	Y
31	Regular expressions
31.1	General	Y
31.2	Definitions	Y
31.3	Requirements	Y
31.4	Header`<regex>` synopsis	Y
31.5	Namespace`std::regex_constants`	Y
31.6	Class`regex_error`	Y
31.7	Class template`regex_traits`	Partial	`transform_primary` is not correctly implemented
31.8	Class template`basic_regex`	Y
31.9	Class template`sub_match`	Y
31.10	Class template`match_results`	Y
31.11	Regular expression algorithms	Y
31.12	Regular expression Iterators	Y
31.13	Modified ECMAScript regular expression grammar	Y
32	Atomic operations
32.1	General	Y
32.2	Header`<atomic>` synopsis	Y
32.3	Type aliases	Y
32.4	Order and consistency	Y
32.5	Lock-free property	Y
32.6	Class template`<atomic>`	Y
32.7	Non-member functions	Y
32.8	Flag Type and operations	Y
32.9	Fences	Y
33	Thread support
33.1	General	Y
33.2	Requirements	Y
33.3	Threads
33.3.1	Header`thread` synopsis
33.3.2	Class`thread`	Y
33.3.2.1	Class`thread`	Partial	`thread::id` comparisons not well-defined
33.3.3	Namespace`this_thread`	Y
33.4	Mutual exclusion
33.4.3	Mutex requirements
33.4.3.1	In general
33.4.3.2	Mutex types
33.4.3.2.1	Class`mutex`	Y
33.4.3.2.2	Class`recursive_mutex`	Y
33.4.3.3	Timed mutex types
33.4.3.3.1	Class`timed_mutex`	Y
33.4.3.3.2	Class`recursive_timed_mutex`	Y
33.4.3.4	Shared mutex types
33.4.3.4.1	Class`shared_mutex`	Y
33.4.3.5	Shared timed mutex types
33.4.3.5.1	Class`shared_timed_mutex`	Y
33.4.4	Locks
33.4.4.1	Class template`lock_guard`	Y
33.4.4.2	Class template`scoped_guard`	Y
33.4.4.3	Class template`unique_lock`	Y
33.4.4.4	Class template`shared_lock`	Y
33.4.5	Generic locking algorithms	Y
33.4.6	Call once
33.4.6.1	Struct`once_flag`	Y
33.4.6.2	Function`call_once`	Y	Exception support is broken.SeePR66146.
33.5	Condition variables	Y
33.5.1	Class`condition_variable`	Y
33.5.2	Class`condition_variable_any`	Y
33.6	Futures
33.6.1	Overview
33.6.2	Header`<future>`
33.6.3	Error handling	Y
33.6.4	Class`future_error`	Y
33.6.5	Shared state	Y
33.6.6	Class template`promise`	Y
33.6.7	Class template`future`	Y
33.6.8	Class template`shared_future`	Y
33.6.9	Function template`async`	Y
33.6.10	Class template`packaged_task`	Y
Appendix D	Compatibility features
D.4	C++ standard library headers	Y
D.4.1	Header`<ccomplex>` synopsis	Y
D.4.1	Header`<cstdalign>` synopsis	Y
D.4.1	Header`<cstdbool>` synopsis	Y
D.4.1	Header`<ctgmath>` synopsis	Y
D.5	C standard library headers	Y
D.6	`char*` streams	Y
D.7	`uncaught_exception`	Y
D.8	Old adaptable function bindings	Y
D.9	The default allocator	Y
D.10	Raw storage iterator	Y
D.11	Temporary buffers	Y
D.12	Deprecated type traits	Y
D.13	Deprecated iterator primitives	Y
D.14	Deprecated`shared_ptr` observers	Y
D.15	Deprecated standard code conversion facets	Y
D.16	Deprecated convenience conversion interfaces	Y

Table 1.7. C++ Technical Specifications Implementation Status

Paper	Title	Status	Comments
N4076	A generalized callable negator	Y	Library Fundamentals 2 TS
N4273	Uniform Container Erasure	Y	Library Fundamentals 2 TS
N4061	Greatest Common Divisor and Least Common Multiple	Y	Library Fundamentals 2 TS
N4066	Delimited iterators	Y	Library Fundamentals 2 TS
N4282	The World's Dumbest Smart Pointer	Y	Library Fundamentals 2 TS
N4388	Const-Propagating Wrapper	Y	Library Fundamentals 2 TS
N4391	`make_array`, revision 4	Y	Library Fundamentals 2 TS
N4502	Support for the C++ Detection Idiom, V2	Y	Library Fundamentals 2 TS
N4519	Source-Code Information Capture	Y	Library 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)	Y	Library Fundamentals 2 TS
N4531	std::rand replacement, revision 3	Y	Library Fundamentals 2 TS
P0214R9	Data-Parallel Types	Y	Parallelism 2 TS

Implementation Specific Behavior

For behaviour which is also specified by previous standards, seeC++ 1998/2003 Implementation Specific Behavior andC++ 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.8.2 [any.bad_any_cast]what() returns"bad any_cast".

23.12.5 [mem.res.pool.options],23.12.5 [mem.res.pool.mem] Let S equalnumeric_limits<size_t>::digits. The limit for maximum number of blocks in a chunk is given by2^N-1, where N ismin(19, 3 + S/2). The largest allocation size that will be allocated from a pool is2²² whenS > 20, otherwise 3072 whenS > 16, otherwise 768.

23.12.6.1 [mem.res.monotonic.buffer.ctor] The defaultnext_buffer_size is128 * sizeof(void*). The default growth factor is1.5.

23.15.4.3 [meta.unary.prop] The predicate condition forhas_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 isC* andbasic_string_view<C, T>::const_iterator isconst C*.

28.4.3 [algorithms.parallel.exec] Threads of execution created bystd::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 theFENV_ACCESS pragma is supported, and on the C library that provides the header.

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

29.9.5 [sf.cmath] Calling the mathematical special functions with large inputs is supported but the results may be imprecise.

30.7.5.2.3 [ostream.inserters] NTCTS fornullptr_t is"nullptr".

30.10.2.1 [fs.conform.9945],30.10.2.2 [fs.conform.os] 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 callingMoveFileExW and so does not meet the requirements of POSIXrename 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).

30.10.29.2 [fs.enum.file_type],30.10.34.3 [fs.op.copy],30.10.34.35 [fs.op.status] No additional file types are supported, and there are no implementation-defined enumerators instd::filesystem::file_type.

30.10.32 [fs.class.directory_iterator],30.10.33 [fs.class.rec.dir.itr] Any directory-like file types supported byopendir/readdir (or_wopendir/_wreaddir on Windows).

Parallelism 2 TS

9.3 [parallel.simd.abi]max_fixed_size<T> is 32, except when targetting AVX512BW andsizeof(T) is 1.

When targeting 32-bit x86,simd_abi::compatible<T> is an alias forsimd_abi::scalar. When targeting 64-bit x86 (including x32) or Aarch64,simd_abi::compatible<T> is an alias forsimd_abi::_VecBuiltin<16>, unlessT islong double, in which case it is an alias forsimd_abi::scalar. When targeting ARM (but not Aarch64) with NEON support,simd_abi::compatible<T> is an alias forsimd_abi::_VecBuiltin<16>, unlesssizeof(T) > 4, in which case it is an alias forsimd_abi::scalar. Additionally,simd_abi::compatible<float> is an alias forsimd_abi::scalar unless compiling with -ffast-math.

When targeting x86 (both 32-bit and 64-bit),simd_abi::native<T> is an alias for one ofsimd_abi::scalar,simd_abi::_VecBuiltin<16>,simd_abi::_VecBuiltin<32>, orsimd_abi::_VecBltnBtmsk<64>, depending onT and the machine options the compiler was invoked with.

When targeting ARM/Aarch64 or POWER,simd_abi::native<T> is an alias forsimd_abi::scalar orsimd_abi::_VecBuiltin<16>, depending onT and the machine options the compiler was invoked with.

For any other targeted machinesimd_abi::compatible<T> andsimd_abi::native<T> are aliases forsimd_abi::scalar. (subject to change)

The extended ABI tag types defined in thestd::experimental::parallelism_v2::simd_abi namespace are:simd_abi::_VecBuiltin<Bytes>, andsimd_abi::_VecBltnBtmsk<Bytes>.

simd_abi::deduce<T, N, Abis...>::type, withN > 1 is an alias for an extended ABI tag, if a supported extended ABI tag exists. Otherwise it is an alias forsimd_abi::fixed_size<N>. The simd_abi::_VecBltnBtmsk ABI tag is preferred oversimd_abi::_VecBuiltin.

9.4 [parallel.simd.traits]memory_alignment<T, U>::value issizeof(U) * T::size() rounded up to the next power-of-two value.

9.6.1 [parallel.simd.overview] On ARM,simd<T, _VecBuiltin<Bytes>> is supported if__ARM_NEON is defined andsizeof(T) <= 4. Additionally,sizeof(T) == 8 with integralT is supported if__ARM_ARCH >= 8, anddouble is supported if__aarch64__ is defined. On POWER,simd<T, _VecBuiltin<Bytes>> is supported if__ALTIVEC__ is defined andsizeof(T) < 8. Additionally,double is supported if__VSX__ is defined, and anyT with sizeof(T) <= 8 is supported if__POWER8_VECTOR__ is defined. On x86, given an extended ABI tagAbi,simd<T, Abi> is supported according to the following table:

Table 1.8. Support for Extended ABI Tags

ABI tag`Abi`	value type`T`	values for`Bytes`	required machine option
`_VecBuiltin<Bytes>`	`float`	8, 12, 16	"-msse"
	`float`	20, 24, 28, 32	"-mavx"
	`double`	16	"-msse2"
	`double`	24, 32	"-mavx"
	integral types other than`bool`	`Bytes` ≤ 16 and`Bytes` divisible by`sizeof(T)`	"-msse2"
	integral types other than`bool`	16 <`Bytes` ≤ 32 and`Bytes` divisible by`sizeof(T)`	"-mavx2"
`_VecBuiltin<Bytes>` and`_VecBltnBtmsk<Bytes>`	vectorizable types with`sizeof(T)` ≥ 4	32 <`Bytes` ≤ 64 and`Bytes` divisible by`sizeof(T)`	"-mavx512f"
`_VecBuiltin<Bytes>` and`_VecBltnBtmsk<Bytes>`	vectorizable types with`sizeof(T)` < 4	32 <`Bytes` ≤ 64 and`Bytes` divisible by`sizeof(T)`	"-mavx512bw"
`_VecBltnBtmsk<Bytes>`	vectorizable types with`sizeof(T)` ≥ 4	`Bytes` ≤ 32 and`Bytes` divisible by`sizeof(T)`	"-mavx512vl"
`_VecBltnBtmsk<Bytes>`	vectorizable types with`sizeof(T)` < 4	`Bytes` ≤ 32 and`Bytes` divisible by`sizeof(T)`	"-mavx512bw" and "-mavx512vl"

C++ 2020

In this implementation the-std=gnu++20 or-std=c++20 flag must be used to enable languageand libraryfeatures. Seedialectoptions. The pre-defined symbol__cplusplus is used to check for thepresence of the required flag.

This section describes the C++20 and library TS support inmainline GCC, not in any particular release.

The following table lists new library features that are included inthe C++20 standard. The "Proposal" column provides a link to theISO C++ committee proposal that describes the feature, while the "Status"column indicates the first version of GCC that contains an implementation ofthis feature (if it has been implemented).A dash (—) in the status column indicates that the changes in the proposaleither 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 fromSD-6:Feature-testing recommendations for C++ (where applicable)or any notes about the implementation.

Table 1.9. C++ 2020 Library Features

Library Feature Proposal Status SD-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 forswap and swap related functions P0879R0 10.1 __cpp_lib_constexpr_algorithms >= 201806L

Constexpr forstd::complex P0415R1 9.1 __cpp_lib_constexpr_complex >= 201711L (since 9.4, see Note 1)

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

Makingstd::string constexpr P0980R1 12.1 __cpp_lib_constexpr_string >= 201907L

Makingstd::vector constexpr P1004R2 12.1 __cpp_lib_constexpr_vector >= 201907L

Constexpr instd::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 forstd::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

constexprINVOKE P1065R2 10.1 __cpp_lib_constexpr_functional >= 201907L

Transformation Traitremove_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)

Theidentity metafunction P0887R1 9.1 __cpp_lib_type_identity >= 201806L (since 9.4, see Note 1)

unwrap_ref_decay andunwrap_reference P0318R1 9.1 __cpp_lib_unwrap_ref >= 201811L (since 9.4, see Note 1)

Improving Completeness Requirements for Type Traits P1285R0 — Most misuses are diagnosed, but not all.

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

12.1

__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 11.1 __cpp_lib_syncbuf >= 201711L

Manipulators for C++ Synchronized Buffered Ostream P0753R2 11.1 __cpp_lib_syncbuf >= 201803L

Makestd::memory_order a scoped enumeration P0439R0 9.1

The Curious Case of Padding Bits, Featuring Atomic Compare-and-Exchange P0528R3 13.1

Atomicshared_ptr P0718R2 12.1 __cpp_lib_atomic_shared_ptr >= 201711L

std::stop_token and std::jthread P0660R10 10.1 __cpp_lib_jthread >= 201907L

Renamecondition_variable_any interruptible wait methods P1869R1 10.1 __cpp_lib_jthread >= 201911L

Atomic waiting and notifying, std::semaphore, std::latch and std::barrier

P1135R6

11.1

__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 forboolean-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 forsafe_ranges in combination with ‘subrange-y’ view adaptors. P1739R4 12.1

Time, dates, calendars, time zones

Extending chrono to Calendars and Time Zones P0355R7 14.1 (see Note 2) __cpp_lib_chrono >= 201803L

Miscellaneous minor fixes for chrono P1466R3 11.1 (see Note 2) __cpp_lib_chrono >= 201907L

<chrono>zero(),min(), andmax() should benoexcept 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 11.1

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 13.1 __cpp_lib_format >= 201907L

Integration of chrono with text formatting P1361R2 13.1 __cpp_lib_format >= 201907L

Printf corner cases instd::format P1652R1 13.1 __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 forstd::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 11.1 __cpp_lib_generic_unordered_lookup >= 201811

Refinement Proposal for P0919 P1690R1 11.1

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: Freeerase/erase_if

P1115R3

9.1

__cpp_lib_erase_if >= 202002L

(defined to201900L 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)

Extendingmake_shared to Support Arrays P0674R1 12.1 __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 12.1 __cpp_lib_smart_ptr_for_overwrite >= 201811L

Rename "default_init" Functions P1973R1 12.1 __cpp_lib_smart_ptr_for_overwrite >= 201811L

Make stateful allocator propagation more consistent foroperator+(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 withstd::move P0616R0 9.1

Deprecate POD P0767R1 10.1

Treating Unnecessarydecay P0777R1 9.1

Thou Shalt Not Specialize std Function Templates! P0551R3 These changes will not be implemented.

Bit-casting object representations P0476R2 11.1 __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 12.1

fpos Requirements P0759R1 —

Addshift 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 benoexcept P0771R1 7.2

Simplified partial function application P0356R5 9.1 __cpp_lib_bind_front >= 201811L

bind_front should not unwrapreference_wrapper P1651R0 9.3 __cpp_lib_bind_front >= 201907L

reference_wrapper for incomplete types P0357R3 9.1

Fixingoperator>>(basic_istream&, CharT*) (LWG 2499) P0487R1 11.1

variant andoptional should propagate copy/move triviality P0602R4 8.3

A sanevariant converting constructor P0608R3 10.1

visit<R>: Explicit Return Type forvisit 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 foristream_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 —

Makecreate_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 11.1 __cpp_lib_source_location >= 201907L

Efficient access to std::basic_stringbuf's Buffer P0408R7 11.1

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.

Note 2: The C++20 calendar types are supported since 11.1,time zones and UTC are supported since 13.1,andchrono::parse is supported since 14.1.

The following status table is based on the table of contents ofISO/IEC 14882:2020.Some subclauses are not shown in the table where the content is unchangedsince C++17 and the implementation is complete.

Table 1.10. C++ 2020 Implementation Status

Section	Description	Status	Comments
17	Language support library
17.1	General
17.2	Common definitions
17.2.1	Header`<cstddef>` synopsis	Y
17.2.2	Header`<cstdlib>` synopsis	Y
17.2.3	Null pointers	Y
17.2.4	Sizes, alignments, and offsets	Y
17.2.5	`byte` type operations	Y
17.3	Implementation properties
17.3.1	General
17.3.2	Header`<version>` synopsis	Y
17.3.3	Header`<limits>` synopsis	Y
17.3.4	Floating-point type properties
17.3.4.1	Type`float_round_style`	N
17.3.4.2	Type`float_denorm_style`	N
17.3.5	Class template`numeric_limits`	Y
17.3.6	Header`<climits>` synopsis	Y
17.3.7	Header`<cfloat>` synopsis	Y
17.4	Integer types
17.4.1	General
17.4.2	Header`<cstdint>` synopsis	Y
17.5	Startup and termination	Partial	C library dependency for quick_exit, at_quick_exit
17.6	Dynamic memory management	Y
17.7	Type identification	Y
17.8	Source location
17.8.1	Header`<source_location>` synopsis	Y
17.8.2	Class`source_location`	Y
17.9	Exception handling	Y
17.10	Initializer lists	Y
17.11	Comparisons
17.11.1	Header`<compare>` synopsis	Y
17.11.2	Comparison category types	Y
17.11.3	Class template`common_comparison_category`	Y
17.11.4	Concept`three_way_comparable`	Y
17.11.5	Result of three-way comparison	Y
17.11.6	Comparison algorithms	Y
17.12	Coroutines
17.12.1	General
17.12.2	Header`<coroutine>` synopsis	Y
17.12.3	Coroutine traits	Y
17.12.4	Class template`coroutine_handle`	Y
17.12.5	No-op coroutines	Y
17.13	Other runtime support	Y
18	Concepts library
18.1	General
18.2	Equality preservation
18.3	Header`<concepts>` synopsis	Y
18.4	Language-related concepts
18.4.1	General
18.4.2	Concept`same_as`	Y
18.4.3	Concept`derived_from`	Y
18.4.4	Concept`convertible_to`	Y
18.4.5	Concept`common_reference_with`	Y
18.4.6	Concept`common_with`	Y
18.4.7	Arithmetic concepts
18.4.8	Concept`assignable_from`	Y
18.4.9	Concept`swappable`	Y
18.4.10	Concept`destructible`	Y
18.4.11	Concept`constructible_from`	Y
18.4.12	Concept`default_initializable`	Y
18.4.13	Concept`move_constructible`	Y
18.4.14	Concept`copy_constructible`	Y
18.5	Comparison concepts
18.5.1	General
18.5.2	Boolean testability	Y
18.5.3	Concept`equality_comparable`	Y
18.5.4	Concept`totally_ordered`	Y
18.6	Object concepts	Y
18.7	Callable concepts
18.7.1	General
18.7.2	Concept`invocable`	Y
18.7.3	Concept`regular_invocable`	Y
18.7.4	Concept`predicate`	Y
18.7.5	Concept`relation`	Y
18.7.6	Concept`equivalence_relation`	Y
18.7.7	Concept`strict_weak_order`	Y
19	Diagnostics library
19.1	General
19.2	Exception classes	Y
19.3	Assertions	Y
19.4	Error numbers	Y
19.5	System error support
19.5.1	General
19.5.2	Header`<system_error>` synopsis	Y
19.5.3	Class`error_category`	Y
19.5.4	Class`error_code`	Y
19.5.5	Class`error_condition`	Y
19.5.6	Comparison operator functions	Y
19.5.7	System error hash support	Y
19.5.8	Class`system_error`	Y
20	General utilities library
20.1	General
20.2	Utility components
20.2.1	Header`<utility>` synopsis	Y
20.2.2	`swap`	Y
20.2.3	`exchange`	Y
20.2.4	Forward/move helpers	Y
20.2.5	Function template`as_const`	Y
20.2.6	Function template`declval`	Y
20.2.7	Integer comparison functions	Y
20.3	Compile-time integer sequences	Y
20.4	Pairs	Y
20.5	Tuples	Y
20.6	Optional objects	Y
20.7	Variants	Y
20.8	Storage for any type	Y
20.9	Bitsets	Y
20.10	Memory	Y
20.11	Smart pointers
20.11.1	Class template`unique_ptr`	Y
20.11.2	Class`bad_weak_ptr`	Y
20.11.3	Class template`shared_ptr`	Y	Uses code from boost::shared_ptr.
20.11.4	Class template`weak_ptr`	Y
20.11.5	Class template`owner_less`	Y
20.11.6	Class template`enable_shared_from_this`	Y
20.11.7	Smart pointer hash support	Y
20.12	Memory resources
20.12.1	Header`<memory_resource>` synopsis	Y
20.12.2	Class`memory_resource`	Y
20.12.3	Class template`polymorphic_allocator`	Y
20.12.4	Access to program-wide`memory_resource` objects	Y
20.12.5	Pool resource classes	Y
20.12.6	Class`monotonic_buffer_resource`	Y
20.13	Class template`scoped_allocator_adaptor`	Y
20.14	Function objects
20.14.1	General
20.14.2	Header`<functional>` synopsis	Y
20.14.3	Definitions
20.14.4	Requirements
20.14.5	Function template`invoke`	Y
20.14.6	Class template`reference_wrapper`	Y
20.14.7	Arithmetic operations	Y
20.14.8	Comparisons	Y
20.14.9	Concept-constrained comparisons	Y
20.14.10	Logical operations	Y
20.14.11	Bitwise operations	Y
20.14.12	Class`identity`	Y
20.14.13	Function template`not_fn`	Y
20.14.14	Function template`bind_front`	Y
20.14.15	Function object binders	Y
20.14.16	Function template`mem_fn`	Y
20.14.17	Polymorphic function wrappers
20.14.17.1	General
20.14.17.2	Class`bad_function_call`	Y
20.14.17.3	Class template`function`	Y
20.14.18	Searchers	Y
20.15	Metaprogramming and type traits
20.15.1	General
20.15.2	Requirements	Y
20.15.3	Header`<type_traits>` synopsis	Y
20.15.4	Helper classes	Y
20.15.5	Unary type traits	Y
20.15.6	Type property queries	Y
20.15.7	Relationships between types	Y
20.15.8	Transformations between types	Y
20.15.9	Logical operator traits	Y
20.15.10	Member relationships	Y
20.15.11	Constant evaluation context	Y
20.16	Compile-time rational arithmetic	Y
20.17	Class`type_index`	Y
20.18	Execution policies	Y
20.19	Primitive numeric conversions
20.19.1	Header`<charconv>` synopsis	Y
20.19.2	Primitive numeric output conversion	Y	Floating-point types up to 64-bit are formatted usingRyu.Types with greater precision are formatted using the C library(`sprintf` and conditionally`strfromf128`).For powerpc64le-unknown-linux-gnu`__sprintfieee128`must be provided by Glibc.
20.19.3	Primitive numeric input conversion	Y	Floating-point types up to 64-bit are parsed usingfast_float.Types with greater precision are parsed using the C library(`strtold`).For powerpc64le-unknown-linux-gnu`__strtoieee128`must be provided by Glibc.
20.20	Formatting
20.20.1	Header`<format>` synopsis	Y
20.20.2	Format string
20.20.2.1	In general	Y
20.20.2.2	Standard format specifiers	Y
20.20.3	Error reporting	Y
20.20.4	Formatting functions	Y
20.20.5	Formatter	Y
20.20.5.1	Formatter requirements
20.20.5.2	Formatter specializations	Y
20.20.5.3	Class template`basic_format_parse_context`	Y
20.20.5.4	Class template`basic_format_context`	Y
20.20.6	Arguments
20.20.6.1	Class template`basic_format_arg`	Y
20.20.6.2	Class templateformat-arg-store	Y
20.20.6.3	Class template`basic_format_args`	Y
20.20.7	Class`format_error`	Y
21	Strings library
21.1	General
21.2	Character traits	Y
21.3	String classes	Y
21.4	String view classes	Y
21.5	Null-terminated sequence utilities	Partial	C library dependency.
22	Containers library
22.1	General
22.2	Container requirements	Y
22.3	Sequence containers	Y
22.4	Associative containers	Y
22.5	Unordered associative containers	Y
22.6	Container adaptors	Y
22.7	Views
22.7.1	General
22.7.2	Header`<span>` synopsis	Y
22.7.3	Class template`span`	Y
23	Iterators library
23.1	General
23.2	Header`<iterator>` synopsis	Y
23.3	Iterator requirements
23.3.1	In general	Y
23.3.2	Associated types	Y
23.3.3	Customization points	Y
23.3.4	Iterator concepts	Y
23.3.5	C++17 iterator requirements	Y
23.3.6	Indirect callable requirements	Y
23.3.7	Common algorithm requirements	Y
23.4	Iterator primitives
23.4.1	General
23.4.2	Standard iterator tags	Y
23.4.3	Iterator operations	Y
23.4.4	Range iterator operations	Y
23.5	Iterator adaptors
23.5.1	Reverse iterators	Y
23.5.2	Insert iterators	Y
23.5.3	Move iterators and sentinels	Y
23.5.4	Common iterators	Y
23.5.5	Default sentinel	Y
23.5.6	Counted iterators	Y
23.5.7	Unreachable sentinel	Y
23.6	Stream iterators	Y
23.6.1	General
23.6.2	Class template`istream_iterator`	Y
23.6.3	Class template`ostream_iterator`	Y
23.6.4	Class template`istreambuf_iterator`	Y
23.6.5	Class template`ostreambuf_iterator`	Y
23.7	Range access	Y
24	Ranges library
24.1	General
24.2	Header`<ranges>` synopsis	Y
24.3	Range access	Y
24.4	Range requirements
24.4.1	General
24.4.2	Ranges	Y
24.4.3	Sized ranges	Y
24.4.4	Views	Y
24.4.5	Other range refinements	Y
24.5	Range utilities
24.5.1	General
24.5.2	Helper concepts	Y
24.5.3	View interface	Y
24.5.4	Sub-ranges	Y
24.5.5	Dangling iterator handling	Y
24.6	Range factories
24.6.1	General
24.6.2	Empty view	Y
24.6.3	Single view	Y
24.6.4	Iota view	Y
24.6.5	Istream view	Y
24.7	Range adaptors
24.7.1	General
24.7.2	Range adaptor objects	Y
24.7.3	Semiregular wrapper	Y
24.7.4	All view	Y
24.7.5	Filter view	Y
24.7.6	Transform view	Y
24.7.7	Take view	Y
24.7.8	Take while view	Y
24.7.9	Drop view	Y
24.7.10	Drop while view	Y
24.7.11	Join view	Y
24.7.12	Split view	Y
24.7.13	Counted view	Y
24.7.14	Common view	Y
24.7.15	Reverse view	Y
24.7.16	Elements view	Y
25	Algorithms library
25.1	General
25.2	Algorithms requirements	Y
25.3	Parallel algorithms		Uses code fromoneDPL
25.4	Header`<algorithm>` synopsis	Y
25.5	Algorithm result types	Y
25.6	Non-modifying sequence operations
25.6.1	All of	Y
25.6.2	Any of	Y
25.6.3	None of	Y
25.6.4	For each	Y
25.6.5	Find	Y
25.6.6	Find end	Y
25.6.7	Find first	Y
25.6.8	Adjacent find	Y
25.6.9	Count	Y
25.6.10	Mismatch	Y
25.6.11	Equal	Y
25.6.12	Is permutation	Y
25.6.13	Search	Y
25.7	Mutating sequence operations
25.7.1	Copy	Y
25.7.2	Move	Y
25.7.3	Swap	Y
25.7.4	Transform	Y
25.7.5	Replace	Y
25.7.6	Fill	Y
25.7.7	Generate	Y
25.7.8	Remove	Y
25.7.9	Unique	Y
25.7.10	Reverse	Y
25.7.11	Rotate	Y
25.7.12	Sample	Y
25.7.13	Shuffle	Y
25.7.14	Shift	Y
25.8	Sorting and related operations
25.8.1	General	Y
25.8.2	Sorting	Y
25.8.3	Nth element	Y
25.8.4	Binary search	Y
25.8.5	Partitions	Y
25.8.6	Merge	Y
25.8.7	Set operations on sorted structures	Y
25.8.8	Heap operations	Y
25.8.9	Minimum and maximum	Y
25.8.10	Bounded value	Y
25.8.11	Lexicographical comparison	Y
25.8.12	Three-way comparison algorithms	Y
25.8.13	Permutation generators	Y
25.9	Header`<numeric>` synopsis	Y
25.10	Generalized numeric operations
25.10.1	General
25.10.2	Definitions
25.10.3	Accumulate	Y
25.10.4	Reduce	Y
25.10.5	Inner product	Y
25.10.6	Transform reduce	Y
25.10.7	Partial sum	Y
25.10.8	Exclusive scan	Y
25.10.9	Inclusive scan	Y
25.10.10	Transform exclusive scan	Y
25.10.11	Transform inclusive scan	Y
25.10.12	Adjacent difference	Y
25.10.13	Iota	Y
25.10.14	Greatest common divisor	Y
25.10.15	Least common multiple	Y
25.10.16	Midpoint	Y
25.11	Specialized`<memory>` algorithms
25.11.1	General
25.11.2	Special memory concepts	Y
25.11.3	`uninitialized_default_construct`	Y
25.11.4	`uninitialized_value_construct`	Y
25.11.5	`uninitialized_copy`	Y
25.11.6	`uninitialized_move`	Y
25.11.7	`uninitialized_fill`	Y
25.11.8	`construct_at`	Y
25.11.9	`destroy`	Y
25.12	C library algorithms	Y
26	Numerics library
26.1	General
26.2	Numeric type requirements	Y
26.3	The floating-point environment	Y
26.4	Complex numbers	Y
26.5	Bit manipulation
26.5.1	General
26.5.2	Header`<bit>` synopsis	Y
26.5.3	Function template`bit_cast`	Y
26.5.4	Integral powers of 2	Y
26.5.5	Rotating	Y
26.5.6	Counting	Y
26.5.7	Endian	Y
26.6	Random number generation	Y
26.7	Numeric arrays	Y
26.8	Mathematical functions for floating-point types	Y
26.9	Numbers
26.9.1	Header`<numbers>` synopsis	Y
26.9.2	Mathematical constants	Y
27	Time library
27.1	General
27.2	Header`<chrono>` synopsis	Y
27.3	Cpp17Clock requirements	Y
27.4	Time-related traits
27.4.1	`treat_as_floating_point`	Y
27.4.2	`duration_values`	Y
27.4.3	Specializations of`common_type`	Y
27.4.4	Class template`is_clock`	Y
27.5	Class template`duration`
27.5.1	General	Y
27.5.2	Constructors	Y
27.5.3	Observer	Y
27.5.4	Arithmetic	Y
27.5.5	Special values	Y
27.5.6	Non-member arithmetic	Y
27.5.7	Comparisons	Y
27.5.8	Conversions	Y
27.5.9	Suffixes for duration literals	Y
27.5.10	Algorithms	Y
27.5.11	I/O	Y
27.6	Class template`time_point`	Y
27.7	Clocks
27.7.1	General	Y
27.7.2	Class`system_clock`	Y
27.7.3	Class`utc_clock`	Y
27.7.4	Class`tai_clock`	Y
27.7.5	Class`gps_clock`	Y
27.7.6	Type`file_clock`	Y
27.7.7	Class`steady_clock`	Y
27.7.8	Class`high_resolution_clock`	Y
27.7.9	Local time	Y
27.7.10	`time_point` conversions	Y
27.8	The civil calendar
27.8.1	In general
27.8.2	Class`last_spec`	Y
27.8.3	Class`day`	Y
27.8.4	Class`month`	Y
27.8.5	Class`year`	Y
27.8.6	Class`weekday`	Y
27.8.7	Class`weekday_indexed`	Y
27.8.8	Class`weekday_last`	Y
27.8.9	Class`month_day`	Y
27.8.10	Class`month_day_last`	Y
27.8.11	Class`month_weekday`	Y
27.8.12	Class`month_weekday_last`	Y
27.8.13	Class`year_month`	Y
27.8.14	Class`year_month_day`	Y
27.8.15	Class`year_month_day_last`	Y
27.8.16	Class`year_month_weekday`	Y
27.8.17	Class`year_month_weekday_last`	Y
27.9	Class template`hh_mm_ss`	Y
27.10	12/24 hours functions	Y
27.11	Time zones
27.11.1	In general
27.11.2	Time zone database	Y
27.11.3	Exception classes	Y
27.11.4	Information classes	Y
27.11.5	Class`time_zone`	Y
27.11.6	Class template`zoned_traits`	Y
27.11.7	Class template`zoned_time`	Y
27.11.8	Class`leap_second`	Y
27.11.9	Class`time_zone_link`	Y
27.12	Formatting	Y
27.13	Parsing	Y
27.14	Header`<ctime>` synopsis	Y
28	Localization library
28.1	General
28.2	Header`<locale>` synopsis	Y
28.3	Locales
28.3.1	Class`locale`	Y
28.3.2	`locale` globals	Y
28.3.3	Convenience interfaces
28.3.3.1	Character classification	Y
28.3.3.2	Character conversions	Y
28.4	Standard`locale` categories
28.4.1	General
28.4.2	The`ctype` category	Y
28.4.3	The numeric category	Y
28.4.4	The numeric punctuation facet	Y
28.4.5	The collate category	Y
28.4.6	The time category	Y
28.4.7	The monetary category	Y
28.4.8	The message retrieval category	Y
28.5	C library locales	Y
29	Input/output library
29.1	General	Y
29.2	Iostreams requirements
29.2.1	Imbue limitations	Y
29.2.2	Positioning type limitations	Y
29.2.3	Thread safety	Partial
29.3	Forward declarations	Y
29.4	Standard iostream objects	Y
29.5	Iostreams base classes	Y
29.6	Stream buffers	Y
29.7	Formatting and manipulators	Y
29.8	String-based streams	Y
29.9	File-based streams	Y
29.10	Synchronized output streams
29.10.1	Header`<syncstream>` synopsis	Y
29.10.2	Class template`basic_syncbuf`	Y
29.10.3	Class template`basic_osyncstream`	Y
29.11	File systems
29.11.1	General
29.11.2	Conformance	Y
29.11.3	Requirements	Y
29.11.4	Header`<filesystem>` synopsis	Y
29.11.5	Error reporting	Y
29.11.6	Class`path`	Y
29.11.7	Class`filesystem_error`	Y
29.11.8	Enumerations
29.11.8.1	Enum`path::format`	Y
29.11.8.2	Enum class`file_type`	Y
29.11.8.3	Enum class`copy_options`	Y
29.11.8.4	Enum class`perms`	Y
29.11.8.5	Enum class`perm_options`	Y
29.11.8.6	Enum class`directory_options`	Y
29.11.9	Class`file_status`	Y
29.11.10	Class`directory_entry`	Y
29.11.11	Class`directory_iterator`	Y
29.11.12	Class`recursive_directory_iterator`	Y
29.11.13	Filesystem operation functions	Y
29.12	C library files
29.12.1	Header`<cstdio>` synopsis	Y
29.12.2	Header`<cinttypes>` synopsis	Y
30	Regular expressions library
30.1	General	Y
30.2	Requirements	Y
30.3	Header`<regex>` synopsis	Y
30.4	Namespace`std::regex_constants`	Y
30.5	Class`regex_error`	Y
30.6	Class template`regex_traits`	Partial	`transform_primary` is not correctly implemented
30.7	Class template`basic_regex`	Y
30.8	Class template`sub_match`	Y
30.9	Class template`match_results`	Y
30.10	Regular expression algorithms	Y
30.11	Regular expression iterators	Y
30.12	Modified ECMAScript regular expression grammar	Y
31	Atomics library
31.1	General	Y
31.2	Header`<atomic>` synopsis	Y
31.3	Type aliases	Y
31.4	Order and consistency	Y
31.5	Lock-free property	Y
31.6	Waiting and notifying	Partial	Waiting and notifying is not supported for volatile objects.
31.7	Class template`atomic_ref`
31.7.1	General	Y
31.7.2	Operations	Partial	volatile-qualified overloads for`wait`,`notify_one`, and`notify_all` are not provided.
31.7.3	Specializations for integral types	Y
31.7.4	Specializations for floating-point types	Y
31.7.5	Partial specialization for pointers	Y
31.8	Class template`atomic`
31.8.1	General	Y
31.8.2	Operations on atomic types	Partial	Waiting and notifying is not supported for volatile objects.
31.8.3	Specializations for integers	Y
31.8.4	Specializations for floating-point types	Y
31.8.5	Partial specialization for pointers	Y
31.8.6	Member operators common to integers and pointers to objects	Y
31.8.7	Partial specializations for smart pointers
31.8.7.1	General	Y
31.8.7.2	Partial specialization for`shared_ptr`	Y
31.8.7.3	Partial specialization for`weak_ptr`	Y
31.9	Non-member functions	Y
31.10	Flag type and operations	Y
31.11	Fences	Y
32	Threads library
32.1	General	Y
32.2	Requirements	Y
32.3	Stop tokens
32.3.1	Introduction	Y
32.3.2	Header`<stop_token>` synopsis	Y
32.3.3	Class`stop_token`	Y
32.3.4	Class`stop_source`	Y
32.3.5	Class template`stop_callback`	Y
32.4	Threads
32.4.1	General
32.4.2	Header`<thread>` synopsis	Y
32.4.3	Class`thread`	Partial	`thread::id` comparisons not well-defined
32.4.4	Class`jthread`	Y
32.4.5	Namespace`this_thread`	Y
32.5	Mutual exclusion
32.5.1	General
32.5.2	Header`<mutex>` synopsis
32.5.3	Header`<shared_mutex>` synopsis
32.5.4	Mutex requirements
32.5.4.1	In general
32.5.4.2	Mutex types	Y
32.5.4.3	Timed mutex types	Y
32.5.4.4	Shared mutex types	Y
32.5.4.5	Shared timed mutex types	Y
32.5.5	Locks	Y
32.5.6	Generic locking algorithms	Y
32.5.7	Call once
32.5.7.1	Struct`once_flag`	Y
32.5.7.2	Function`call_once`	Partial	Exception support is broken.SeePR66146.
32.6	Condition variables	Y
32.7	Semaphore	Y
32.7.1	General
32.7.2	Header`<semaphore>` synopsis	Y
32.7.3	Class template`counting_semaphore`	Y
32.8	Coordination types
32.8.1	General
32.8.2	Latches
32.8.2.1	General
32.8.2.2	Header`<latch>` synopsis	Y
32.8.2.3	Class`latch`	Y
32.8.3	Barriers
32.8.3.1	General
32.8.3.2	Header`<barrier>` synopsis	Y
32.8.3.3	Class template`barrier`	Y
32.9	Futures	Y
Appendix D	Compatibility features
D.10	C headers
D.10.1	General	Y
D.10.2	Header`<complex.h>` synopsis	Y
D.10.3	Header`<iso646.h>` synopsis	Y
D.10.4	Header`<stdalign.h>` synopsis	Y
D.10.5	Header`<stdbool.h>` synopsis	Y
D.10.6	Header`<tgmath.h>` synopsis	Y
D.10.7	Other C headers	Y
D.12	Relational operators	Y
D.13	`char*` streams	Y
D.13.1	Header`<strstream>` synopsis	Y
D.13.2	Class`strstreambuf`	Y
D.13.3	Class`istrstream`	Y
D.13.4	Class`ostrstream`	Y
D.13.5	Class`strstream`	Y
D.14	Deprecated type traits	Y
D.15	Tuple	Y
D.16	Variant	Y
D.17	Deprecated`iterator` class template	Y
D.18	Deprecated`move_iterator` access	Y
D.19	Deprecated`shared_ptr` atomic access	Y
D.20	Deprecated`basic_string` capacity	Y
D.21	Deprecated standard code conversion facets
D.21.1	General	Y
D.21.2	Header`<codecvt>` synopsis	Y
D.21.3	Requirements	Y
D.22	Deprecated convenience conversion interfaces
D.22.1	General	Y
D.22.2	Class template`wstring_convert`	Y
D.22.3	Class template`wbuffer_convert`	Y
D.23	Deprecated locale category facets	Y
D.24	Deprecated filesystem path factory functions	Y
D.25	Deprecated atomic operations
D.25.1	General	Y
D.25.2	Volatile access	Y
D.25.3	Non-member functions	Y
D.25.4	Operations on atomic types	Y
D.25.5	Flag type and operations	Y

Implementation Specific Behavior

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

16.4.2.4 [compliance] The implementation is freestanding if the-ffreestanding compiler flag is used, and hosted otherwise.

16.4.2.4 [compliance] The support for always lock-free integral atomic types and presence ofatomic_signed_lock_free andatomic_unsigned_lock_free type aliases depends on the target.

27.5.11 [time.duration.io] The"μs" ("\u00b5\u0073") is used forstd::microPeriod::type if the macro_GLIBCXX_USE_ALT_MICROSECONDS_SUFFIX is defined to a value other than zero before inclusion of thechrono header,"us" is used otherwise.

29.8.2.2 [stringbuf.cons] Sequence pointers are initialized to null pointers by thebasic_stringbuf(ios_base::openmode) constructor.

31.7.1 [atomics.ref.generic.general],31.7.3 [atomics.ref.int],31.7.4 [atomics.ref.float],31.7.5 [atomics.ref.pointer] The values ofis_always_lock_free members depend on the target and cannot be listed here.

31.7.1 [atomics.ref.generic.general] Ifsizeof(T) is equal to either1,2,4,8, or16, then the value ofrequired_alignment member is equal to the maximum ofalignof(T) andsizeof(T). Otherwiserequired_alignment value isalignof(T).

31.7.3 [atomics.ref.int] The value ofrequired_alignment member is equal to the maximum ofalignof(value_type) andsizeof(value_type).

31.7.4 [atomics.ref.float],31.7.5 [atomics.ref.pointer] The value ofrequired_alignment member is equal toalignof(value_type).

32.7.3 [thread.sema.cnt] The value of default argument for theleast_max_value parameter depends on the target operating system and platform, however the value ofcounting_semaphore<>::max() is greater than or equal tonumeric_limits<int>::max().

C++ 2023

In this implementation the-std=gnu++23 or-std=c++23 flag must be used to enable languageand libraryfeatures. Seedialectoptions. The pre-defined symbol__cplusplus is used to check for thepresence of the required flag.

This section describes the C++23 and library TS support inmainline GCC, not in any particular release.

The following table lists new library features that have been accepted intothe C++23 working draft. The "Proposal" column provides a link to theISO C++ committee proposal that describes the feature, while the "Status"column indicates the first version of GCC that contains an implementation ofthis feature (if it has been implemented).A dash (—) in the status column indicates that the changes in the proposaleither 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 fromSD-6:Feature-testing recommendations for C++ (where applicable)or any notes about the implementation.

Table 1.11. C++ 2023 Library Features

Library Feature Proposal Status SD-6 Feature Test / Notes

Ranges and Views

Range constructor for std::string_view P1989R2 11.1

join_view should join all views of ranges P2328R1 11.2

Clarifying range adaptor objects P2281R1 11.1

Views should not be required to be default constructible P2325R3 11.3 __cpp_lib_ranges >= 202106L

Conditionally borrowed ranges P2017R1 11.1

Requirespan &basic_string_view to be Trivially Copyable P2251R1 Yes

Repairing input range adaptors and counted_iterator P2259R1 12.1

Superior String Splitting P2210R2 12.1

What is aview? P2415R2 12.1 __cpp_lib_ranges >= 202110L

Fix istream_view P2432R1 12.1

starts_with andends_with P1659R3 __cpp_lib_ranges_starts_ends_with >= 202106L

zip P2321R2 13.1 __cpp_lib_ranges_zip >= 202110L

views::repeat P2474R2 13.1 __cpp_lib_ranges_repeat >= 202207L

views::enumerate P2164R9 13.1 __cpp_lib_ranges_enumerate >= 202302L

views::join_with P2441R2 13.1 __cpp_lib_ranges_join_with >= 202202L

Windowing range adaptors:views::chunkandviews::slide P2442R1 13.1 __cpp_lib_ranges_slide >= 202202L

views::chunk_by P2443R1 13.1 __cpp_lib_ranges_chunk_by >= 202202L

views::stride P1899R3 13.1 __cpp_lib_ranges_stride >= 202207L

views::cartesian_product P2374R4 13.1 __cpp_lib_ranges_cartesian_product >= 202207L

Empty Product for certain Views P2540R1 13.1 __cpp_lib_ranges_cartesian_product >= 202207L

views::as_rvalue P2446R2 13.1 __cpp_lib_ranges_as_rvalue >= 202207L

cbegin should always return a constant iterator P2278R4 13.1 __cpp_lib_ranges_as_const >= 202207L

ranges::to

P1206R7

14.1 (ranges::to function)

15.1 (new members in containers)

__cpp_lib_ranges_to_container >= 202202L,__cpp_lib_containers_ranges >= 202202L

Ranges iterators as inputs to non-Ranges algorithms P2408R5 __cpp_lib_algorithm_iterator_requirements >= 202207L

Pipe support for user-defined range adaptors P2387R3 13.1 __cpp_lib_bind_pack >= 202202L,__cpp_lib_ranges >= 202202L

ranges::iota,ranges::shift_left, andranges::shift_right P2440R1 13.1 (ranges::iota) __cpp_lib_ranges_iota >= 202202L,__cpp_lib_shift >= 202202L

ranges::find_last P1223R5 13.1 __cpp_lib_ranges_find_last >= 202207L

ranges::contains P2302R4 13.1 __cpp_lib_ranges_contains >= 202207L

Making multi-param constructors of views explicit P2711R1

ranges::fold P2322R6 13.1 __cpp_lib_ranges_fold >= 202207L

Relaxing Ranges Just A Smidge P2609R3 14.3 __cpp_lib_ranges >= 202302L

Compile-time programming

A proposal for a type trait to detect scoped enumerations P1048R1 11.1 __cpp_lib_is_scoped_enum >= 202011L

std::to_underlying for enumerations P1682R3 11.1 __cpp_lib_to_underlying >= 202102L

Missing constexpr in std::optional and std::variant

P2231R1

11.3 (optional)

12.1 (variant)

__cpp_lib_constexpr_optional >= 202106L

__cpp_lib_variant >= 202106L

Makingstd::unique_ptr constexpr P2273R3 12.1 __cpp_lib_constexpr_memory >= 202202L

Makingstd::type_info::operator== constexpr P1328R1 12.1 __cpp_lib_constexpr_typeinfo >= 202106L

constexpr for<cmath> and<cstdlib> P0533R9 __cpp_lib_constexpr_cmath >= 202202L

Deprecate std::aligned_storage and std::aligned_union P1413R3 13.1

A type trait to detect reference binding to temporary

P2255R2

13.1 (missing changes tostd::tuple)

14.1 (complete)

__cpp_lib_reference_from_temporary >= 202202L

Move-only types for equality_comparable_with, totally_ordered_with,and three_way_comparable_with P2404R3 __cpp_lib_concepts >= 202207L

A trait for implicit lifetime types P2674R1 __cpp_lib_is_implicit_lifetime >= 202302L

common_reference_t ofreference_wrapperShould Be a Reference Type P2655R3 __cpp_lib_common_reference >= 202302L

Deprecatenumeric_limits::has_denorm P2614R2

Containers

Iterator pair constructors for stack and queue P1425R4 12.1 __cpp_lib_adaptor_iterator_pair_constructor >= 202106L

Stop overconstraining allocators in container deduction guides P1518R2 12.1

Heterogeneous erasure overloads for associative containers P2077R3 __cpp_lib_associative_heterogeneous_erasure >= 202110L

<flat_map> P0429R9 15.1 __cpp_lib_flat_map >= 202207L

<flat_set> P1222R4 15.1 __cpp_lib_flat_set >= 202207L

mdspan P0009R18 __cpp_lib_mdspan >= 202207L

index_type &size_typeinmdspan P2599R2 __cpp_lib_mdspan >= 202207L

mdspan: renamepointer andcontiguous P2604R0 __cpp_lib_mdspan >= 202207L

Add the missingempty tomdspan P2613R1 __cpp_lib_mdspan >= 202207L

layout_stride static extents default constructor fix P2763R1

Strings and text

string contains function P1679R3 11.1 __cpp_lib_string_contains >= 202011L

Prohibit std::basic_string and std::basic_string_view construction from nullptr P2166R1 12.1

basic_string::resize_and_overwrite P1072R10 12.1 __cpp_lib_resize_and_overwrite >= 202110L

A strstream replacement using span<charT> as buffer P0448R4 12.1 __cpp_lib_spanstream >= 202106L

std::string::substr() && P2438R2

std::format improvements P2216R3 13.1 __cpp_lib_format >= 202106L

Add support forstd::generator-like types tostd::format P2418R2 13.1 __cpp_lib_format >= 202110L

Exposestd::basic-format-string<charT, Args...> P2508R1 13.1 (feature test macro not updated until 15.1) __cpp_lib_format >= 202207L

Clarify handling of encodings in localized formatting of chrono types P2419R2 15.1 __cpp_lib_format >= 202207L

Formatting pointers P2510R3 13.2 (feature test macro not updated until 15.1) __cpp_lib_format >= 202207L

Formatting Ranges

P2286R8

15.1 (changes to adaptors missing)

15.2 (complete)

__cpp_lib_format_ranges >= 202207L

Improve default container formatting P2585R1 15.1 (feature test macro not defined until 15.2) __cpp_lib_format_ranges >= 202207L

Formatted output P2093R14 14.1 __cpp_lib_print >= 202207L

Should the output of std::print to a terminal be synchronized withthe underlying stream? P2539R3 14.1

Formattingthread::id andstacktrace P2693R1 14.1 __cpp_lib_formatters >= 202302L

Add Constexpr Modifiers to Functionsto_chars andfrom_chars for Integral Types in<charconv> Header P2291R3 13.1 __cpp_lib_constexpr_charconv >= 202207L

Miscellaneous

Inheriting fromstd::variant P2162R2 11.3 __cpp_lib_variant >= 202102L

Printingvolatile Pointers P1147R1 11.3

A Proposal to add stacktrace library P0881R7 12.1 __cpp_lib_stacktrace >= 202011L

Add a pmr alias for std::stacktrace P2301R1 12.1

std::expected P0323R12 12.1 __cpp_lib_expected >= 202202L

Monadic operations for std::expected P2505R5 13.1 __cpp_lib_expected >= 202211L

Monadic operations for std::optional P0798R8 12.1 __cpp_lib_optional >= 202110L

Compatibility betweentuple,pairandtuple-like objects P2165R4 14.1 __cpp_lib_tuple_like >= 202207L

Default Arguments forpair's Forwarding Constructor P1951R1 14.1

move_only_function P0288R9 12.1 __cpp_lib_move_only_function >= 202110L

invoke_r P2136R3 12.1 __cpp_lib_invoke_r >= 202106L

Byteswapping for fun&&nuf P1272R4 12.1 __cpp_lib_byteswap >= 202110L

Function to mark unreachable code P0627R6 12.1 __cpp_lib_unreachable >= 202202L

Add a conditional noexcept specification to std::exchange P2401R0 12.1

A more constexpr bitset P2417R2 13.1 __cpp_lib_constexpr_bitset >= 202207L

Extended floating-point types and standard names P1467R9 13.1

Support C atomics in C++ P0943R6 12.1 __cpp_lib_stdatomic_h >= 202011L

Clarifying the status of the "C headers" P2340R1 Yes

Relax Requirements for time_point::clock P2212R2 Yes

Removing Garbage Collection Support P2186R2 12.1

Easy [utilities], [ranges], and [iterators] P1642R11 13.1

Providing size feedback in the Allocator interface P0401R6 __cpp_lib_allocate_at_least >= 202306L

Disallow User Specialization ofallocator_traits P2652R2

Explicit lifetime management P2590R2 __cpp_lib_start_lifetime_as >= 202207L

Fixingstd::start_lifetime_as andstd::start_lifetime_as_array P2679R2

out_ptr - a scalable output pointer abstraction P1132R8 14.1 __cpp_lib_out_ptr >= 202106L

barrier's phase completion guarantees P2588R3 __cpp_lib_barrier >= 202302L

Standard Library Modulesstd andstd.compat P2465R3 15.1 __cpp_lib_modules >= 202207L

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 bytr1/, for instance<tr1/functional>,<tr1/memory>, and so on.

This page describes the TR1 support inmainline GCC, not in any particular release.

Table 1.12. C++ TR1 Implementation Status

Section	Description	Status	Comments
2	General Utilities
2.1	Reference wrappers
2.1.1	Additions to header`<functional>` synopsis	Y
2.1.2	Class template`reference_wrapper`
2.1.2.1	`reference_wrapper` construct/copy/destroy	Y
2.1.2.2	`reference_wrapper` assignment	Y
2.1.2.3	`reference_wrapper` access	Y
2.1.2.4	`reference_wrapper` invocation	Y
2.1.2.5	`reference_wrapper` helper functions	Y
2.2	Smart pointers
2.2.1	Additions to header`<memory>` synopsis	Y
2.2.2	Class`bad_weak_ptr`	Y
2.2.3	Class template`shared_ptr`		Uses code fromboost::shared_ptr.
2.2.3.1	`shared_ptr` constructors	Y
2.2.3.2	`shared_ptr` destructor	Y
2.2.3.3	`shared_ptr` assignment	Y
2.2.3.4	`shared_ptr` modifiers	Y
2.2.3.5	`shared_ptr` observers	Y
2.2.3.6	`shared_ptr` comparison	Y
2.2.3.7	`shared_ptr` I/O	Y
2.2.3.8	`shared_ptr` specialized algorithms	Y
2.2.3.9	`shared_ptr` casts	Y
2.2.3.10	`get_deleter`	Y
2.2.4	Class template`weak_ptr`
2.2.4.1	`weak_ptr` constructors	Y
2.2.4.2	`weak_ptr` destructor	Y
2.2.4.3	`weak_ptr` assignment	Y
2.2.4.4	`weak_ptr` modifiers	Y
2.2.4.5	`weak_ptr` observers	Y
2.2.4.6	`weak_ptr` comparison	Y
2.2.4.7	`weak_ptr` specialized algorithms	Y
2.2.5	Class template`enable_shared_from_this`	Y
3	Function Objects
3.1	Definitions	Y
3.2	Additions to`<functional> synopsis`	Y
3.3	Requirements	Y
3.4	Function return types	Y
3.5	Function template`mem_fn`	Y
3.6	Function object binders
3.6.1	Class template`is_bind_expression`	Y
3.6.2	Class template`is_placeholder`	Y
3.6.3	Function template`bind`	Y
3.6.4	Placeholders	Y
3.7	Polymorphic function wrappers
3.7.1	Class`bad_function_call`	Y
3.7.1.1	`bad_function_call` constructor	Y
3.7.2	Class template`function`
3.7.2.1	`function` construct/copy/destroy	Y
3.7.2.2	`function` modifiers	Y
3.7.2.3	`function` capacity	Y
3.7.2.4	`function` invocation	Y
3.7.2.5	`function` target access	Y
3.7.2.6	undefined operators	Y
3.7.2.7	null pointer comparison operators	Y
3.7.2.8	specialized algorithms	Y
4	Metaprogramming and type traits
4.1	Requirements	Y
4.2	Header`<type_traits>` synopsis	Y
4.3	Helper classes	Y
4.4	General Requirements	Y
4.5	Unary Type Traits
4.5.1	Primary Type Categories	Y
4.5.2	Composite type traits	Y
4.5.3	Type properties	Y
4.6	Relationships between types	Y
4.7	Transformations between types
4.7.1	Const-volatile modifications	Y
4.7.2	Reference modifications	Y
4.7.3	Array modifications	Y
4.7.4	Pointer modifications	Y
4.8	Other transformations	Y
4.9	Implementation requirements	Y
5	Numerical Facilities
5.1	Random number generation
5.1.1	Requirements	Y
5.1.2	Header`<random>` synopsis	Y
5.1.3	Class template`variate_generator`	Y
5.1.4	Random number engine class templates	Y
5.1.4.1	Class template`linear_congruential`	Y
5.1.4.2	Class template`mersenne_twister`	Y
5.1.4.3	Class template`subtract_with_carry`	Y
5.1.4.4	Class template`subtract_with_carry_01`	Y
5.1.4.5	Class template`discard_block`	Y
5.1.4.6	Class template`xor_combine`	Y	operator()() per N2079
5.1.5	Engines with predefined parameters	Y
5.1.6	Class`random_device`	Y
5.1.7	Random distribution class templates	Y
5.1.7.1	Class template`uniform_int`	Y
5.1.7.2	Class`bernoulli_distribution`	Y
5.1.7.3	Class template`geometric_distribution`	Y
5.1.7.4	Class template`poisson_distribution`	Y
5.1.7.5	Class template`binomial_distribution`	Y
5.1.7.6	Class template`uniform_real`	Y
5.1.7.7	Class template`exponential_distribution`	Y
5.1.7.8	Class template`normal_distribution`	Y
5.1.7.9	Class template`gamma_distribution`	Y
5.2	Mathematical special functions	Y
5.2.1	Additions to header`<cmath>` synopsis	Y
5.2.1.1	associated Laguerre polynomials	Y
5.2.1.2	associated Legendre functions	Y
5.2.1.3	beta function	Y
5.2.1.4	(complete) elliptic integral of the first kind	Y
5.2.1.5	(complete) elliptic integral of the second kind	Y
5.2.1.6	(complete) elliptic integral of the third kind	Y
5.2.1.7	confluent hypergeometric functions	Y
5.2.1.8	regular modified cylindrical Bessel functions	Y
5.2.1.9	cylindrical Bessel functions (of the first kind)	Y
5.2.1.10	irregular modified cylindrical Bessel functions	Y
5.2.1.11	cylindrical Neumann functions	Y
5.2.1.12	(incomplete) elliptic integral of the first kind	Y
5.2.1.13	(incomplete) elliptic integral of the second kind	Y
5.2.1.14	(incomplete) elliptic integral of the third kind	Y
5.2.1.15	exponential integral	Y
5.2.1.16	Hermite polynomials	Y
5.2.1.17	hypergeometric functions	Y
5.2.1.18	Laguerre polynomials	Y
5.2.1.19	Legendre polynomials	Y
5.2.1.20	Riemann zeta function	Y
5.2.1.21	spherical Bessel functions (of the first kind)	Y
5.2.1.22	spherical associated Legendre functions	Y
5.2.1.23	spherical Neumann functions	Y
5.2.2	Additions to header`<math.h>` synopsis	Y
6	Containers
6.1	Tuple types	Y
6.1.1	Header`<tuple>` synopsis	Y
6.1.2	Additions to header`<utility>` synopsis	Y
6.1.3	Class template`tuple`	Y
6.1.3.1	Construction	Y
6.1.3.2	Tuple creation functions	Y
6.1.3.3	Tuple helper classes	Y
6.1.3.4	Element access	Y
6.1.3.5	Relational operators	Y
6.1.4	Pairs	Y
6.2	Fixed size array	Y
6.2.1	Header`<array>` synopsis	Y
6.2.2	Class template`array`	Y
6.2.2.1	`array` constructors, copy, and assignment	Y
6.2.2.2	`array` specialized algorithms	Y
6.2.2.3	`array` size	Y
6.2.2.4	Zero sized`array`s	Y
6.2.2.5	Tuple interface to class template`array`	Y
6.3	Unordered associative containers	Y
6.3.1	Unordered associative container requirements	Y
6.3.1.1	Exception safety guarantees	Y
6.3.2	Additions to header`<functional>` synopsis	Y
6.3.3	Class template`hash`	Y
6.3.4	Unordered associative container classes	Y
6.3.4.1	Header`<unordered_set>` synopsis	Y
6.3.4.2	Header`<unordered_map>` synopsis	Y
6.3.4.3	Class template`unordered_set`	Y
6.3.4.3.1	`unordered_set` constructors	Y
6.3.4.3.2	`unordered_set` swap	Y
6.3.4.4	Class template`unordered_map`	Y
6.3.4.4.1	`unordered_map` constructors	Y
6.3.4.4.2	`unordered_map` element access	Y
6.3.4.4.3	`unordered_map` swap	Y
6.3.4.5	Class template`unordered_multiset`	Y
6.3.4.5.1	`unordered_multiset` constructors	Y
6.3.4.5.2	`unordered_multiset` swap	Y
6.3.4.6	Class template`unordered_multimap`	Y
6.3.4.6.1	`unordered_multimap` constructors	Y
6.3.4.6.2	`unordered_multimap` swap	Y
7	Regular Expressions
7.1	Definitions	N
7.2	Requirements	N
7.3	Regular expressions summary	N
7.4	Header`<regex>` synopsis	N
7.5	Namespace`tr1::regex_constants`	N
7.5.1	Bitmask Type`syntax_option_type`	N
7.5.2	Bitmask Type`regex_constants::match_flag_type`	N
7.5.3	Implementation defined`error_type`	N
7.6	Class`regex_error`	N
7.7	Class template`regex_traits`	N
7.8	Class template`basic_regex`	N
7.8.1	`basic_regex` constants	N
7.8.2	`basic_regex` constructors	N
7.8.3	`basic_regex` assign	N
7.8.4	`basic_regex` constant operations	N
7.8.5	`basic_regex` locale	N
7.8.6	`basic_regex` swap	N
7.8.7	`basic_regex` non-member functions	N
7.8.7.1	`basic_regex` non-member swap	N
7.9	Class template`sub_match`	N
7.9.1	`sub_match` members	N
7.9.2	`sub_match` non-member operators	N
7.10	Class template`match_results`	N
7.10.1	`match_results` constructors	N
7.10.2	`match_results` size	N
7.10.3	`match_results` element access	N
7.10.4	`match_results` formatting	N
7.10.5	`match_results` allocator	N
7.10.6	`match_results` swap	N
7.11	Regular expression algorithms	N
7.11.1	exceptions	N
7.11.2	`regex_match`	N
7.11.3	`regex_search`	N
7.11.4	`regex_replace`	N
7.12	Regular expression Iterators	N
7.12.1	Class template`regex_iterator`	N
7.12.1.1	`regex_iterator` constructors	N
7.12.1.2	`regex_iterator` comparisons	N
7.12.1.3	`regex_iterator` dereference	N
7.12.1.4	`regex_iterator` increment	N
7.12.2	Class template`regex_token_iterator`	N
7.12.2.1	`regex_token_iterator` constructors	N
7.12.2.2	`regex_token_iterator` comparisons	N
7.12.2.3	`regex_token_iterator` dereference	N
7.12.2.4	`regex_token_iterator` increment	N
7.13	Modified ECMAScript regular expression grammar	N
8	C Compatibility
8.1	Additions to header`<complex>`	Y
8.1.1	Synopsis	Y
8.1.2	Function`acos`	Y
8.1.3	Function`asin`	Y
8.1.4	Function`atan`	Y
8.1.5	Function`acosh`	Y
8.1.6	Function`asinh`	Y
8.1.7	Function`atanh`	Y
8.1.8	Function`fabs`	Y
8.1.9	Additional Overloads	Y
8.2	Header`<ccomplex>`	N	DR 551
8.3	Header`<complex.h>`	N	DR 551
8.4	Additions to header`<cctype>`	Y
8.4.1	Synopsis	Y
8.4.2	Function`isblank`	Y
8.5	Additions to header`<ctype.h>`	Y
8.6	Header`<cfenv>`	Y
8.6.1	Synopsis	Y
8.6.2	Definitions	Y
8.7	Header`<fenv.h>`	Y
8.8	Additions to header`<cfloat>`	Y
8.9	Additions to header`<float.h>`	Y
8.10	Additions to header`<ios>`	N
8.10.1	Synopsis	N
8.10.2	Function`hexfloat`	N
8.11	Header`<cinttypes>`	Y
8.11.1	Synopsis	Y	DR 557
8.11.2	Definitions	Y
8.12	Header`<inttypes.h>`	Y
8.13	Additions to header`<climits>`	Y
8.14	Additions to header`<limits.h>`	Y
8.15	Additions to header`<locale>`	N
8.16	Additions to header`<cmath>`	Y
8.16.1	Synopsis	Y
8.16.2	Definitions	Y
8.16.3	Function template definitions	Y
8.16.4	Additional overloads	Y	DR 568; DR 550
8.17	Additions to header`<math.h>`	Y
8.18	Additions to header`<cstdarg>`	Y
8.19	Additions to header`<stdarg.h>`	Y
8.20	The header`<cstdbool>`	Y
8.21	The header`<stdbool.h>`	Y
8.22	The header`<cstdint>`	Y
8.22.1	Synopsis	Y
8.22.2	Definitions	Y
8.23	The header`<stdint.h>`	Y
8.24	Additions to header`<cstdio>`	Y
8.24.1	Synopsis	Y
8.24.2	Definitions	Y
8.24.3	Additional format specifiers	Y	C library dependency
8.24.4	Additions to header`<stdio.h>`	Y
8.25	Additions to header`<cstdlib>`	Y
8.25.1	Synopsis	Y
8.25.2	Definitions	Y
8.25.3	Function`abs`	Y
8.25.4	Function`div`	Y
8.26	Additions to header`<stdlib.h>`	Y
8.27	Header`<ctgmath>`	Y	DR 551
8.28	Header`<tgmath.h>`	Y	DR 551
8.29	Additions to header`<ctime>`	Y	C library dependency
8.30	Additions to header`<cwchar>`	Y
8.30.1	Synopsis	Y
8.30.2	Definitions	Y
8.30.3	Additional wide format specifiers	Y	C library dependency
8.31	Additions to header`<wchar.h>`	Y
8.32	Additions to header`<cwctype>`	Y
8.32.1	Synopsis	Y
8.32.2	Function`iswblank`	Y
8.33	Additions to header`<wctype.h>`	Y

Implementation Specific Behavior

For behaviour which is specified by the 1998 and 2003 standards, seeC++ 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 areAssignable.

C++ TR 24733

This table is based on the table of contents ofISO/IEC TR 24733:2011,"Extensions for the programming language C++ to supportdecimal floating-point arithmetic".

This page describes the TR 24733 support inmainline GCC, not in any particular release.

Table 1.13. C++ TR 24733 Implementation Status

Section	Description	Status	Comments
0	Introduction
1	Normative references
2	Conventions
3	Decimal floating-point types
3.1	Characteristics of decimal floating-point types
3.2	Decimal Types
3.2.1	Class`decimal` synopsis	Partial	Missing declarations for formatted input/output; non-conforming extension for functions converting to integral type
3.2.2	Class`decimal32`	Partial	Missing 3.2.2.5 conversion to integral type; conforming extension for conversion from scalar decimal floating-point
3.2.3	Class`decimal64`	Partial	Missing 3.2.3.5 conversion to integral type; conforming extension for conversion from scalar decimal floating-point
3.2.4	Class`decimal128`	Partial	Missing 3.2.4.5 conversion to integral type; conforming extension for conversion from scalar decimal floating-point
3.2.5	Initialization from coefficient and exponent	Y
3.2.6	Conversion to generic floating-point type	Y
3.2.7	Unary arithmetic operators	Y
3.2.8	Binary arithmetic operators	Y
3.2.9	Comparison operators	Y
3.2.10	Formatted input	N
3.2.11	Formatted output	N
3.3	Additions to header`limits`	N
3.4	Headers`cfloat` and`float.h`
3.4.2	Additions to header`cfloat` synopsis	Y
3.4.3	Additions to header`float.h` synopsis	N
3.4.4	Maximum finite value	Y
3.4.5	Epsilon	Y
3.4.6	Minimum positive normal value	Y
3.4.7	Minimum positive subnormal value	Y
3.4.8	Evaluation format	Y
3.5	Additions to`cfenv` and`fenv.h`	Outside the scope of GCC
3.6	Additions to`cmath` and`math.h`	Outside the scope of GCC
3.7	Additions to`cstdio` and`stdio.h`	Outside the scope of GCC
3.8	Additions to`cstdlib` and`stdlib.h`	Outside the scope of GCC
3.9	Additions to`cwchar` and`wchar.h`	Outside the scope of GCC
3.10	Facets	N
3.11	Type traits	N
3.12	Hash functions	N
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 usingat 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 theirrespective 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 to201003L.

In addition to the special functions defined in IS 29124, fornon-strict modes (i.e.-std=gnu++NN modes) thehypergeometric functions and confluent hypergeometric functionsfrom TR1 are also provided, defined in namespace__gnu_cxx.

Table 1.14. C++ Special Functions Implementation Status

Section	Description	Status	Comments
7	Macro names	Partial	No diagnostic for inconsistent definitions of`__STDCPP_WANT_MATH_SPEC_FUNCS__`
8	Mathematical special functions	Y
8.1	Additions to header`<cmath>` synopsis	Y
8.1.1	associated Laguerre polynomials	Y
8.1.2	associated Legendre functions	Y
8.1.3	beta function	Y
8.1.4	(complete) elliptic integral of the first kind	Y
8.1.5	(complete) elliptic integral of the second kind	Y
8.1.6	(complete) elliptic integral of the third kind	Y
8.1.7	regular modified cylindrical Bessel functions	Y
8.1.8	cylindrical Bessel functions (of the first kind)	Y
8.1.9	irregular modified cylindrical Bessel functions	Y
8.1.10	cylindrical Neumann functions	Y
8.1.11	(incomplete) elliptic integral of the first kind	Y
8.1.12	(incomplete) elliptic integral of the second kind	Y
8.1.13	(incomplete) elliptic integral of the third kind	Y
8.1.14	exponential integral	Y
8.1.15	Hermite polynomials	Y
8.1.16	Laguerre polynomials	Y
8.1.17	Legendre polynomials	Y
8.1.18	Riemann zeta function	Y
8.1.19	spherical Bessel functions (of the first kind)	Y
8.1.20	spherical associated Legendre functions	Y
8.1.21	spherical Neumann functions	Y
8.2	Additions to header`<math.h>`	Y
8.3	The header`<ctgmath>`	Partial	Conflicts with C++ 2011 requirements.
8.4	The header`<tgmath.h>`	N	Conflicts with C++ 2011 requirements.

Implementation Specific Behavior

For behaviour which is specified by the 2011 standard, seeC++ 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 withn >= 128 orm >= 128 should be described here.

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

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

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

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

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

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

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

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

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

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

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