Chapter 1. Status

Chapter 1. Status
Prev	Part I. + Introduction + +	Next

Table 1.1. C++ 1998/2003 Implementation Status

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 implementation and that each implementation + shall document. +

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

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

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

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

[18.1]/4 The type of NULL is described + here. +

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

[18.4.2.1]/5 (bad_alloc), + [18.5.2]/5 (bad_cast), + [18.5.3]/5 (bad_typeid), + [18.6.1]/8 (exception), + [18.6.2.1]/5 (bad_exception): The what() + member function of class std::exception, and these other + classes publicly derived from it, simply returns the name of the + class. But they are the mangled names; you will need to call + c++filt and pass the names as command-line parameters to + demangle them, or call a + runtime demangler function. + (The classes in <stdexcept> have constructors which + require an argument to use later for what() calls, so the + problem of what()'s value does not arise in most + user-defined exceptions.) +

[18.5.1]/7 The return value of + std::type_info::name() is the mangled type name (see the + previous entry for more). +

[20.1.5]/5 "Implementors are encouraged to + supply libraries that can accept allocators that encapsulate more + general memory models and that support non-equal instances. In such + implementations, any requirements imposed on allocators by containers + beyond those requirements that appear in Table 32, and the semantics + of containers and algorithms when allocator instances compare + non-equal, are implementation-defined." As yet we don't + have any allocators which compare non-equal, so we can't describe how + they behave. +

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

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

[22.*] Anything and everything we have on locale + implementation will be described + over here. +

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

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

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

[27.7.1.3]/16, + [27.8.1.4]/10 + The effects of pubsetbuf/setbuf are described + in this chapter. +

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

C++ 200x

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

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

+This page describes the C++0x support in the GCC 4.6 release series. +

Table 1.2. C++ 200x Implementation Status

Section	Description	Status	Comments
+ 18 +	+ Language support +
18.1	General	Y
18.2	Types	Partial	Missing offsetof, max_align_t
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	N
18.10	Other runtime support	Y
+ 19 +	+ Diagnostics +
19.1	General	Y
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` and `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	Partial	`tuple_cat` should be a single variadic signature (DR 1385)
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	N
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	N
20.6.4	Pointer safety	Partial
20.6.5	Align	N
20.6.6	Allocator argument tag	Y
20.6.7	`uses_allocator`	Y
20.6.8	Allocator traits	N
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	Y
20.7.2.1	Class `bad_weak_ptr`	Y
20.7.2.2	Class template `shared_ptr`	Y	+ + Uses code from + boost::shared_ptr. + +
20.7.2.3	Class template `weak_ptr`	Y
20.7.2.4	Class template `emable_shared_from_this`	Y
20.7.2.5	`shared_ptr` atomic access	Partial
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`	Partial	Missing overloads for reference-qualified member functions
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	Partial	Missing is_trivially_copyable, + is_assignable, is_copy_assignable, is_move_assignable, + is_trivially_constructible, is_trivially_default_constructible, + is_trivially_copy_constructible, is_trivially_move_constructible, + is_trivially_assignable, is_trivially_default_assignable, + is_trivially_copy_assignable, is_trivially_move_assignable, + is_trivially_destructible, + is_nothrow_assignable, + is_nothrow_copy_assignable, is_nothrow_move_assignable, + is_nothrow_destructible +
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`	Partial	Missing constexpr for non-member arithmetic operations
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`	N	Support old `monotonic_clock` spec instead
20.11.7.3	Class `high_resolution_clock`	Y
20.11.8	Date and time functions	Y
20.12	Scoped allocator adaptor
20.12.1	Header `<scoped_allocator>` synopsis
20.12.2	Scoped allocator adaptor member types	N
20.12.3	Scoped allocator adaptor constructors	N
20.12.4	Scoped allocator adaptor members	N
20.12.5	Scoped allocator operators	N
20.13	Class `type_index`	N
+ 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>`	Partial	Missing constexpr
21.2.3.2	struct `char_traits<char16_t>`	Partial	Missing constexpr
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	Y	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	N
22.3.3.2.3	Buffer conversions	N
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	N
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	N
+ 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	Y
26.2	Numeric type requirements	Y
26.3	The floating-point environment	Y
26.4	Complex numbers	Partial	Missing constexpr
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	Missing constexpr
26.5.3.2	Class template `mersenne_twister_engine`	Y	Missing constexpr
26.5.3.3	Class template `subtract_with_carry_engine`	Y	Missing constexpr
26.5.4	Random number engine adaptor class templates
26.5.4.2	Class template `discard_block_engine`	Y	Missing constexpr
26.5.4.3	Class template `independent_bits_engine`	Y	Missing constexpr
26.5.4.4	Class template `shuffle_order_engine`	Y	Missing constexpr
26.5.5	Engines and engine adaptors with predefined parameters	Y
26.5.6	Class `random_device`	Y	Missing constexpr
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`	Partial	Missing move and swap operations
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	Partial	+ Missing move and swap operations on `basic_ios`. Missing + `make_error_code` and `make_error_condition`. +
27.6	Stream buffers	Y
27.7	Formatting and manipulators	Partial	Missing move and swap operations
27.8	String-based streams	Partial	Missing move and swap operations
27.9	File-based streams	Partial	Missing move and swap operations
+ 28 +	+ Regular expressions +
28.1	General	N
28.2	Definitions	N
28.3	Requirements	N
28.4	Header `<regex>` synopsis	N
28.5	Namespace `std::regex_constants`	Y
28.6	Class `regex_error`	Y
28.7	Class template `regex_traits`	Partial
28.8	Class template `basic_regex`	Partial
28.9	Class template `sub_match`	Partial
28.10	Class template `match_results`	Partial
28.11	Regular expression algorithms	N
28.12	Regular expression Iterators	N
28.13	Modified ECMAScript regular expression grammar	N
+ 29 +	+ Atomic operations +
29.1	General	Y
29.2	Header `<atomic>` synopsis	Y
29.3	Order and consistency	N
29.4	Lock-free property	Partial	Missing `ATOMIC_BOOL_LOCK_FREE` and + `ATOMIC_POINTER_LOCK_FREE`. + Based on _GLIBCXX_ATOMIC_PROPERTY +
29.5	Atomic types	Partial	Missing constexpr
29.6	Operations on atomic types	Y
29.7	Flag Type and operations	Y
29.8	Fences	N
+ 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
30.5	Condition variables	Partial	Missing notify_all_at_thread_exit
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`	Partial	Missing set_*_at_thread_exit
30.6.6	Class template `future`	Partial	Missing future_status and future::share()
30.6.7	Class template `shared_future`	Partial	Missing future_status
30.6.8	Function template `async`	Y
30.6.9	Class template `packaged_task`	Partial	Missing make_ready_at_thread_exit
+ 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
D.6	Old iostreams members
D.7	`char*` streams
D.8	Function objects
D.9	Binders
D.10	`auto_ptr`
D.11	Violating exception-specifications

C++ TR1

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

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

+This page describes the TR1 support in mainline GCC SVN, not in any particular +release. +

Table 1.3. 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 from + boost::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

C++ TR 24733

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

+This page describes the TR 24733 support in mainline GCC SVN, not in any +particular release. +

Table 1.4. 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 +