Chapter 1. Status

Table of Contents

Implementation Status
C++ 1998/2003
Implementation Status
Implementation Specific Behavior
C++ 2011
Implementation Specific Behavior
C++ TR1
Implementation Specific Behavior
C++ TR 24733
The Code: GPL
The Documentation: GPL, FDL
Implementation Bugs
Standard Bugs

Implementation Status

C++ 1998/2003

Implementation Status

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

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

Table 1.1. C++ 1998/2003 Implementation Status

18 Language support
18.2Implementation propertiesY 
18.2.1Numeric Limits template numeric_limitsY membersY specializationsY 
18.2.2C LibraryY 
18.3Start and terminationY 
18.4Dynamic memory managementY 
18.5Type identification  
18.5.1Class type_infoY 
18.5.2Class bad_castY 
18.5.3Class bad_typeidY 
18.6Exception handling  
18.6.1Class exceptionY 
18.6.2Violation exception-specificationsY 
18.6.3Abnormal terminationY 
18.7Other runtime supportY 
19 Diagnostics
19.1Exception classesY 
19.3Error numbersY 
20 General utilities
20.2Utility components  
20.3Function objects  
20.3.2Arithmetic operationY 
20.3.4Logical operationsY 
20.3.7Adaptors for pointers to functionsY 
20.3.8Adaptors for pointers to membersY 
20.4.1The default allocatorY 
20.4.2Raw storage iteratorY 
20.4.3Temporary buffersY 
20.4.4Specialized algorithmsY 
20.4.5Class template auto_ptrY 
20.4.6C libraryY 
21 Strings
21.1Character traits  
21.1.1Character traits requirementsY 
21.1.2traits typedefY 
21.1.3char_traits specializations char_traits<char>Y char_traits<wchar_t>Y 
21.2String classesY 
21.3Class template basic_stringY 
21.4Null-terminated sequence utilitiesYC library dependency
22 Localization
22.1.1Class localeY 
22.1.2locale globalsY 
22.1.3Convenience interfaces classificationY conversionsY 
22.2Standard locale categories  
22.2.8Program-defined facetsY 
22.3C Library LocalesY 
23 Containers
23.1Container requirementsY 
23.2Sequence containers  
23.2.1Class template dequeY 
23.2.2Class template listY 
23.2.3Adaptors template queueY template priority_queueY template stackY 
23.2.4Class template vectorY 
23.2.5Class vector<bool>Y 
23.3Associative containers  
23.3.1Class template mapY 
23.3.2Class template multimapY 
23.3.3Class template setY 
23.3.4Class template multisetY 
24 Iterators
24.2Header <iterator> synopsisY 
24.3Iterator primitivesY 
24.4Predefined iterators and Iterator adaptors  
24.4.1Reverse iteratorsY 
24.4.2Insert iteratorsY 
24.5Stream iterators  
24.5.1Class template istream_iteratorY 
24.5.2Class template ostream_iteratorY 
24.5.3Class template istreambuf_iteratorY 
24.5.4Class template ostreambuf_iteratorY 
25 Algorithms
25.1Non-modifying sequence operationsY 
25.2Mutating sequence operationsY 
25.3Sorting and related operationsY 
25.4C library algorithmsY 
26 Numerics
26.1Numeric type requirementsY 
26.2Complex numbersY 
26.3Numeric arrays  
26.3.1Header <valarray> synopsisY 
26.3.2Class template valarrayY 
26.3.3valarray non-member operationsY 
26.3.4Class sliceY 
26.3.5Class template slice_arrayY 
26.3.6Class gsliceY 
26.3.7Class template gslice_arrayY 
26.3.8Class template mask_arrayY 
26.3.9Class template indirect_arrayY 
26.4Generalized numeric operations  
26.5C LibraryY 
27 Input/output
27.2Forward declarationsY 
27.3Standard iostream objectsY 
27.3.1Narrow stream objectsY 
27.3.2Wide stream objectsY 
27.4Iostreams base classesY 
27.5Stream buffersY 
27.6Formatting and manipulatorsY 
27.7String-based streamsY 
27.8File-based streamsY 
Appendix D Compatibility features
D.1Increment operator with bool operand  
D.2static keyword  
D.3Access declarations  
D.4Implicit conversion from const strings  
D.5C standard library headers  
D.6Old iostreams members  
D.7char* streams  

Implementation Specific Behavior

The ISO standard defines the following phrase:

[1.3.5] implementation-defined behavior

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

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

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

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

[] 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. :-)

[]/5 (bad_alloc), [18.5.2]/5 (bad_cast), [18.5.3]/5 (bad_typeid), [18.6.1]/8 (exception), []/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.

[]/3,4, []/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. :-)

[]/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.

[]/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!

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

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

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

C++ 2011

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

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

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

Table 1.2. C++ 2011 Implementation Status

18 Language support
18.2TypesPartialMissing offsetof, max_align_t
18.3Implementation properties  
18.3.2Numeric Limits template numeric_limitsY membersY specializationsY 
18.3.3C LibraryY 
18.4Integer types  
18.4.1Header <cstdint> synopsisY 
18.5Start and terminationPartialC library dependency for quick_exit, at_quick_exit
18.6Dynamic memory managementPartialMissing get_new_handler. set_new_handler is not thread-safe.
18.7Type identification  
18.7.1Class type_infoY 
18.7.2Class bad_castY 
18.7.3Class bad_typeidY 
18.8Exception handling  
18.8.1Class exceptionY 
18.8.2Class bad_exceptionY 
18.8.3Abnormal terminationPartialMissing get_terminate. set_terminate is not thread-safe.
18.8.5Exception PropagationY 
18.9Initializer lists  
18.9.1Initializer list constructorsY 
18.9.2Initializer list accessY 
18.9.3Initializer list range accessY 
18.10Other runtime supportY 
19 Diagnostics
19.2Exception classesPartialMissing const char* constructors.
19.4Error numbersY 
19.5System error support  
19.5.1Class error_categoryY 
19.5.2Class error_codeY 
19.5.3Class error_conditionY 
19.5.4Comparison operatorsY 
19.5.5Class system_errorPartialMissing const char* constructors.
20 General utilities
20.2Utility components  
20.2.3forward and move helpersY 
20.2.4Function template declvalY 
20.3.1In general  
20.3.2Class template pairY 
20.3.3Specialized algorithmsY 
20.3.4Tuple-like access to pairY 
20.3.5Piecewise constructionY 
20.4.1In general  
20.4.2Class template tuple creation functionsY helper classesY accessY operatorsY traitsY specialized algorithmsY 
20.5Class template bitsetY 
20.5.1bitset constructorsY 
20.5.2bitset membersY 
20.5.3bitset hash supportY 
20.5.4bitset operatorsY 
20.6.1In general  
20.6.2Header <memory> synopsis  
20.6.3Pointer traitsY 
20.6.4Pointer safetyPartial 
20.6.6Allocator argument tagY 
20.6.8Allocator traitsY 
20.6.9The default allocatorY 
20.6.10Raw storage iteratorY 
20.6.11Temporary buffersY 
20.6.12Specialized algorithms 
20.6.13C libraryY 
20.7Smart pointers  
20.7.1Class template unique_ptrY 
20.7.2Shared-ownership pointersY bad_weak_ptrY template shared_ptrY

Uses code from boost::shared_ptr. template weak_ptrY template emable_shared_from_thisY atomic accessPartial pointer hash supportY 
20.8Function objects  
20.8.3Class template reference_wrapperY 
20.8.4Arithmetic operationY 
20.8.6Logical operationsY 
20.8.7Bitwise operationsY 
20.8.9Function template bindY 
20.8.10Function template mem_fnY 
20.8.11Polymorphic function wrappers bad_function_callY template functionPartialMissing allocator support
20.8.12Class template hashY 
20.9Metaprogramming and type traits  
20.9.2Header <type_traits> synopsis  
20.9.3Helper classesY 
20.9.4Unary Type TraitsY type categoriesY type traitsY propertiesPartialMissing is_trivially_copyable, 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
20.9.5Type property queriesY 
20.9.6Relationships between typesY 
20.9.7Transformations between types modificationsY modificationsY modificationsY modificationsY modificationsY transformationsY 
20.10Compile-time rational arithmetic  
20.10.1In general  
20.10.2Header <ratio> synopsis  
20.10.3Class template ratioY 
20.10.4Arithmetic on ratiosY 
20.10.5Comparison of ratiosY 
20.10.6SI types for ratioY 
20.11Time utilities  
20.11.3Clock requirementsY 
20.11.4Time-related traits of common_typeY 
20.11.5Class template durationPartialMissing constexpr for non-member arithmetic operations
20.11.6Class template time_pointY 
20.11.7Clocks system_clockY steady_clockY high_resolution_clockY 
20.11.8Date and time functionsY 
20.12Scoped allocator adaptorPartial 
20.12.1Header <scoped_allocator> synopsis  
20.12.2Scoped allocator adaptor member typesY 
20.12.3Scoped allocator adaptor constructorsY 
20.12.4Scoped allocator adaptor membersPartialOUTERMOST is not recursive.
20.12.5Scoped allocator operatorsY 
20.13Class type_indexY 
21 Strings
21.2Character traits  
21.2.1Character traits requirementsY 
21.2.2traits typedefsY 
21.2.3char_traits specializations char_traits<char>PartialMissing constexpr char_traits<char16_t>PartialMissing constexpr char_traits<char32_t>Y char_traits<wchar_t>Y 
21.3String classesY 
21.4Class template basic_stringY 
21.5Numeric ConversionsY 
21.6Hash supportY 
21.7Null-terminated sequence utilitiesPartialC library dependency. Missing <cuchar>
22 Localization
22.2Header <locale> synopsisY 
22.3.1Class localeY 
22.3.2locale globalsY 
22.3.3Convenience interfaces classificationY conversionsY conversionsN conversionsN 
22.4Standard locale categories  
22.4.1The ctype categoryPartialMissing codecvt<char16_t> and codecvt<char32_t>
22.4.2The numeric category 
22.4.3The numeric punctuation facetY 
22.4.4The collate categoryY 
22.4.5The time category template time_getY template time_get_bynameY template time_putY template time_put_bynameY 
22.4.6The monetary category template money_getY template money_putY template money_punctY template money_punct_bynameY 
22.4.7The message retrieval categoryY 
22.4.8Program-defined facetsY 
22.5Standard code conversion facetsN 
22.6C Library LocalesY 
23 Containers
23.2Container requirements  
23.2.1General container requirementsPartialOnly vector and forward_list meet the requirements relating to allocator use and propagation.
23.2.2Container data racesY 
23.2.3Sequence containersY 
23.2.4Associative containersY 
23.2.5Unordered associative containersY 
23.3Sequence containers  
23.3.2Class template arrayY 
23.3.3Class template dequePartialinsert and erase members do not take const_iterator arguments (N2350).
23.3.4Class template forward_listY 
23.3.5Class template listPartialinsert and erase members do not take const_iterator arguments (N2350).
23.3.6Class template vectorPartialinsert and erase members do not take const_iterator arguments (N2350).
23.3.7Class vector<bool>Partialinsert and erase members do not take const_iterator arguments (N2350).
23.4Associative containers  
23.4.4Class template mapY 
23.4.5Class template multimapY 
23.4.6Class template setY 
23.4.7Class template multisetY 
23.5Unordered associative containers  
23.5.4Class template unordered_mapY 
23.5.5Class template unordered_multimapY 
23.5.6Class template unordered_setY 
23.5.7Class template unordered_multisetY 
23.6Container adaptors  
23.6.1Class template queueY 
23.6.2Class template priority_queueY 
23.6.3Class template stackY 
24 Iterators
24.2Iterator requirementsY 
24.3Header <iterator> synopsisY 
24.4Iterator primitivesY 
24.5Iterator adaptors  
24.5.1Reverse iteratorsY 
24.5.2Insert iteratorsY 
24.5.3Move iteratorsY 
24.6Stream iterators  
24.6.1Class template istream_iteratorY 
24.6.2Class template ostream_iteratorY 
24.6.3Class template istreambuf_iteratorY 
24.6.4Class template ostreambuf_iteratorY 
24.6.5range accessY 
25 Algorithms
25.2Non-modifying sequence operationsY 
25.3Mutating sequence operationsY 
25.4Sorting and related operationsY 
25.5C library algorithmsY 
26 Numerics
26.2Numeric type requirementsY 
26.3The floating-point environmentY 
26.4Complex numbersPartialMissing constexpr
26.5Random number generation  
26.5.2Header <random> synopsis  
26.5.3Random number engine class templates template linear_congruential_engineYMissing constexpr template mersenne_twister_engineYMissing constexpr template subtract_with_carry_engineYMissing constexpr
26.5.4Random number engine adaptor class templates template discard_block_engineYMissing constexpr template independent_bits_engineYMissing constexpr template shuffle_order_engineYMissing constexpr
26.5.5Engines and engine adaptors with predefined parametersY 
26.5.6Class random_deviceYMissing constexpr
26.5.7Utilities seed_seqY template generate_canonicalY 
26.5.8Random number distribution class templates distributions template uniform_int_distributionY template uniform_real_distributionY distributions bernoulli_distributionY template binomial_distributionY template geometric_distributionY template negative_binomial_distributionY distributions template poisson_distributionY template exponential_distributionY template gamma_distributionY template weibull_distributionY template extreme_value_distributionY distributions template normal_distributionY template lognormal_distributionY template chi_squared_distributionY template cauchy_distributionY template fisher_f_distributionY template student_t_distributionY distributions template discrete_distributionY template piecewise_constant_distributionY template piecewise_linear_distributionY 
26.6Numeric arrays  
26.6.1Header <valarray> synopsisY 
26.6.2Class template valarrayY 
26.6.3valarray non-member operationsY 
26.6.4Class sliceY 
26.6.5Class template slice_arrayY 
26.6.6The gslice classY 
26.6.7Class template gslice_arrayY 
26.6.8Class template mask_arrayY 
26.6.9Class template indirect_arrayY 
26.6.10valarray range accessY 
26.7Generalized numeric operations  
26.7.1Header <numeric> synopsisY 
26.8C LibraryY 
27 Input/output library
27.2Iostreams requirementsY 
27.2.1Imbue LimitationsY 
27.2.2Positioning Type LimitationsY 
27.2.3Thread safetyPartial 
27.3Forward declarationsY 
27.4Standard iostream objectsY 
27.4.2Narrow stream objectsY 
27.4.3Wide stream objectsY 
27.5Iostreams base classesPartial Missing move and swap operations on basic_ios. Missing io_errc and iostream_category. ios_base::failure is not derived from system_error.
27.6Stream buffersY 
27.7Formatting and manipulatorsPartial Missing move and swap operations Missing get_time and put_time manipulators.
27.8String-based streamsPartialMissing move and swap operations
27.9File-based streamsPartialMissing move and swap operations
28 Regular expressions
28.4Header <regex> synopsisN 
28.5Namespace std::regex_constantsY 
28.6Class regex_errorY 
28.7Class template regex_traitsPartial 
28.8Class template basic_regexPartial 
28.9Class template sub_matchPartial 
28.10Class template match_resultsPartial 
28.11Regular expression algorithmsN 
28.12Regular expression IteratorsN 
28.13Modified ECMAScript regular expression grammarN 
29 Atomic operations
29.2Header <atomic> synopsisY 
29.3Order and consistencyPartial 
29.4Lock-free propertyY 
29.5Atomic typesY 
29.6Operations on atomic typesY 
29.7Flag Type and operationsY 
30 Thread support
30.3.1Class threadPartialthread::id comparisons not well-defined
30.3.2Namespace this_threadY 
30.4Mutual exclusion  
30.4.1Mutex requirements general types mutexY recursive_mutexY mutex types On POSIX sytems these types are only defined if the OS supports the POSIX Timeouts option. timed_mutexY recursive_timed_mutexY 
30.4.2Locks template lock_guardY template unique_lockY 
30.4.3Generic locking algorithmsY 
30.4.4Call once once_flagY call_onceY 
30.5Condition variablesPartialMissing notify_all_at_thread_exit
30.5.1Class condition_variableY 
30.5.2Class condition_variable_anyY 
30.6.2Error handlingY 
30.6.3Class future_errorY 
30.6.4Shared stateY 
30.6.5Class template promisePartialMissing set_*_at_thread_exit
30.6.6Class template futurePartialTimed waiting functions do not return future_status::deferred
30.6.7Class template shared_futurePartialTimed waiting functions do not return future_status::deferred
30.6.8Function template asyncY 
30.6.9Class template packaged_taskPartialMissing make_ready_at_thread_exit
Appendix D Compatibility features
D.1Increment operator with bool operand  
D.2register keyword  
D.3Implicit declaration of copy functions  
D.4Dynamic exception specifications  
D.5C standard library headers  
D.6Old iostreams members  
D.7char* streams  
D.8Function objects  
D.11Violating exception-specificationsPartialMissing get_unexpected. set_unexpected is not thread-safe.

Implementation Specific Behavior

For behaviour which is also specified by the 1998 and 2003 standards, see C++ 1998/2003 Implementation Specific Behavior. This section only documents behaviour which is new in the 2011 standard. []/1 There are 29 placeholders defined and the placeholder types are CopyAssignable. [], [unord.multimap.cnstr], [unord.set.cnstr], [unord.multiset.cnstr] The default bucket count is 10 for the default constructors and 0 for the range constructors and initializer-list constructors.

30.2.3 [thread.req.native]/1 native_handle_type and native_handle are provided. The handle types are defined in terms of the Gthreads abstraction layer.

  • thread: The native handle type is a typedef for __gthread_t i.e. pthread_t when GCC is configured with the posix thread model. The value of the native handle is undefined for a thread which is not joinable.

  • mutex and timed_mutex: The native handle type is __gthread_mutex_t* i.e. pthread_mutex_t* for the posix thread model.

  • recursive_mutex and recursive_timed_mutex: The native handle type is __gthread_recursive_mutex_t* i.e. pthread_mutex_t* for the posix thread model.

  • condition_variable: The native handle type is __gthread_cond_t* i.e. pthread_cond_t* for the posix thread model.

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

C++ 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

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

Uses code from boost::shared_ptr. constructorsY destructorY assignmentY modifiersY observersY comparisonY I/OY specialized algorithmsY castsY 
2.2.4Class template weak_ptr constructorsY destructorY assignmentY modifiersY observersY comparisonY specialized algorithmsY 
2.2.5Class template enable_shared_from_thisY 
3Function Objects
3.2Additions to <functional> synopsisY 
3.4Function return typesY 
3.5Function template mem_fnY 
3.6Function object binders  
3.6.1Class template is_bind_expressionY 
3.6.2Class template is_placeholderY 
3.6.3Function template bindY 
3.7Polymorphic function wrappers  
3.7.1Class bad_function_callY constructorY 
3.7.2Class template function construct/copy/destroyY modifiersY capacityY invocationY target accessY operatorsY pointer comparison operatorsY algorithmsY 
4Metaprogramming and type traits
4.2Header <type_traits> synopsisY 
4.3Helper classesY 
4.4General RequirementsY 
4.5Unary Type Traits  
4.5.1Primary Type CategoriesY 
4.5.2Composite type traitsY 
4.5.3Type propertiesY 
4.6Relationships between typesY 
4.7Transformations between types  
4.7.1Const-volatile modificationsY 
4.7.2Reference modificationsY 
4.7.3Array modificationsY 
4.7.4Pointer modificationsY 
4.8Other transformationsY 
4.9Implementation requirementsY 
5Numerical Facilities
5.1Random number generation  
5.1.2Header <random> synopsisY 
5.1.3Class template variate_generatorY 
5.1.4Random number engine class templatesY template linear_congruentialY template mersenne_twisterY template subtract_with_carryY template subtract_with_carry_01Y template discard_blockY template xor_combineYoperator()() per N2079
5.1.5Engines with predefined parametersY 
5.1.6Class random_deviceY 
5.1.7Random distribution class templatesY template uniform_intY bernoulli_distributionY template geometric_distributionY template poisson_distributionY template binomial_distributionY template uniform_realY template exponential_distributionY template normal_distributionY template gamma_distributionY 
5.2Mathematical special functionsY 
5.2.1Additions to header <cmath> synopsisY Laguerre polynomialsY Legendre functionsY functionY elliptic integral of the first kindY elliptic integral of the second kindY elliptic integral of the third kindY hypergeometric functionsY modified cylindrical Bessel functionsY Bessel functions (of the first kind)Y modified cylindrical Bessel functionsY Neumann functionsY elliptic integral of the first kindY elliptic integral of the second kindY elliptic integral of the third kindY integralY polynomialsY functionsY polynomialsY polynomialsY zeta functionY Bessel functions (of the first kind)Y associated Legendre functionsY Neumann functionsY 
5.2.2Additions to header <math.h> synopsisY 
6.1Tuple typesY 
6.1.1Header <tuple> synopsisY 
6.1.2Additions to header <utility> synopsisY 
6.1.3Class template tupleY creation functionsY helper classesY accessY operatorsY 
6.2Fixed size arrayY 
6.2.1Header <array> synopsisY 
6.2.2Class template arrayY constructors, copy, and assignmentY specialized algorithmsY sizeY sized arraysY interface to class template arrayY 
6.3Unordered associative containersY 
6.3.1Unordered associative container requirementsY safety guaranteesY 
6.3.2Additions to header <functional> synopsisY 
6.3.3Class template hashY 
6.3.4Unordered associative container classesY <unordered_set> synopsisY <unordered_map> synopsisY template unordered_setY constructorsY swapY template unordered_mapY constructorsY element accessY swapY template unordered_multisetY constructorsY swapY template unordered_multimapY constructorsY swapY 
7Regular Expressions
7.3Regular expressions summaryN 
7.4Header <regex> synopsisN 
7.5Namespace tr1::regex_constantsN 
7.5.1Bitmask Type syntax_option_typeN 
7.5.2Bitmask Type regex_constants::match_flag_typeN 
7.5.3Implementation defined error_typeN 
7.6Class regex_errorN 
7.7Class template regex_traitsN 
7.8Class template basic_regexN 
7.8.1basic_regex constantsN 
7.8.2basic_regex constructorsN 
7.8.3basic_regex assignN 
7.8.4basic_regex constant operationsN 
7.8.5basic_regex localeN 
7.8.6basic_regex swapN 
7.8.7basic_regex non-member functionsN non-member swapN 
7.9Class template sub_matchN 
7.9.1sub_match membersN 
7.9.2sub_match non-member operatorsN 
7.10Class template match_resultsN 
7.10.1match_results constructorsN 
7.10.2match_results sizeN 
7.10.3match_results element accessN 
7.10.4match_results formattingN 
7.10.5match_results allocatorN 
7.10.6match_results swapN 
7.11Regular expression algorithmsN 
7.12Regular expression IteratorsN 
7.12.1Class template regex_iteratorN constructorsN comparisonsN dereferenceN incrementN 
7.12.2Class template regex_token_iteratorN constructorsN comparisonsN dereferenceN incrementN 
7.13Modified ECMAScript regular expression grammarN 
8C Compatibility
8.1Additions to header <complex>Y 
8.1.2Function acosY 
8.1.3Function asinY 
8.1.4Function atanY 
8.1.5Function acoshY 
8.1.6Function asinhY 
8.1.7Function atanhY 
8.1.8Function fabsY 
8.1.9Additional OverloadsY 
8.2Header <ccomplex>NDR 551
8.3Header <complex.h>NDR 551
8.4Additions to header <cctype>Y 
8.4.2Function isblankY 
8.5Additions to header <ctype.h>Y 
8.6Header <cfenv>Y 
8.7Header <fenv.h>Y 
8.8Additions to header <cfloat>Y 
8.9Additions to header <float.h>Y 
8.10Additions to header <ios>N 
8.10.2Function hexfloatN 
8.11Header <cinttypes>Y 
8.11.1SynopsisYDR 557
8.12Header <inttypes.h>Y 
8.13Additions to header <climits>Y 
8.14Additions to header <limits.h>Y 
8.15Additions to header <locale>N 
8.16Additions to header <cmath>Y 
8.16.3Function template definitionsY 
8.16.4Additional overloadsYDR 568; DR 550
8.17Additions to header <math.h>Y 
8.18Additions to header <cstdarg>Y 
8.19Additions to header <stdarg.h>Y 
8.20The header <cstdbool>Y 
8.21The header <stdbool.h>Y 
8.22The header <cstdint>Y 
8.23The header <stdint.h>Y 
8.24Additions to header <cstdio>Y 
8.24.3Additional format specifiersYC library dependency
8.24.4Additions to header <stdio.h>Y 
8.25Additions to header <cstdlib>Y 
8.25.3Function absY 
8.25.4Function divY 
8.26Additions to header <stdlib.h>Y 
8.27Header <ctgmath>YDR 551
8.28Header <tgmath.h>YDR 551
8.29Additions to header <ctime>YC library dependency
8.30Additions to header <cwchar>Y 
8.30.3Additional wide format specifiersYC library dependency
8.31Additions to header <wchar.h>Y 
8.32Additions to header <cwctype>Y 
8.32.2Function iswblankY 
8.33Additions to header <wctype.h>Y 

Implementation Specific Behavior

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

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

C++ TR 24733

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

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

Table 1.4. C++ TR 24733 Implementation Status

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