ISO C++
1998
C++ 1998/2003
Implementation Status
This status table is based on the table of contents of ISO/IEC 14882:2003.
This page describes the C++0x support in mainline GCC SVN, not in any
particular release.
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.