diff --git a/libstdc++-v3/doc/html/faq.html b/libstdc++-v3/doc/html/faq.html index 6be4f5d37ea..439eb3a09b1 100644 --- a/libstdc++-v3/doc/html/faq.html +++ b/libstdc++-v3/doc/html/faq.html @@ -4,7 +4,7 @@ 2008, 2010 FSF -

Allocator (3.4)	Header (3.4)	Allocator (3.[0-3])	Header (3.[0-3])
`__gnu_cxx::new_allocator<T>`	`ext/new_allocator.h`	`std::__new_alloc`	`memory`
`__gnu_cxx::malloc_allocator<T>`	`ext/malloc_allocator.h`	`std::__malloc_alloc_template<int>`	`memory`
`__gnu_cxx::debug_allocator<T>`	`ext/debug_allocator.h`	`std::debug_alloc<T>`	`memory`
`__gnu_cxx::__pool_alloc<T>`	`ext/pool_allocator.h`	`std::__default_alloc_template<bool,int>`	`memory`
`__gnu_cxx::__mt_alloc<T>`	`ext/mt_allocator.h`
`__gnu_cxx::bitmap_allocator<T>`	`ext/bitmap_allocator.h`

Allocator (3.4)	Header (3.4)	Allocator (3.[0-3])	Header (3.[0-3])
`__gnu_cxx::new_allocator<T>`	`ext/new_allocator.h`	`std::__new_alloc`	`memory`
`__gnu_cxx::malloc_allocator<T>`	`ext/malloc_allocator.h`	`std::__malloc_alloc_template<int>`	`memory`
`__gnu_cxx::debug_allocator<T>`	`ext/debug_allocator.h`	`std::debug_alloc<T>`	`memory`
`__gnu_cxx::__pool_alloc<T>`	`ext/pool_allocator.h`	`std::__default_alloc_template<bool,int>`	`memory`
`__gnu_cxx::__mt_alloc<T>`	`ext/mt_allocator.h`
`__gnu_cxx::bitmap_allocator<T>`	`ext/bitmap_allocator.h`

Allocator	Include	Version
`__gnu_cxx::array_allocator<T>`	`ext/array_allocator.h`	4.0.0
`__gnu_cxx::throw_allocator<T>`	`ext/throw_allocator.h`	4.2.0

Allocator	Include	Version
`__gnu_cxx::array_allocator<T>`	`ext/array_allocator.h`	4.0.0
`__gnu_cxx::throw_allocator<T>`	`ext/throw_allocator.h`	4.2.0

3.0
3.1
3.2
3.3
3.4
4.0
4.1
4.2
4.3
4.4
4.5

First

No ios_base
No cout in ostream.h, no cin in istream.h

Second

Namespace std:: not supported
Illegal iterator usage
isspace from cctype is a macro -
No vector::at, deque::at, string::at
No std::char_traits<char>::eof
No string::clear
+C++11 Requirements Test Sequence Descriptions +

ABI Policy and Guidelines

The C++ Interface

Versioning

Goals
History
Prerequisites
Configuring
Checking Active

Allowed Changes

Prohibited Changes

Implementation

Testing

Single ABI Testing
Multiple ABI Testing

Outstanding Issues

API Evolution and Deprecation History

3.0
3.1
3.2
3.3
3.4
4.0
4.1
4.2
4.3
4.4
4.5

Backwards Compatibility

First

No ios_base
No cout in ostream.h, no cin in istream.h

Second

Namespace std:: not supported
Illegal iterator usage
isspace from cctype is a macro +
No vector::at, deque::at, string::at
No std::char_traits<char>::eof
No string::clear
Removal of ostream::form and istream::scan extensions -
No basic_stringbuf, basic_stringstream
Little or no wide character support
No templatized iostreams
Thread safety issues

Third

Pre-ISO headers moved to backwards or removed
Extension headers hash_map, hash_set moved to ext or backwards
No ios::nocreate/ios::noreplace. -
+
No basic_stringbuf, basic_stringstream
Little or no wide character support
No templatized iostreams
Thread safety issues

Third

Pre-ISO headers moved to backwards or removed
Extension headers hash_map, hash_set moved to ext or backwards
No ios::nocreate/ios::noreplace. +
No stream::attach(int fd) -
+
Support for C++98 dialect. -
+
Support for C++TR1 dialect. -
-Support for C++0x dialect. -
+
+Support for C++11 dialect. +
Container::iterator_type is not necessarily Container::value_type*

Configure and Build Hacking

Prerequisites

As noted previously, @@ -41,7 +41,7 @@ Support for C++0x dialect. in GCC try to stay in sync with each other in terms of versions of the auto-tools used, so please try to play nicely with the neighbors. -

Overview: What Comes from Where

FigureÂ B.1.Â Configure and Build File Dependencies

Overview: What Comes from Where

FigureÂ B.1.Â Configure and Build File Dependencies

Regenerate all generated files by using the command sequence "autoreconf" at the top level of the libstdc++ source directory. The following will also work, but is much more complex: diff --git a/libstdc++-v3/doc/html/manual/atomics.html b/libstdc++-v3/doc/html/manual/atomics.html index 0038be3b6ef..d7216eba403 100644 --- a/libstdc++-v3/doc/html/manual/atomics.html +++ b/libstdc++-v3/doc/html/manual/atomics.html @@ -7,7 +7,7 @@ Standard Contents Â Next

ChapterÂ 14.Â Atomics - +

Table of Contents

API Reference

Facilities for atomic operations.

API Reference

diff --git a/libstdc++-v3/doc/html/manual/backwards.html b/libstdc++-v3/doc/html/manual/backwards.html index ab90f3bf84a..fef479d6b33 100644 --- a/libstdc++-v3/doc/html/manual/backwards.html +++ b/libstdc++-v3/doc/html/manual/backwards.html @@ -17,8 +17,8 @@ ISO Standard (e.g., statistical analysis). While there are a lot of really useful things that are used by a lot of people, the Standards Committee couldn't include everything, and so a lot of those âobviousâ classes didn't get included. -

Known Issues include many of the limitations of its immediate ancestor.

Portability notes and known implementation limitations are as follows.

`isspace` from `cctype` is a macro +

`isspace` from `cctype` is a macro

Glibc 2.0.x and 2.1.x define ctype.h functionality as macros (isspace, isalpha etc.). @@ -154,7 +154,7 @@ std:: (__ctype_b[(int) ( ( 'X' ) )] & (unsigned short int) _ISspace ) ; (ctype.h) and the definitions in namespace std:: (<cctype>). -

No `vector::at`, `deque::at`, `string::at`

One solution is to add an autoconf-test for this:

 AC_MSG_CHECKING(for container::at)
@@ -180,7 +180,7 @@ AC_DEFINE(HAVE_CONTAINER_AT)],

If you are using other (non-GNU) compilers it might be a good idea to check for string::at separately. -

No `std::char_traits<char>::eof`

Use some kind of autoconf test, plus this:

 #ifdef HAVE_CHAR_TRAITS
@@ -188,7 +188,7 @@ AC_DEFINE(HAVE_CONTAINER_AT)],
 #else
 #define CPP_EOF EOF
 #endif
-

No `string::clear`

There are two functions for deleting the contents of a string: clear and erase (the latter returns the string). @@ -206,12 +206,12 @@ erase(size_type __pos = 0, size_type __n = npos) Unfortunately, clear is not implemented in this version, so you should use erase (which is probably faster than operator=(charT*)). -

+

Removal of `ostream::form` and `istream::scan` extensions

These are no longer supported. Please use stringstreams instead. -

No `basic_stringbuf`, `basic_stringstream`

Although the ISO standard i/ostringstream-classes are provided, (sstream), for compatibility with older implementations the pre-ISO @@ -299,14 +299,14 @@ any = temp; Another example of using stringstreams is in this howto.

There is additional information in the libstdc++-v2 info files, in particular âinfo iostreamâ. -

Little or no wide character support

Classes wstring and char_traits<wchar_t> are not supported. -

No templatized iostreams

Classes wfilebuf and wstringstream are not supported. -

Thread safety issues

Earlier GCC releases had a somewhat different approach to threading configuration and proper compilation. Before GCC 3.0, configuration of the threading model was dictated by compiler @@ -364,7 +364,7 @@ libstdc++-v3. of the SGI STL (version 3.3), with extensive changes.

A more formal description of the V3 goals can be found in the official design document. -

Portability notes and known implementation limitations are as follows.

Pre-ISO headers moved to backwards or removed

The pre-ISO C++ headers +

Portability notes and known implementation limitations are as follows.

Pre-ISO headers moved to backwards or removed

The pre-ISO C++ headers (iostream.h, defalloc.h etc.) are available, unlike previous libstdc++ versions, but inclusion generates a warning that you are using deprecated headers. @@ -436,15 +436,17 @@ like vector.h can be replaced with using namespace std; can be put at the global scope. This should be enough to get this code compiling, assuming the other usage is correct. -

Extension headers hash_map, hash_set moved to ext or backwards

At this time most of the features of the SGI STL extension have been +

Extension headers hash_map, hash_set moved to ext or backwards

At this time most of the features of the SGI STL extension have been replaced by standardized libraries. - In particular, the unordered_map and unordered_set containers of TR1 - are suitable replacement for the non-standard hash_map and hash_set + In particular, the unordered_map and + unordered_set containers of TR1 and C++ 2011 + are suitable replacements for the non-standard + hash_map and hash_set containers in the SGI STL.

Header files hash_map and hash_set moved to ext/hash_map and ext/hash_set, respectively. At the same time, all types in these files are enclosed -in namespace __gnu_cxx. Later versions move deprecate +in namespace __gnu_cxx. Later versions deprecate these files, and suggest using TR1's unordered_map and unordered_set instead.

The extensions are no longer in the global or std @@ -508,7 +510,7 @@ AC_DEFUN([AC_HEADER_EXT_HASH_SET], [ AC_DEFINE(HAVE_EXT_HASH_SET,,[Define if ext/hash_set is present. ]) fi ]) -

No `ios::nocreate/ios::noreplace`. +

No `ios::nocreate/ios::noreplace`.

The existence of ios::nocreate being used for input-streams has been confirmed, most probably because the author thought it would be more correct to specify nocreate explicitly. So @@ -519,7 +521,7 @@ open the file for reading, check if it has been opened, and then decide whether you want to create/replace or not. To my knowledge, even older implementations support app, ate and trunc (except for app ?). -

+

No `stream::attach(int fd)`

Phil Edwards writes: It was considered and rejected for the ISO @@ -542,7 +544,7 @@ No stream::attach(int fd) For another example of this, refer to fdstream example by Nicolai Josuttis. -

+

Support for C++98 dialect.

Check for complete library coverage of the C++1998/2003 standard.

@@ -610,7 +612,7 @@ AC_DEFUN([AC_HEADER_STDCXX_98], [
     AC_DEFINE(STDCXX_98_HEADERS,,[Define if ISO C++ 1998 header files are present. ])
   fi
 ])
-

+

Support for C++TR1 dialect.

Check for library coverage of the TR1 standard.

@@ -687,14 +689,14 @@ AC_DEFUN([AC_HEADER_TR1_UNORDERED_SET], [
     AC_DEFINE(HAVE_TR1_UNORDERED_SET,,[Define if tr1/unordered_set is present. ])
   fi
 ])
-

-Support for C++0x dialect. -

Check for baseline language coverage in the compiler for the C++0xstandard. +

+Support for C++11 dialect. +

Check for baseline language coverage in the compiler for the C++11 standard.

-# AC_COMPILE_STDCXX_OX
-AC_DEFUN([AC_COMPILE_STDCXX_0X], [
-  AC_CACHE_CHECK(if g++ supports C++0x features without additional flags,
-  ac_cv_cxx_compile_cxx0x_native,
+# AC_COMPILE_STDCXX_11
+AC_DEFUN([AC_COMPILE_STDCXX_11], [
+  AC_CACHE_CHECK(if g++ supports C++11 features without additional flags,
+  ac_cv_cxx_compile_cxx11_native,
   [AC_LANG_SAVE
   AC_LANG_CPLUSPLUS
   AC_TRY_COMPILE([
@@ -712,16 +714,16 @@ AC_DEFUN([AC_COMPILE_STDCXX_0X], [
     typedef check<int> check_type;
     check_type c;
     check_type&& cr = c;],,
-  ac_cv_cxx_compile_cxx0x_native=yes, ac_cv_cxx_compile_cxx0x_native=no)
+  ac_cv_cxx_compile_cxx11_native=yes, ac_cv_cxx_compile_cxx11_native=no)
   AC_LANG_RESTORE
   ])
 
-  AC_CACHE_CHECK(if g++ supports C++0x features with -std=c++0x,
-  ac_cv_cxx_compile_cxx0x_cxx,
+  AC_CACHE_CHECK(if g++ supports C++11 features with -std=c++11,
+  ac_cv_cxx_compile_cxx11_cxx,
   [AC_LANG_SAVE
   AC_LANG_CPLUSPLUS
   ac_save_CXXFLAGS="$CXXFLAGS"
-  CXXFLAGS="$CXXFLAGS -std=c++0x"
+  CXXFLAGS="$CXXFLAGS -std=c++11"
   AC_TRY_COMPILE([
   template <typename T>
     struct check
@@ -737,17 +739,17 @@ AC_DEFUN([AC_COMPILE_STDCXX_0X], [
     typedef check<int> check_type;
     check_type c;
     check_type&& cr = c;],,
-  ac_cv_cxx_compile_cxx0x_cxx=yes, ac_cv_cxx_compile_cxx0x_cxx=no)
+  ac_cv_cxx_compile_cxx11_cxx=yes, ac_cv_cxx_compile_cxx11_cxx=no)
   CXXFLAGS="$ac_save_CXXFLAGS"
   AC_LANG_RESTORE
   ])
 
-  AC_CACHE_CHECK(if g++ supports C++0x features with -std=gnu++0x,
-  ac_cv_cxx_compile_cxx0x_gxx,
+  AC_CACHE_CHECK(if g++ supports C++11 features with -std=gnu++11,
+  ac_cv_cxx_compile_cxx11_gxx,
   [AC_LANG_SAVE
   AC_LANG_CPLUSPLUS
   ac_save_CXXFLAGS="$CXXFLAGS"
-  CXXFLAGS="$CXXFLAGS -std=gnu++0x"
+  CXXFLAGS="$CXXFLAGS -std=gnu++11"
   AC_TRY_COMPILE([
   template <typename T>
     struct check
@@ -763,28 +765,28 @@ AC_DEFUN([AC_COMPILE_STDCXX_0X], [
     typedef check<int> check_type;
     check_type c;
     check_type&& cr = c;],,
-  ac_cv_cxx_compile_cxx0x_gxx=yes, ac_cv_cxx_compile_cxx0x_gxx=no)
+  ac_cv_cxx_compile_cxx11_gxx=yes, ac_cv_cxx_compile_cxx11_gxx=no)
   CXXFLAGS="$ac_save_CXXFLAGS"
   AC_LANG_RESTORE
   ])
 
-  if test "$ac_cv_cxx_compile_cxx0x_native" = yes ||
-     test "$ac_cv_cxx_compile_cxx0x_cxx" = yes ||
-     test "$ac_cv_cxx_compile_cxx0x_gxx" = yes; then
-    AC_DEFINE(HAVE_STDCXX_0X,,[Define if g++ supports C++0x features. ])
+  if test "$ac_cv_cxx_compile_cxx11_native" = yes ||
+     test "$ac_cv_cxx_compile_cxx11_cxx" = yes ||
+     test "$ac_cv_cxx_compile_cxx11_gxx" = yes; then
+    AC_DEFINE(HAVE_STDCXX_11,,[Define if g++ supports C++11 features. ])
   fi
 ])
-

Check for library coverage of the C++0xstandard. +

Check for library coverage of the C++2011 standard.

-# AC_HEADER_STDCXX_0X
-AC_DEFUN([AC_HEADER_STDCXX_0X], [
-  AC_CACHE_CHECK(for ISO C++ 0x include files,
-  ac_cv_cxx_stdcxx_0x,
-  [AC_REQUIRE([AC_COMPILE_STDCXX_0X])
+# AC_HEADER_STDCXX_11
+AC_DEFUN([AC_HEADER_STDCXX_11], [
+  AC_CACHE_CHECK(for ISO C++11 include files,
+  ac_cv_cxx_stdcxx_11,
+  [AC_REQUIRE([AC_COMPILE_STDCXX_11])
   AC_LANG_SAVE
   AC_LANG_CPLUSPLUS
   ac_save_CXXFLAGS="$CXXFLAGS"
-  CXXFLAGS="$CXXFLAGS -std=gnu++0x"
+  CXXFLAGS="$CXXFLAGS -std=gnu++11"
 
   AC_TRY_COMPILE([
     #include <cassert>
@@ -852,12 +854,12 @@ AC_DEFUN([AC_HEADER_STDCXX_0X], [
     #include <valarray>
     #include <vector>
   ],,
-  ac_cv_cxx_stdcxx_0x=yes, ac_cv_cxx_stdcxx_0x=no)
+  ac_cv_cxx_stdcxx_11=yes, ac_cv_cxx_stdcxx_11=no)
   AC_LANG_RESTORE
   CXXFLAGS="$ac_save_CXXFLAGS"
   ])
-  if test "$ac_cv_cxx_stdcxx_0x" = yes; then
-    AC_DEFINE(STDCXX_0X_HEADERS,,[Define if ISO C++ 0x header files are present. ])
+  if test "$ac_cv_cxx_stdcxx_11" = yes; then
+    AC_DEFINE(STDCXX_11_HEADERS,,[Define if ISO C++11 header files are present. ])
   fi
 ])

As is the case for TR1 support, these autoconf macros can be made for a finer-grained, per-header-file check. For <unordered_map> @@ -866,11 +868,11 @@ AC_DEFUN([AC_HEADER_STDCXX_0X], [ AC_DEFUN([AC_HEADER_UNORDERED_MAP], [ AC_CACHE_CHECK(for unordered_map, ac_cv_cxx_unordered_map, - [AC_REQUIRE([AC_COMPILE_STDCXX_0X]) + [AC_REQUIRE([AC_COMPILE_STDCXX_11]) AC_LANG_SAVE AC_LANG_CPLUSPLUS ac_save_CXXFLAGS="$CXXFLAGS" - CXXFLAGS="$CXXFLAGS -std=gnu++0x" + CXXFLAGS="$CXXFLAGS -std=gnu++11" AC_TRY_COMPILE([#include <unordered_map>], [using std::unordered_map;], ac_cv_cxx_unordered_map=yes, ac_cv_cxx_unordered_map=no) CXXFLAGS="$ac_save_CXXFLAGS" @@ -885,11 +887,11 @@ AC_DEFUN([AC_HEADER_UNORDERED_MAP], [ AC_DEFUN([AC_HEADER_UNORDERED_SET], [ AC_CACHE_CHECK(for unordered_set, ac_cv_cxx_unordered_set, - [AC_REQUIRE([AC_COMPILE_STDCXX_0X]) + [AC_REQUIRE([AC_COMPILE_STDCXX_11]) AC_LANG_SAVE AC_LANG_CPLUSPLUS ac_save_CXXFLAGS="$CXXFLAGS" - CXXFLAGS="$CXXFLAGS -std=gnu++0x" + CXXFLAGS="$CXXFLAGS -std=gnu++11" AC_TRY_COMPILE([#include <unordered_set>], [using std::unordered_set;], ac_cv_cxx_unordered_set=yes, ac_cv_cxx_unordered_set=no) CXXFLAGS="$ac_save_CXXFLAGS" @@ -899,21 +901,29 @@ AC_DEFUN([AC_HEADER_UNORDERED_SET], [ AC_DEFINE(HAVE_UNORDERED_SET,,[Define if unordered_set is present. ]) fi ]) -

+
+ Some C++11 features first appeared in GCC 4.3 and could be enabled by + `-std=c++0x` and `-std=gnu++0x` for GCC + releases which pre-date the 2011 standard. Those C++11 features and GCC's + support for them were still changing until the 2011 standard was finished, + but the autoconf checks above could be extended to test for incomplete + C++11 support with `-std=c++0x` and + `-std=gnu++0x`. +

Container::iterator_type is not necessarily Container::value_type*

- This is a change in behavior from the previous version. Now, most + This is a change in behavior from older versions. Now, most iterator_type typedefs in container classes are POD objects, not value_type pointers. -

Bibliography

Migrating to GCC 4.1 - . Dan Kegel.

+ . Dan Kegel.

Building the Whole Debian Archive with GCC 4.1: A Summary - . Martin Michlmayr.

+ . Martin Michlmayr.

Migration guide for GCC-3.2 diff --git a/libstdc++-v3/doc/html/manual/bk01pt02.html b/libstdc++-v3/doc/html/manual/bk01pt02.html index 05ae37aed78..5a56534768a 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt02.html +++ b/libstdc++-v3/doc/html/manual/bk01pt02.html @@ -13,13 +13,13 @@
Exceptions
API Reference
Adding Data to exception
Concept Checking
6. Utilities -
Functors
Pairs
Memory
Allocators
Requirements
Design Issues
Implementation
Interface Design
Selecting Default Allocation Policy
Disabling Memory Caching
Using a Specific Allocator
Custom Allocators
Extension Allocators
auto_ptr
Limitations
Use in Containers
shared_ptr
Requirements
Design Issues
Implementation
Class Hierarchy
Thread Safety
Selecting Lock Policy
Dual C++0x and TR1 Implementation
Related functions and classes
Use
Examples
Unresolved Issues
Acknowledgments
Traits
7. +
Functors
Pairs
Memory
Allocators
Requirements
Design Issues
Implementation
Interface Design
Selecting Default Allocation Policy
Disabling Memory Caching
Using a Specific Allocator
Custom Allocators
Extension Allocators
auto_ptr
Limitations
Use in Containers
shared_ptr
Requirements
Design Issues
Implementation
Class Hierarchy
Thread Safety
Selecting Lock Policy
Dual C++11 and TR1 Implementation
Related functions and classes
Use
Examples
Unresolved Issues
Acknowledgments
Traits
7. Strings
String Classes
Simple Transformations
Case Sensitivity
Arbitrary Character Types
Tokenizing
Shrink to Fit
CString (MFC)
8. Localization -
Locales
locale
Requirements
Design
Implementation
Interacting with "C" locales
Future
Facets
ctype
Implementation
Specializations
Future
codecvt
Requirements
Design
wchar_t Size
Support for Unicode
Other Issues
Implementation
Use
Future
messages
Requirements
Design
Implementation
Models
The GNU Model
Use
Future
9. +
Locales
locale
Requirements
Design
Implementation
Interacting with "C" locales
Future
Facets
ctype
Implementation
Specializations
Future
codecvt
Requirements
Design
wchar_t Size
Support for Unicode
Other Issues
Implementation
Use
Future
messages
Requirements
Design
Implementation
Models
The GNU Model
Use
Future
9. Containers
Sequences
list
list::size() is O(n)
vector
Space Overhead Management
Associative
Insertion Hints
bitset
Size Variable
Type String
Interacting with C
Containers vs. Arrays
10. diff --git a/libstdc++-v3/doc/html/manual/bk01pt02ch05s02.html b/libstdc++-v3/doc/html/manual/bk01pt02ch05s02.html index 74c468d8800..e12ca2f310c 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt02ch05s02.html +++ b/libstdc++-v3/doc/html/manual/bk01pt02ch05s02.html @@ -36,7 +36,7 @@ -D_GLIBCXX_CONCEPT_CHECKS.
Please note that the checks are based on the requirements in the original - C++ standard, some of which have changed in the upcoming C++0x revision. + C++ standard, some of which have changed in the new C++11 revision. Additionally, some correct code might be rejected by the concept checks, for example template argument types may need to be complete when used in a template definition, rather than at the point of instantiation. diff --git a/libstdc++-v3/doc/html/manual/bk01pt03ch17s03.html b/libstdc++-v3/doc/html/manual/bk01pt03ch17s03.html index 79161360ff5..e343a514c9d 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt03ch17s03.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch17s03.html @@ -19,6 +19,6 @@ mode or with debug mode. The following table provides the names and headers of the debugging containers: -
TableÂ 17.1.Â Debugging Containers
Container Header Debug container Debug header
std::bitset bitset __gnu_debug::bitset <debug/bitset>
std::deque deque __gnu_debug::deque <debug/deque>
std::list list __gnu_debug::list <debug/list>
std::map map __gnu_debug::map <debug/map>
std::multimap map __gnu_debug::multimap <debug/map>
std::multiset set __gnu_debug::multiset <debug/set>
std::set set __gnu_debug::set <debug/set>
std::string string __gnu_debug::string <debug/string>
std::wstring string __gnu_debug::wstring <debug/string>
std::basic_string string __gnu_debug::basic_string <debug/string>
std::vector vector __gnu_debug::vector <debug/vector>

In addition, when compiling in C++0x mode, these additional +
TableÂ 17.1.Â Debugging Containers
Container Header Debug container Debug header
std::bitset bitset __gnu_debug::bitset <debug/bitset>
std::deque deque __gnu_debug::deque <debug/deque>
std::list list __gnu_debug::list <debug/list>
std::map map __gnu_debug::map <debug/map>
std::multimap map __gnu_debug::multimap <debug/map>
std::multiset set __gnu_debug::multiset <debug/set>
std::set set __gnu_debug::set <debug/set>
std::string string __gnu_debug::string <debug/string>
std::wstring string __gnu_debug::wstring <debug/string>
std::basic_string string __gnu_debug::basic_string <debug/string>
std::vector vector __gnu_debug::vector <debug/vector>

In addition, when compiling in C++11 mode, these additional containers have additional debug capability. -
TableÂ 17.2.Â Debugging Containers C++0x
Container Header Debug container Debug header
std::unordered_map unordered_map __gnu_debug::unordered_map <debug/unordered_map>
std::unordered_multimap unordered_map __gnu_debug::unordered_multimap <debug/unordered_map>
std::unordered_set unordered_set __gnu_debug::unordered_set <debug/unordered_set>
std::unordered_multiset unordered_set __gnu_debug::unordered_multiset <debug/unordered_set>

Container	Header	Debug container	Debug header
`std::bitset`	`bitset`	`__gnu_debug::bitset`	`<debug/bitset>`
`std::deque`	`deque`	`__gnu_debug::deque`	`<debug/deque>`
`std::list`	`list`	`__gnu_debug::list`	`<debug/list>`
`std::map`	`map`	`__gnu_debug::map`	`<debug/map>`
`std::multimap`	`map`	`__gnu_debug::multimap`	`<debug/map>`
`std::multiset`	`set`	`__gnu_debug::multiset`	`<debug/set>`
`std::set`	`set`	`__gnu_debug::set`	`<debug/set>`
`std::string`	`string`	`__gnu_debug::string`	`<debug/string>`
`std::wstring`	`string`	`__gnu_debug::wstring`	`<debug/string>`
`std::basic_string`	`string`	`__gnu_debug::basic_string`	`<debug/string>`
`std::vector`	`vector`	`__gnu_debug::vector`	`<debug/vector>`

Container	Header	Debug container	Debug header
`std::bitset`	`bitset`	`__gnu_debug::bitset`	`<debug/bitset>`
`std::deque`	`deque`	`__gnu_debug::deque`	`<debug/deque>`
`std::list`	`list`	`__gnu_debug::list`	`<debug/list>`
`std::map`	`map`	`__gnu_debug::map`	`<debug/map>`
`std::multimap`	`map`	`__gnu_debug::multimap`	`<debug/map>`
`std::multiset`	`set`	`__gnu_debug::multiset`	`<debug/set>`
`std::set`	`set`	`__gnu_debug::set`	`<debug/set>`
`std::string`	`string`	`__gnu_debug::string`	`<debug/string>`
`std::wstring`	`string`	`__gnu_debug::wstring`	`<debug/string>`
`std::basic_string`	`string`	`__gnu_debug::basic_string`	`<debug/string>`
`std::vector`	`vector`	`__gnu_debug::vector`	`<debug/vector>`

Container	Header	Debug container	Debug header
`std::unordered_map`	`unordered_map`	`__gnu_debug::unordered_map`	`<debug/unordered_map>`
`std::unordered_multimap`	`unordered_map`	`__gnu_debug::unordered_multimap`	`<debug/unordered_map>`
`std::unordered_set`	`unordered_set`	`__gnu_debug::unordered_set`	`<debug/unordered_set>`
`std::unordered_multiset`	`unordered_set`	`__gnu_debug::unordered_multiset`	`<debug/unordered_set>`

PrevÂ	Up	Â Next
SemanticsÂ	Home	Â Design

+
TableÂ 17.2.Â Debugging Containers C++11
Container Header Debug container Debug header
std::unordered_map unordered_map __gnu_debug::unordered_map <debug/unordered_map>
std::unordered_multimap unordered_map __gnu_debug::unordered_multimap <debug/unordered_map>
std::unordered_set unordered_set __gnu_debug::unordered_set <debug/unordered_set>
std::unordered_multiset unordered_set __gnu_debug::unordered_multiset <debug/unordered_set>

Container	Header	Debug container	Debug header
`std::unordered_map`	`unordered_map`	`__gnu_debug::unordered_map`	`<debug/unordered_map>`
`std::unordered_multimap`	`unordered_map`	`__gnu_debug::unordered_multimap`	`<debug/unordered_map>`
`std::unordered_set`	`unordered_set`	`__gnu_debug::unordered_set`	`<debug/unordered_set>`
`std::unordered_multiset`	`unordered_set`	`__gnu_debug::unordered_multiset`	`<debug/unordered_set>`

PrevÂ	Up	Â Next
SemanticsÂ	Home	Â Design

diff --git a/libstdc++-v3/doc/html/manual/bk01pt03ch17s04.html b/libstdc++-v3/doc/html/manual/bk01pt03ch17s04.html index a0a85b76dc1..1aa9f30a246 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt03ch17s04.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch17s04.html @@ -193,7 +193,7 @@ template<typename _Tp, typename _Allocator = allocator<_Tp> and making the debug mode easier to incorporate into development environments by minimizing dependencies.
Achieving link- and run-time coexistence is not a trivial implementation task. To achieve this goal we required a small - extension to the GNU C++ compiler (since incorporated into the C++0x language specification, described in the GCC Manual for the C++ language as + extension to the GNU C++ compiler (since incorporated into the C++11 language specification, described in the GCC Manual for the C++ language as namespace association), and a complex organization of debug- and release-modes. The end result is that we have achieved per-use @@ -224,7 +224,7 @@ namespace std defined in the namespace __cxx1998) and also the debug-mode container. The debug-mode container is defined within the namespace __debug, which is associated with namespace -std via the C++0x namespace association language feature. This +std via the C++11 namespace association language feature. This method allows the debug and release versions of the same component to coexist at compile-time and link-time without causing an unreasonable maintenance burden, while minimizing confusion. Again, this boils down diff --git a/libstdc++-v3/doc/html/manual/bk01pt03ch18s03.html b/libstdc++-v3/doc/html/manual/bk01pt03ch18s03.html index c33d260ae0e..e81434e5e44 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt03ch18s03.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch18s03.html @@ -63,4 +63,4 @@ Then compile this code with the prerequisite compiler flags flags for atomic operations.)
The following table provides the names and headers of all the parallel algorithms that can be used in a similar manner: -
TableÂ 18.1.Â Parallel Algorithms
Algorithm Header Parallel algorithm Parallel header
std::accumulate numeric __gnu_parallel::accumulate parallel/numeric
std::adjacent_difference numeric __gnu_parallel::adjacent_difference parallel/numeric
std::inner_product numeric __gnu_parallel::inner_product parallel/numeric
std::partial_sum numeric __gnu_parallel::partial_sum parallel/numeric
std::adjacent_find algorithm __gnu_parallel::adjacent_find parallel/algorithm
std::count algorithm __gnu_parallel::count parallel/algorithm
std::count_if algorithm __gnu_parallel::count_if parallel/algorithm
std::equal algorithm __gnu_parallel::equal parallel/algorithm
std::find algorithm __gnu_parallel::find parallel/algorithm
std::find_if algorithm __gnu_parallel::find_if parallel/algorithm
std::find_first_of algorithm __gnu_parallel::find_first_of parallel/algorithm
std::for_each algorithm __gnu_parallel::for_each parallel/algorithm
std::generate algorithm __gnu_parallel::generate parallel/algorithm
std::generate_n algorithm __gnu_parallel::generate_n parallel/algorithm
std::lexicographical_compare algorithm __gnu_parallel::lexicographical_compare parallel/algorithm
std::mismatch algorithm __gnu_parallel::mismatch parallel/algorithm
std::search algorithm __gnu_parallel::search parallel/algorithm
std::search_n algorithm __gnu_parallel::search_n parallel/algorithm
std::transform algorithm __gnu_parallel::transform parallel/algorithm
std::replace algorithm __gnu_parallel::replace parallel/algorithm
std::replace_if algorithm __gnu_parallel::replace_if parallel/algorithm
std::max_element algorithm __gnu_parallel::max_element parallel/algorithm
std::merge algorithm __gnu_parallel::merge parallel/algorithm
std::min_element algorithm __gnu_parallel::min_element parallel/algorithm
std::nth_element algorithm __gnu_parallel::nth_element parallel/algorithm
std::partial_sort algorithm __gnu_parallel::partial_sort parallel/algorithm
std::partition algorithm __gnu_parallel::partition parallel/algorithm
std::random_shuffle algorithm __gnu_parallel::random_shuffle parallel/algorithm
std::set_union algorithm __gnu_parallel::set_union parallel/algorithm
std::set_intersection algorithm __gnu_parallel::set_intersection parallel/algorithm
std::set_symmetric_difference algorithm __gnu_parallel::set_symmetric_difference parallel/algorithm
std::set_difference algorithm __gnu_parallel::set_difference parallel/algorithm
std::sort algorithm __gnu_parallel::sort parallel/algorithm
std::stable_sort algorithm __gnu_parallel::stable_sort parallel/algorithm
std::unique_copy algorithm __gnu_parallel::unique_copy parallel/algorithm

Algorithm	Header	Parallel algorithm	Parallel header
`std::accumulate`	`numeric`	`__gnu_parallel::accumulate`	`parallel/numeric`
`std::adjacent_difference`	`numeric`	`__gnu_parallel::adjacent_difference`	`parallel/numeric`
`std::inner_product`	`numeric`	`__gnu_parallel::inner_product`	`parallel/numeric`
`std::partial_sum`	`numeric`	`__gnu_parallel::partial_sum`	`parallel/numeric`
`std::adjacent_find`	`algorithm`	`__gnu_parallel::adjacent_find`	`parallel/algorithm`
`std::count`	`algorithm`	`__gnu_parallel::count`	`parallel/algorithm`
`std::count_if`	`algorithm`	`__gnu_parallel::count_if`	`parallel/algorithm`
`std::equal`	`algorithm`	`__gnu_parallel::equal`	`parallel/algorithm`
`std::find`	`algorithm`	`__gnu_parallel::find`	`parallel/algorithm`
`std::find_if`	`algorithm`	`__gnu_parallel::find_if`	`parallel/algorithm`
`std::find_first_of`	`algorithm`	`__gnu_parallel::find_first_of`	`parallel/algorithm`
`std::for_each`	`algorithm`	`__gnu_parallel::for_each`	`parallel/algorithm`
`std::generate`	`algorithm`	`__gnu_parallel::generate`	`parallel/algorithm`
`std::generate_n`	`algorithm`	`__gnu_parallel::generate_n`	`parallel/algorithm`
`std::lexicographical_compare`	`algorithm`	`__gnu_parallel::lexicographical_compare`	`parallel/algorithm`
`std::mismatch`	`algorithm`	`__gnu_parallel::mismatch`	`parallel/algorithm`
`std::search`	`algorithm`	`__gnu_parallel::search`	`parallel/algorithm`
`std::search_n`	`algorithm`	`__gnu_parallel::search_n`	`parallel/algorithm`
`std::transform`	`algorithm`	`__gnu_parallel::transform`	`parallel/algorithm`
`std::replace`	`algorithm`	`__gnu_parallel::replace`	`parallel/algorithm`
`std::replace_if`	`algorithm`	`__gnu_parallel::replace_if`	`parallel/algorithm`
`std::max_element`	`algorithm`	`__gnu_parallel::max_element`	`parallel/algorithm`
`std::merge`	`algorithm`	`__gnu_parallel::merge`	`parallel/algorithm`
`std::min_element`	`algorithm`	`__gnu_parallel::min_element`	`parallel/algorithm`
`std::nth_element`	`algorithm`	`__gnu_parallel::nth_element`	`parallel/algorithm`
`std::partial_sort`	`algorithm`	`__gnu_parallel::partial_sort`	`parallel/algorithm`
`std::partition`	`algorithm`	`__gnu_parallel::partition`	`parallel/algorithm`
`std::random_shuffle`	`algorithm`	`__gnu_parallel::random_shuffle`	`parallel/algorithm`
`std::set_union`	`algorithm`	`__gnu_parallel::set_union`	`parallel/algorithm`
`std::set_intersection`	`algorithm`	`__gnu_parallel::set_intersection`	`parallel/algorithm`
`std::set_symmetric_difference`	`algorithm`	`__gnu_parallel::set_symmetric_difference`	`parallel/algorithm`
`std::set_difference`	`algorithm`	`__gnu_parallel::set_difference`	`parallel/algorithm`
`std::sort`	`algorithm`	`__gnu_parallel::sort`	`parallel/algorithm`
`std::stable_sort`	`algorithm`	`__gnu_parallel::stable_sort`	`parallel/algorithm`
`std::unique_copy`	`algorithm`	`__gnu_parallel::unique_copy`	`parallel/algorithm`

PrevÂ	Up	Â Next
SemanticsÂ	Home	Â Design

+
TableÂ 18.1.Â Parallel Algorithms
Algorithm Header Parallel algorithm Parallel header
std::accumulate numeric __gnu_parallel::accumulate parallel/numeric
std::adjacent_difference numeric __gnu_parallel::adjacent_difference parallel/numeric
std::inner_product numeric __gnu_parallel::inner_product parallel/numeric
std::partial_sum numeric __gnu_parallel::partial_sum parallel/numeric
std::adjacent_find algorithm __gnu_parallel::adjacent_find parallel/algorithm
std::count algorithm __gnu_parallel::count parallel/algorithm
std::count_if algorithm __gnu_parallel::count_if parallel/algorithm
std::equal algorithm __gnu_parallel::equal parallel/algorithm
std::find algorithm __gnu_parallel::find parallel/algorithm
std::find_if algorithm __gnu_parallel::find_if parallel/algorithm
std::find_first_of algorithm __gnu_parallel::find_first_of parallel/algorithm
std::for_each algorithm __gnu_parallel::for_each parallel/algorithm
std::generate algorithm __gnu_parallel::generate parallel/algorithm
std::generate_n algorithm __gnu_parallel::generate_n parallel/algorithm
std::lexicographical_compare algorithm __gnu_parallel::lexicographical_compare parallel/algorithm
std::mismatch algorithm __gnu_parallel::mismatch parallel/algorithm
std::search algorithm __gnu_parallel::search parallel/algorithm
std::search_n algorithm __gnu_parallel::search_n parallel/algorithm
std::transform algorithm __gnu_parallel::transform parallel/algorithm
std::replace algorithm __gnu_parallel::replace parallel/algorithm
std::replace_if algorithm __gnu_parallel::replace_if parallel/algorithm
std::max_element algorithm __gnu_parallel::max_element parallel/algorithm
std::merge algorithm __gnu_parallel::merge parallel/algorithm
std::min_element algorithm __gnu_parallel::min_element parallel/algorithm
std::nth_element algorithm __gnu_parallel::nth_element parallel/algorithm
std::partial_sort algorithm __gnu_parallel::partial_sort parallel/algorithm
std::partition algorithm __gnu_parallel::partition parallel/algorithm
std::random_shuffle algorithm __gnu_parallel::random_shuffle parallel/algorithm
std::set_union algorithm __gnu_parallel::set_union parallel/algorithm
std::set_intersection algorithm __gnu_parallel::set_intersection parallel/algorithm
std::set_symmetric_difference algorithm __gnu_parallel::set_symmetric_difference parallel/algorithm
std::set_difference algorithm __gnu_parallel::set_difference parallel/algorithm
std::sort algorithm __gnu_parallel::sort parallel/algorithm
std::stable_sort algorithm __gnu_parallel::stable_sort parallel/algorithm
std::unique_copy algorithm __gnu_parallel::unique_copy parallel/algorithm

Algorithm	Header	Parallel algorithm	Parallel header
`std::accumulate`	`numeric`	`__gnu_parallel::accumulate`	`parallel/numeric`
`std::adjacent_difference`	`numeric`	`__gnu_parallel::adjacent_difference`	`parallel/numeric`
`std::inner_product`	`numeric`	`__gnu_parallel::inner_product`	`parallel/numeric`
`std::partial_sum`	`numeric`	`__gnu_parallel::partial_sum`	`parallel/numeric`
`std::adjacent_find`	`algorithm`	`__gnu_parallel::adjacent_find`	`parallel/algorithm`
`std::count`	`algorithm`	`__gnu_parallel::count`	`parallel/algorithm`
`std::count_if`	`algorithm`	`__gnu_parallel::count_if`	`parallel/algorithm`
`std::equal`	`algorithm`	`__gnu_parallel::equal`	`parallel/algorithm`
`std::find`	`algorithm`	`__gnu_parallel::find`	`parallel/algorithm`
`std::find_if`	`algorithm`	`__gnu_parallel::find_if`	`parallel/algorithm`
`std::find_first_of`	`algorithm`	`__gnu_parallel::find_first_of`	`parallel/algorithm`
`std::for_each`	`algorithm`	`__gnu_parallel::for_each`	`parallel/algorithm`
`std::generate`	`algorithm`	`__gnu_parallel::generate`	`parallel/algorithm`
`std::generate_n`	`algorithm`	`__gnu_parallel::generate_n`	`parallel/algorithm`
`std::lexicographical_compare`	`algorithm`	`__gnu_parallel::lexicographical_compare`	`parallel/algorithm`
`std::mismatch`	`algorithm`	`__gnu_parallel::mismatch`	`parallel/algorithm`
`std::search`	`algorithm`	`__gnu_parallel::search`	`parallel/algorithm`
`std::search_n`	`algorithm`	`__gnu_parallel::search_n`	`parallel/algorithm`
`std::transform`	`algorithm`	`__gnu_parallel::transform`	`parallel/algorithm`
`std::replace`	`algorithm`	`__gnu_parallel::replace`	`parallel/algorithm`
`std::replace_if`	`algorithm`	`__gnu_parallel::replace_if`	`parallel/algorithm`
`std::max_element`	`algorithm`	`__gnu_parallel::max_element`	`parallel/algorithm`
`std::merge`	`algorithm`	`__gnu_parallel::merge`	`parallel/algorithm`
`std::min_element`	`algorithm`	`__gnu_parallel::min_element`	`parallel/algorithm`
`std::nth_element`	`algorithm`	`__gnu_parallel::nth_element`	`parallel/algorithm`
`std::partial_sort`	`algorithm`	`__gnu_parallel::partial_sort`	`parallel/algorithm`
`std::partition`	`algorithm`	`__gnu_parallel::partition`	`parallel/algorithm`
`std::random_shuffle`	`algorithm`	`__gnu_parallel::random_shuffle`	`parallel/algorithm`
`std::set_union`	`algorithm`	`__gnu_parallel::set_union`	`parallel/algorithm`
`std::set_intersection`	`algorithm`	`__gnu_parallel::set_intersection`	`parallel/algorithm`
`std::set_symmetric_difference`	`algorithm`	`__gnu_parallel::set_symmetric_difference`	`parallel/algorithm`
`std::set_difference`	`algorithm`	`__gnu_parallel::set_difference`	`parallel/algorithm`
`std::sort`	`algorithm`	`__gnu_parallel::sort`	`parallel/algorithm`
`std::stable_sort`	`algorithm`	`__gnu_parallel::stable_sort`	`parallel/algorithm`
`std::unique_copy`	`algorithm`	`__gnu_parallel::unique_copy`	`parallel/algorithm`

PrevÂ	Up	Â Next
SemanticsÂ	Home	Â Design

diff --git a/libstdc++-v3/doc/html/manual/bk01pt03ch19s02.html b/libstdc++-v3/doc/html/manual/bk01pt03ch19s02.html index eada010800c..5b923c070d0 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt03ch19s02.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch19s02.html @@ -1,7 +1,7 @@ Design
Design
PrevÂ ChapterÂ 19.Â Profile Mode Â Next
Design
-
TableÂ 19.1.Â Profile Code Location
Code Location Use
libstdc++-v3/include/std/* Preprocessor code to redirect to profile extension headers.
libstdc++-v3/include/profile/* Profile extension public headers (map, vector, ...).
libstdc++-v3/include/profile/impl/* Profile extension internals. Implementation files are +
TableÂ 19.1.Â Profile Code Location
Code Location Use
libstdc++-v3/include/std/* Preprocessor code to redirect to profile extension headers.
libstdc++-v3/include/profile/* Profile extension public headers (map, vector, ...).
libstdc++-v3/include/profile/impl/* Profile extension internals. Implementation files are only included from impl/profiler.h, which is the only file included from the public headers.

Wrapper Model
diff --git a/libstdc++-v3/doc/html/manual/bk01pt03ch19s07.html b/libstdc++-v3/doc/html/manual/bk01pt03ch19s07.html index cfa6aaa982c..780504cbbc5 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt03ch19s07.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch19s07.html @@ -18,7 +18,7 @@ A high accuracy means that the diagnostic is unlikely to be wrong. These grades are not perfect. They are just meant to guide users with specific needs or time budgets. -
TableÂ 19.2.Â Profile Diagnostics
Group Flag Benefit Cost Freq. Implemented Â
+
TableÂ 19.2.Â Profile Diagnostics
Group Flag Benefit Cost Freq. Implemented Â
CONTAINERS HASHTABLE_TOO_SMALL 10 1 Â 10 yes
Â HASHTABLE_TOO_LARGE 5 1 Â 10 yes
Â diff --git a/libstdc++-v3/doc/html/manual/bk01pt03ch21s02.html b/libstdc++-v3/doc/html/manual/bk01pt03ch21s02.html index 3b3267340ac..5a0abcd4944 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt03ch21s02.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch21s02.html @@ -76,7 +76,7 @@ else return false.

Consider a block of size 64 ints. In memory, it would look like this: (assume a 32-bit system where, size_t is a 32-bit entity). -
TableÂ 21.1.Â Bitmap Allocator Memory Map
268 0 4294967295 4294967295 Data -> Space for 64 ints

+
TableÂ 21.1.Â Bitmap Allocator Memory Map
268 0 4294967295 4294967295 Data -> Space for 64 ints

The first Column(268) represents the size of the Block in bytes as seen by the Bitmap Allocator. Internally, a global free list is used to keep track of the free blocks used and given back by the diff --git a/libstdc++-v3/doc/html/manual/bk01pt03ch23s02.html b/libstdc++-v3/doc/html/manual/bk01pt03ch23s02.html index 29d9f5d1db6..f1771e99c9e 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt03ch23s02.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch23s02.html @@ -4,7 +4,7 @@ The SGI hashing classes hash_set and hash_set have been deprecated by the unordered_set, unordered_multiset, unordered_map, - unordered_multimap containers in TR1 and the upcoming C++0x, and + unordered_multimap containers in TR1 and C++11, and may be removed in future releases.
The SGI headers
<hash_map> diff --git a/libstdc++-v3/doc/html/manual/bk01pt03pr01.html b/libstdc++-v3/doc/html/manual/bk01pt03pr01.html index 255a182469f..79e7f97c00e 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt03pr01.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03pr01.html @@ -3,7 +3,7 @@ <meta name="generator" content="DocBook XSL-NS Stylesheets V1.76.1"/><meta name="keywords" content=" ISO C++ , library "/><meta name="keywords" content=" ISO C++ , runtime , library "/><link rel="home" href="../index.html" title="The GNU C++ Library"/><link rel="up" href="extensions.html" title="PartÂ III.Â Extensions"/><link rel="prev" href="extensions.html" title="PartÂ III.Â Extensions"/><link rel="next" href="ext_compile_checks.html" title="ChapterÂ 16.Â Compile Time Checks"/></head><body><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center"/></tr><tr><td align="left"><a accesskey="p" href="extensions.html">Prev</a>Â </td><th width="60%" align="center">PartÂ III.Â Extensions -</th><td align="right">Â <a accesskey="n" href="ext_compile_checks.html">Next</a></td></tr></table><hr/></div><div class="preface"><div class="titlepage"><div><div><h1 class="title"><a id="id484429"/></h1></div></div></div><p> +</th><td align="right">Â <a accesskey="n" href="ext_compile_checks.html">Next</a></td></tr></table><hr/></div><div class="preface"><div class="titlepage"><div><div><h1 class="title"><a id="id464675"/></h1></div></div></div><p> Here we will make an attempt at describing the non-Standard extensions to the library. Some of these are from older versions of standard library components, namely SGI's STL, and some of these are diff --git a/libstdc++-v3/doc/html/manual/bk01pt04.html b/libstdc++-v3/doc/html/manual/bk01pt04.html index 7ac1c32cc4c..427cdabb0ad 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt04.html +++ b/libstdc++-v3/doc/html/manual/bk01pt04.html @@ -16,21 +16,21 @@ </a></span></dt><dd><dl><dt><span class="section"><a href="test.html#test.exception.safety.overview">Overview</a></span></dt><dt><span class="section"><a href="test.html#test.exception.safety.status"> Existing tests </a></span></dt><dt><span class="section"><a href="test.html#test.exception.safety.containers"> -C++0x Requirements Test Sequence Descriptions -</a></span></dt></dl></dd></dl></dd></dl></dd><dt><span class="section"><a href="abi.html">ABI Policy and Guidelines</a></span></dt><dd><dl><dt><span class="section"><a href="abi.html#abi.cxx_interface">The C++ Interface</a></span></dt><dt><span class="section"><a href="abi.html#abi.versioning">Versioning</a></span></dt><dd><dl><dt><span class="section"><a href="abi.html#abi.versioning.goals">Goals</a></span></dt><dt><span class="section"><a href="abi.html#abi.versioning.history">History</a></span></dt><dt><span class="section"><a href="abi.html#abi.versioning.prereq">Prerequisites</a></span></dt><dt><span class="section"><a href="abi.html#abi.versioning.config">Configuring</a></span></dt><dt><span class="section"><a href="abi.html#abi.versioning.active">Checking Active</a></span></dt></dl></dd><dt><span class="section"><a href="abi.html#abi.changes_allowed">Allowed Changes</a></span></dt><dt><span class="section"><a href="abi.html#abi.changes_no">Prohibited Changes</a></span></dt><dt><span class="section"><a href="abi.html#abi.impl">Implementation</a></span></dt><dt><span class="section"><a href="abi.html#abi.testing">Testing</a></span></dt><dd><dl><dt><span class="section"><a href="abi.html#abi.testing.single">Single ABI Testing</a></span></dt><dt><span class="section"><a href="abi.html#abi.testing.multi">Multiple ABI Testing</a></span></dt></dl></dd><dt><span class="section"><a href="abi.html#abi.issues">Outstanding Issues</a></span></dt></dl></dd><dt><span class="section"><a href="api.html">API Evolution and Deprecation History</a></span></dt><dd><dl><dt><span class="section"><a href="api.html#api.rel_300"><code class="constant">3.0</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_310"><code class="constant">3.1</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_320"><code class="constant">3.2</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_330"><code class="constant">3.3</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_340"><code class="constant">3.4</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_400"><code class="constant">4.0</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_410"><code class="constant">4.1</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_420"><code class="constant">4.2</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_430"><code class="constant">4.3</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_440"><code class="constant">4.4</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_450"><code class="constant">4.5</code></a></span></dt></dl></dd><dt><span class="section"><a href="backwards.html">Backwards Compatibility</a></span></dt><dd><dl><dt><span class="section"><a href="backwards.html#backwards.first">First</a></span></dt><dd><dl><dt><span class="section"><a href="backwards.html#id540654">No <code class="code">ios_base</code></a></span></dt><dt><span class="section"><a href="backwards.html#id540687">No <code class="code">cout</code> in <code class="code">ostream.h</code>, no <code class="code">cin</code> in <code class="code">istream.h</code></a></span></dt></dl></dd><dt><span class="section"><a href="backwards.html#backwards.second">Second</a></span></dt><dd><dl><dt><span class="section"><a href="backwards.html#id540790">Namespace <code class="code">std::</code> not supported</a></span></dt><dt><span class="section"><a href="backwards.html#id540916">Illegal iterator usage</a></span></dt><dt><span class="section"><a href="backwards.html#id540977"><code class="code">isspace</code> from <code class="filename">cctype</code> is a macro - </a></span></dt><dt><span class="section"><a href="backwards.html#id541073">No <code class="code">vector::at</code>, <code class="code">deque::at</code>, <code class="code">string::at</code></a></span></dt><dt><span class="section"><a href="backwards.html#id541112">No <code class="code">std::char_traits<char>::eof</code></a></span></dt><dt><span class="section"><a href="backwards.html#id541130">No <code class="code">string::clear</code></a></span></dt><dt><span class="section"><a href="backwards.html#id541176"> +C++11 Requirements Test Sequence Descriptions +</a></span></dt></dl></dd></dl></dd></dl></dd><dt><span class="section"><a href="abi.html">ABI Policy and Guidelines</a></span></dt><dd><dl><dt><span class="section"><a href="abi.html#abi.cxx_interface">The C++ Interface</a></span></dt><dt><span class="section"><a href="abi.html#abi.versioning">Versioning</a></span></dt><dd><dl><dt><span class="section"><a href="abi.html#abi.versioning.goals">Goals</a></span></dt><dt><span class="section"><a href="abi.html#abi.versioning.history">History</a></span></dt><dt><span class="section"><a href="abi.html#abi.versioning.prereq">Prerequisites</a></span></dt><dt><span class="section"><a href="abi.html#abi.versioning.config">Configuring</a></span></dt><dt><span class="section"><a href="abi.html#abi.versioning.active">Checking Active</a></span></dt></dl></dd><dt><span class="section"><a href="abi.html#abi.changes_allowed">Allowed Changes</a></span></dt><dt><span class="section"><a href="abi.html#abi.changes_no">Prohibited Changes</a></span></dt><dt><span class="section"><a href="abi.html#abi.impl">Implementation</a></span></dt><dt><span class="section"><a href="abi.html#abi.testing">Testing</a></span></dt><dd><dl><dt><span class="section"><a href="abi.html#abi.testing.single">Single ABI Testing</a></span></dt><dt><span class="section"><a href="abi.html#abi.testing.multi">Multiple ABI Testing</a></span></dt></dl></dd><dt><span class="section"><a href="abi.html#abi.issues">Outstanding Issues</a></span></dt></dl></dd><dt><span class="section"><a href="api.html">API Evolution and Deprecation History</a></span></dt><dd><dl><dt><span class="section"><a href="api.html#api.rel_300"><code class="constant">3.0</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_310"><code class="constant">3.1</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_320"><code class="constant">3.2</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_330"><code class="constant">3.3</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_340"><code class="constant">3.4</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_400"><code class="constant">4.0</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_410"><code class="constant">4.1</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_420"><code class="constant">4.2</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_430"><code class="constant">4.3</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_440"><code class="constant">4.4</code></a></span></dt><dt><span class="section"><a href="api.html#api.rel_450"><code class="constant">4.5</code></a></span></dt></dl></dd><dt><span class="section"><a href="backwards.html">Backwards Compatibility</a></span></dt><dd><dl><dt><span class="section"><a href="backwards.html#backwards.first">First</a></span></dt><dd><dl><dt><span class="section"><a href="backwards.html#id520901">No <code class="code">ios_base</code></a></span></dt><dt><span class="section"><a href="backwards.html#id520933">No <code class="code">cout</code> in <code class="code">ostream.h</code>, no <code class="code">cin</code> in <code class="code">istream.h</code></a></span></dt></dl></dd><dt><span class="section"><a href="backwards.html#backwards.second">Second</a></span></dt><dd><dl><dt><span class="section"><a href="backwards.html#id521036">Namespace <code class="code">std::</code> not supported</a></span></dt><dt><span class="section"><a href="backwards.html#id521162">Illegal iterator usage</a></span></dt><dt><span class="section"><a href="backwards.html#id521224"><code class="code">isspace</code> from <code class="filename">cctype</code> is a macro + </a></span></dt><dt><span class="section"><a href="backwards.html#id521319">No <code class="code">vector::at</code>, <code class="code">deque::at</code>, <code class="code">string::at</code></a></span></dt><dt><span class="section"><a href="backwards.html#id521358">No <code class="code">std::char_traits<char>::eof</code></a></span></dt><dt><span class="section"><a href="backwards.html#id521376">No <code class="code">string::clear</code></a></span></dt><dt><span class="section"><a href="backwards.html#id521422"> Removal of <code class="code">ostream::form</code> and <code class="code">istream::scan</code> extensions -</a></span></dt><dt><span class="section"><a href="backwards.html#id541195">No <code class="code">basic_stringbuf</code>, <code class="code">basic_stringstream</code></a></span></dt><dt><span class="section"><a href="backwards.html#id541351">Little or no wide character support</a></span></dt><dt><span class="section"><a href="backwards.html#id541369">No templatized iostreams</a></span></dt><dt><span class="section"><a href="backwards.html#id541388">Thread safety issues</a></span></dt></dl></dd><dt><span class="section"><a href="backwards.html#backwards.third">Third</a></span></dt><dd><dl><dt><span class="section"><a href="backwards.html#id541513">Pre-ISO headers moved to backwards or removed</a></span></dt><dt><span class="section"><a href="backwards.html#id541598">Extension headers hash_map, hash_set moved to ext or backwards</a></span></dt><dt><span class="section"><a href="backwards.html#id541701">No <code class="code">ios::nocreate/ios::noreplace</code>. -</a></span></dt><dt><span class="section"><a href="backwards.html#id541749"> +</a></span></dt><dt><span class="section"><a href="backwards.html#id521441">No <code class="code">basic_stringbuf</code>, <code class="code">basic_stringstream</code></a></span></dt><dt><span class="section"><a href="backwards.html#id521597">Little or no wide character support</a></span></dt><dt><span class="section"><a href="backwards.html#id521616">No templatized iostreams</a></span></dt><dt><span class="section"><a href="backwards.html#id521634">Thread safety issues</a></span></dt></dl></dd><dt><span class="section"><a href="backwards.html#backwards.third">Third</a></span></dt><dd><dl><dt><span class="section"><a href="backwards.html#id521759">Pre-ISO headers moved to backwards or removed</a></span></dt><dt><span class="section"><a href="backwards.html#id521844">Extension headers hash_map, hash_set moved to ext or backwards</a></span></dt><dt><span class="section"><a href="backwards.html#id521961">No <code class="code">ios::nocreate/ios::noreplace</code>. +</a></span></dt><dt><span class="section"><a href="backwards.html#id522009"> No <code class="code">stream::attach(int fd)</code> -</a></span></dt><dt><span class="section"><a href="backwards.html#id541817"> +</a></span></dt><dt><span class="section"><a href="backwards.html#backwards.support_cxx98"> Support for C++98 dialect. -</a></span></dt><dt><span class="section"><a href="backwards.html#id541844"> +</a></span></dt><dt><span class="section"><a href="backwards.html#backwards.support_tr1"> Support for C++TR1 dialect. -</a></span></dt><dt><span class="section"><a href="backwards.html#id541888"> -Support for C++0x dialect. -</a></span></dt><dt><span class="section"><a href="backwards.html#id541966"> +</a></span></dt><dt><span class="section"><a href="backwards.html#backwards.support_cxx11"> +Support for C++11 dialect. +</a></span></dt><dt><span class="section"><a href="backwards.html#id522258"> Container::iterator_type is not necessarily Container::value_type* </a></span></dt></dl></dd></dl></dd></dl></dd><dt><span class="appendix"><a href="appendix_free.html">C. Free Software Needs Free Documentation diff --git a/libstdc++-v3/doc/html/manual/bugs.html b/libstdc++-v3/doc/html/manual/bugs.html index a3dcaaf94cf..91a4574b106 100644 --- a/libstdc++-v3/doc/html/manual/bugs.html +++ b/libstdc++-v3/doc/html/manual/bugs.html @@ -226,7 +226,7 @@ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#387">387</a>: <span class="emphasis"><em>std::complex over-encapsulated</em></span> </span></dt><dd><p>Add the <code class="code">real(T)</code> and <code class="code">imag(T)</code> - members; in C++0x mode, also adjust the existing + members; in C++11 mode, also adjust the existing <code class="code">real()</code> and <code class="code">imag()</code> members and free functions. </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#389">389</a>: @@ -298,7 +298,7 @@ </span></dt><dd><p>Follow the straightforward proposed resolution. </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#550">550</a>: <span class="emphasis"><em>What should the return type of pow(float,int) be?</em></span> - </span></dt><dd><p>In C++0x mode, remove the pow(float,int), etc., signatures. + </span></dt><dd><p>In C++11 mode, remove the pow(float,int), etc., signatures. </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#586">586</a>: <span class="emphasis"><em>string inserter not a formatted function</em></span> </span></dt><dd><p>Change it to be a formatted output function (i.e. catch exceptions). @@ -313,7 +313,7 @@ </span></dt><dd><p>Add the missing operations. </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#691">691</a>: <span class="emphasis"><em>const_local_iterator cbegin, cend missing from TR1</em></span> - </span></dt><dd><p>In C++0x mode add cbegin(size_type) and cend(size_type) + </span></dt><dd><p>In C++11 mode add cbegin(size_type) and cend(size_type) to the unordered containers. </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#693">693</a>: <span class="emphasis"><em>std::bitset::all() missing</em></span> @@ -326,22 +326,22 @@ </span></dt><dd><p>Implement the straightforward resolution. </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#761">761</a>: <span class="emphasis"><em>unordered_map needs an at() member function</em></span> - </span></dt><dd><p>In C++0x mode, add at() and at() const. + </span></dt><dd><p>In C++11 mode, add at() and at() const. </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#775">775</a>: <span class="emphasis"><em>Tuple indexing should be unsigned?</em></span> </span></dt><dd><p>Implement the int -> size_t replacements. </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#776">776</a>: <span class="emphasis"><em>Undescribed assign function of std::array</em></span> - </span></dt><dd><p>In C++0x mode, remove assign, add fill. + </span></dt><dd><p>In C++11 mode, remove assign, add fill. </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#781">781</a>: <span class="emphasis"><em>std::complex should add missing C99 functions</em></span> - </span></dt><dd><p>In C++0x mode, add std::proj. + </span></dt><dd><p>In C++11 mode, add std::proj. </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#809">809</a>: <span class="emphasis"><em>std::swap should be overloaded for array types</em></span> </span></dt><dd><p>Add the overload. </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#844">844</a>: <span class="emphasis"><em>complex pow return type is ambiguous</em></span> - </span></dt><dd><p>In C++0x mode, remove the pow(complex<T>, int) signature. + </span></dt><dd><p>In C++11 mode, remove the pow(complex<T>, int) signature. </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#853">853</a>: <span class="emphasis"><em>to_string needs updating with zero and one</em></span> </span></dt><dd><p>Update / add the signatures. diff --git a/libstdc++-v3/doc/html/manual/concurrency.html b/libstdc++-v3/doc/html/manual/concurrency.html index 98fdae64911..35efc060239 100644 --- a/libstdc++-v3/doc/html/manual/concurrency.html +++ b/libstdc++-v3/doc/html/manual/concurrency.html @@ -7,7 +7,7 @@ Standard Contents </th><td align="right">Â <a accesskey="n" href="extensions.html">Next</a></td></tr></table><hr/></div><div class="chapter" title="ChapterÂ 15.Â Concurrency"><div class="titlepage"><div><div><h2 class="title"><a id="std.concurrency"/>ChapterÂ 15.Â Concurrency - <a id="id484245" class="indexterm"/> + <a id="id464491" class="indexterm"/> </h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="concurrency.html#std.concurrency.api">API Reference</a></span></dt></dl></div><p> Facilities for concurrent operation, and control thereof. </p><div class="section" title="API Reference"><div class="titlepage"><div><div><h2 class="title"><a id="std.concurrency.api"/>API Reference</h2></div></div></div><p> diff --git a/libstdc++-v3/doc/html/manual/configure.html b/libstdc++-v3/doc/html/manual/configure.html index 92809aa09e9..c2cf8d4c13a 100644 --- a/libstdc++-v3/doc/html/manual/configure.html +++ b/libstdc++-v3/doc/html/manual/configure.html @@ -88,7 +88,7 @@ </p></dd><dt><span class="term"><code class="code">--enable-libstdcxx-time=OPTION</code></span></dt><dd><p>Enables link-type checks for the availability of the clock_gettime clocks, used in the implementation of [time.clock], and of the nanosleep and sched_yield functions, used in the - implementation of [thread.thread.this] of the current C++0x draft. + implementation of [thread.thread.this] of the 2011 ISO C++ standard. The choice OPTION=yes checks for the availability of the facilities in libc and libposix4. In case of need the latter is also linked to libstdc++ as part of the build process. OPTION=rt also searches diff --git a/libstdc++-v3/doc/html/manual/containers.html b/libstdc++-v3/doc/html/manual/containers.html index 554bc1c1d90..05c5b0e88af 100644 --- a/libstdc++-v3/doc/html/manual/containers.html +++ b/libstdc++-v3/doc/html/manual/containers.html @@ -7,7 +7,7 @@ Standard Contents </th><td align="right">Â <a accesskey="n" href="associative.html">Next</a></td></tr></table><hr/></div><div class="chapter" title="ChapterÂ 9.Â Containers"><div class="titlepage"><div><div><h2 class="title"><a id="std.containers"/>ChapterÂ 9.Â Containers - <a id="id481292" class="indexterm"/> + <a id="id461537" class="indexterm"/> </h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="containers.html#std.containers.sequences">Sequences</a></span></dt><dd><dl><dt><span class="section"><a href="containers.html#containers.sequences.list">list</a></span></dt><dd><dl><dt><span class="section"><a href="containers.html#sequences.list.size">list::size() is O(n)</a></span></dt></dl></dd><dt><span class="section"><a href="containers.html#containers.sequences.vector">vector</a></span></dt><dd><dl><dt><span class="section"><a href="containers.html#sequences.vector.management">Space Overhead Management</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="associative.html">Associative</a></span></dt><dd><dl><dt><span class="section"><a href="associative.html#containers.associative.insert_hints">Insertion Hints</a></span></dt><dt><span class="section"><a href="associative.html#containers.associative.bitset">bitset</a></span></dt><dd><dl><dt><span class="section"><a href="associative.html#associative.bitset.size_variable">Size Variable</a></span></dt><dt><span class="section"><a href="associative.html#associative.bitset.type_string">Type String</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="containers_and_c.html">Interacting with C</a></span></dt><dd><dl><dt><span class="section"><a href="containers_and_c.html#containers.c.vs_array">Containers vs. Arrays</a></span></dt></dl></dd></dl></div><div class="section" title="Sequences"><div class="titlepage"><div><div><h2 class="title"><a id="std.containers.sequences"/>Sequences</h2></div></div></div><div class="section" title="list"><div class="titlepage"><div><div><h3 class="title"><a id="containers.sequences.list"/>list</h3></div></div></div><div class="section" title="list::size() is O(n)"><div class="titlepage"><div><div><h4 class="title"><a id="sequences.list.size"/>list::size() is O(n)</h4></div></div></div><p> Yes it is, and that's okay. This is a decision that we preserved when we imported SGI's STL implementation. The following is diff --git a/libstdc++-v3/doc/html/manual/diagnostics.html b/libstdc++-v3/doc/html/manual/diagnostics.html index 001e026caeb..f6de96d6ee5 100644 --- a/libstdc++-v3/doc/html/manual/diagnostics.html +++ b/libstdc++-v3/doc/html/manual/diagnostics.html @@ -7,7 +7,7 @@ Standard Contents </th><td align="right">Â <a accesskey="n" href="bk01pt02ch05s02.html">Next</a></td></tr></table><hr/></div><div class="chapter" title="ChapterÂ 5.Â Diagnostics"><div class="titlepage"><div><div><h2 class="title"><a id="std.diagnostics"/>ChapterÂ 5.Â Diagnostics - <a id="id462728" class="indexterm"/> + <a id="id442982" class="indexterm"/> </h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="diagnostics.html#std.diagnostics.exceptions">Exceptions</a></span></dt><dd><dl><dt><span class="section"><a href="diagnostics.html#std.diagnostics.exceptions.api">API Reference</a></span></dt><dt><span class="section"><a href="diagnostics.html#std.diagnostics.exceptions.data">Adding Data to <code class="classname">exception</code></a></span></dt></dl></dd><dt><span class="section"><a href="bk01pt02ch05s02.html">Concept Checking</a></span></dt></dl></div><div class="section" title="Exceptions"><div class="titlepage"><div><div><h2 class="title"><a id="std.diagnostics.exceptions"/>Exceptions</h2></div></div></div><div class="section" title="API Reference"><div class="titlepage"><div><div><h3 class="title"><a id="std.diagnostics.exceptions.api"/>API Reference</h3></div></div></div><p> All exception objects are defined in one of the standard header files: <code class="filename">exception</code>, diff --git a/libstdc++-v3/doc/html/manual/documentation_hacking.html b/libstdc++-v3/doc/html/manual/documentation_hacking.html index 11bc93ef4c0..798ea57f18f 100644 --- a/libstdc++-v3/doc/html/manual/documentation_hacking.html +++ b/libstdc++-v3/doc/html/manual/documentation_hacking.html @@ -117,7 +117,7 @@ supported, and are always aliased to dummy rules. These unsupported formats are: <span class="emphasis"><em>info</em></span>, <span class="emphasis"><em>ps</em></span>, and <span class="emphasis"><em>dvi</em></span>. - </p></div><div class="section" title="Doxygen"><div class="titlepage"><div><div><h3 class="title"><a id="doc.doxygen"/>Doxygen</h3></div></div></div><div class="section" title="Prerequisites"><div class="titlepage"><div><div><h4 class="title"><a id="doxygen.prereq"/>Prerequisites</h4></div></div></div><div class="table"><a id="id531887"/><p class="title"><strong>TableÂ B.1.Â Doxygen Prerequisites</strong></p><div class="table-contents"><table summary="Doxygen Prerequisites" border="1"><colgroup><col style="text-align: center" class="c1"/><col style="text-align: center" class="c2"/><col style="text-align: center" class="c3"/></colgroup><thead><tr><th style="text-align: center">Tool</th><th style="text-align: center">Version</th><th style="text-align: center">Required By</th></tr></thead><tbody><tr><td style="text-align: center">coreutils</td><td style="text-align: center">8.5</td><td style="text-align: center">all</td></tr><tr><td style="text-align: center">bash</td><td style="text-align: center">4.1</td><td style="text-align: center">all</td></tr><tr><td style="text-align: center">doxygen</td><td style="text-align: center">1.7.0</td><td style="text-align: center">all</td></tr><tr><td style="text-align: center">graphviz</td><td style="text-align: center">2.26</td><td style="text-align: center">graphical hierarchies</td></tr><tr><td style="text-align: center">pdflatex</td><td style="text-align: center">2007-59</td><td style="text-align: center">pdf output</td></tr></tbody></table></div></div><br class="table-break"/><p> + </p></div><div class="section" title="Doxygen"><div class="titlepage"><div><div><h3 class="title"><a id="doc.doxygen"/>Doxygen</h3></div></div></div><div class="section" title="Prerequisites"><div class="titlepage"><div><div><h4 class="title"><a id="doxygen.prereq"/>Prerequisites</h4></div></div></div><div class="table"><a id="id512133"/><p class="title"><strong>TableÂ B.1.Â Doxygen Prerequisites</strong></p><div class="table-contents"><table summary="Doxygen Prerequisites" border="1"><colgroup><col style="text-align: center" class="c1"/><col style="text-align: center" class="c2"/><col style="text-align: center" class="c3"/></colgroup><thead><tr><th style="text-align: center">Tool</th><th style="text-align: center">Version</th><th style="text-align: center">Required By</th></tr></thead><tbody><tr><td style="text-align: center">coreutils</td><td style="text-align: center">8.5</td><td style="text-align: center">all</td></tr><tr><td style="text-align: center">bash</td><td style="text-align: center">4.1</td><td style="text-align: center">all</td></tr><tr><td style="text-align: center">doxygen</td><td style="text-align: center">1.7.0</td><td style="text-align: center">all</td></tr><tr><td style="text-align: center">graphviz</td><td style="text-align: center">2.26</td><td style="text-align: center">graphical hierarchies</td></tr><tr><td style="text-align: center">pdflatex</td><td style="text-align: center">2007-59</td><td style="text-align: center">pdf output</td></tr></tbody></table></div></div><br class="table-break"/><p> Prerequisite tools are Bash 2.0 or later, <a class="link" href="http://www.doxygen.org/">Doxygen</a>, and the <a class="link" href="http://www.gnu.org/software/coreutils/">GNU @@ -263,7 +263,7 @@ writing Doxygen comments. Single and double quotes, and separators in filenames are two common trouble spots. When in doubt, consult the following table. - </p><div class="table"><a id="id532390"/><p class="title"><strong>TableÂ B.2.Â HTML to Doxygen Markup Comparison</strong></p><div class="table-contents"><table summary="HTML to Doxygen Markup Comparison" border="1"><colgroup><col style="text-align: left" class="c1"/><col style="text-align: left" class="c2"/></colgroup><thead><tr><th style="text-align: left">HTML</th><th style="text-align: left">Doxygen</th></tr></thead><tbody><tr><td style="text-align: left">\</td><td style="text-align: left">\\</td></tr><tr><td style="text-align: left">"</td><td style="text-align: left">\"</td></tr><tr><td style="text-align: left">'</td><td style="text-align: left">\'</td></tr><tr><td style="text-align: left"><i></td><td style="text-align: left">@a word</td></tr><tr><td style="text-align: left"><b></td><td style="text-align: left">@b word</td></tr><tr><td style="text-align: left"><code></td><td style="text-align: left">@c word</td></tr><tr><td style="text-align: left"><em></td><td style="text-align: left">@a word</td></tr><tr><td style="text-align: left"><em></td><td style="text-align: left"><em>two words or more</em></td></tr></tbody></table></div></div><br class="table-break"/></div></div><div class="section" title="Docbook"><div class="titlepage"><div><div><h3 class="title"><a id="doc.docbook"/>Docbook</h3></div></div></div><div class="section" title="Prerequisites"><div class="titlepage"><div><div><h4 class="title"><a id="docbook.prereq"/>Prerequisites</h4></div></div></div><div class="table"><a id="id532552"/><p class="title"><strong>TableÂ B.3.Â Docbook Prerequisites</strong></p><div class="table-contents"><table summary="Docbook Prerequisites" border="1"><colgroup><col style="text-align: center" class="c1"/><col style="text-align: center" class="c2"/><col style="text-align: center" class="c3"/></colgroup><thead><tr><th style="text-align: center">Tool</th><th style="text-align: center">Version</th><th style="text-align: center">Required By</th></tr></thead><tbody><tr><td style="text-align: center">docbook5-style-xsl</td><td style="text-align: center">1.76.1</td><td style="text-align: center">all</td></tr><tr><td style="text-align: center">xsltproc</td><td style="text-align: center">1.1.26</td><td style="text-align: center">all</td></tr><tr><td style="text-align: center">xmllint</td><td style="text-align: center">2.7.7</td><td style="text-align: center">validation</td></tr><tr><td style="text-align: center">dblatex</td><td style="text-align: center">0.3</td><td style="text-align: center">pdf output</td></tr><tr><td style="text-align: center">pdflatex</td><td style="text-align: center">2007-59</td><td style="text-align: center">pdf output</td></tr><tr><td style="text-align: center">docbook2X</td><td style="text-align: center">0.8.8</td><td style="text-align: center">info output</td></tr></tbody></table></div></div><br class="table-break"/><p> + </p><div class="table"><a id="id512636"/><p class="title"><strong>TableÂ B.2.Â HTML to Doxygen Markup Comparison</strong></p><div class="table-contents"><table summary="HTML to Doxygen Markup Comparison" border="1"><colgroup><col style="text-align: left" class="c1"/><col style="text-align: left" class="c2"/></colgroup><thead><tr><th style="text-align: left">HTML</th><th style="text-align: left">Doxygen</th></tr></thead><tbody><tr><td style="text-align: left">\</td><td style="text-align: left">\\</td></tr><tr><td style="text-align: left">"</td><td style="text-align: left">\"</td></tr><tr><td style="text-align: left">'</td><td style="text-align: left">\'</td></tr><tr><td style="text-align: left"><i></td><td style="text-align: left">@a word</td></tr><tr><td style="text-align: left"><b></td><td style="text-align: left">@b word</td></tr><tr><td style="text-align: left"><code></td><td style="text-align: left">@c word</td></tr><tr><td style="text-align: left"><em></td><td style="text-align: left">@a word</td></tr><tr><td style="text-align: left"><em></td><td style="text-align: left"><em>two words or more</em></td></tr></tbody></table></div></div><br class="table-break"/></div></div><div class="section" title="Docbook"><div class="titlepage"><div><div><h3 class="title"><a id="doc.docbook"/>Docbook</h3></div></div></div><div class="section" title="Prerequisites"><div class="titlepage"><div><div><h4 class="title"><a id="docbook.prereq"/>Prerequisites</h4></div></div></div><div class="table"><a id="id512798"/><p class="title"><strong>TableÂ B.3.Â Docbook Prerequisites</strong></p><div class="table-contents"><table summary="Docbook Prerequisites" border="1"><colgroup><col style="text-align: center" class="c1"/><col style="text-align: center" class="c2"/><col style="text-align: center" class="c3"/></colgroup><thead><tr><th style="text-align: center">Tool</th><th style="text-align: center">Version</th><th style="text-align: center">Required By</th></tr></thead><tbody><tr><td style="text-align: center">docbook5-style-xsl</td><td style="text-align: center">1.76.1</td><td style="text-align: center">all</td></tr><tr><td style="text-align: center">xsltproc</td><td style="text-align: center">1.1.26</td><td style="text-align: center">all</td></tr><tr><td style="text-align: center">xmllint</td><td style="text-align: center">2.7.7</td><td style="text-align: center">validation</td></tr><tr><td style="text-align: center">dblatex</td><td style="text-align: center">0.3</td><td style="text-align: center">pdf output</td></tr><tr><td style="text-align: center">pdflatex</td><td style="text-align: center">2007-59</td><td style="text-align: center">pdf output</td></tr><tr><td style="text-align: center">docbook2X</td><td style="text-align: center">0.8.8</td><td style="text-align: center">info output</td></tr></tbody></table></div></div><br class="table-break"/><p> Editing the DocBook sources requires an XML editor. Many exist: some notable options include <span class="command"><strong>emacs</strong></span>, <span class="application">Kate</span>, @@ -419,11 +419,11 @@ make <code class="literal">XSL_STYLE_DIR="/usr/share/xml/docbook/stylesheet/nwal <a class="link" href="http://www.docbook.org/tdg/en/html/part2.html">online</a>. An incomplete reference for HTML to Docbook conversion is detailed in the table below. - </p><div class="table"><a id="id533030"/><p class="title"><strong>TableÂ B.4.Â HTML to Docbook XML Markup Comparison</strong></p><div class="table-contents"><table summary="HTML to Docbook XML Markup Comparison" border="1"><colgroup><col style="text-align: left" class="c1"/><col style="text-align: left" class="c2"/></colgroup><thead><tr><th style="text-align: left">HTML</th><th style="text-align: left">Docbook</th></tr></thead><tbody><tr><td style="text-align: left"><p></td><td style="text-align: left"><para></td></tr><tr><td style="text-align: left"><pre></td><td style="text-align: left"><computeroutput>, <programlisting>, + </p><div class="table"><a id="id513276"/><p class="title"><strong>TableÂ B.4.Â HTML to Docbook XML Markup Comparison</strong></p><div class="table-contents"><table summary="HTML to Docbook XML Markup Comparison" border="1"><colgroup><col style="text-align: left" class="c1"/><col style="text-align: left" class="c2"/></colgroup><thead><tr><th style="text-align: left">HTML</th><th style="text-align: left">Docbook</th></tr></thead><tbody><tr><td style="text-align: left"><p></td><td style="text-align: left"><para></td></tr><tr><td style="text-align: left"><pre></td><td style="text-align: left"><computeroutput>, <programlisting>, <literallayout></td></tr><tr><td style="text-align: left"><ul></td><td style="text-align: left"><itemizedlist></td></tr><tr><td style="text-align: left"><ol></td><td style="text-align: left"><orderedlist></td></tr><tr><td style="text-align: left"><il></td><td style="text-align: left"><listitem></td></tr><tr><td style="text-align: left"><dl></td><td style="text-align: left"><variablelist></td></tr><tr><td style="text-align: left"><dt></td><td style="text-align: left"><term></td></tr><tr><td style="text-align: left"><dd></td><td style="text-align: left"><listitem></td></tr><tr><td style="text-align: left"><a href=""></td><td style="text-align: left"><ulink url=""></td></tr><tr><td style="text-align: left"><code></td><td style="text-align: left"><literal>, <programlisting></td></tr><tr><td style="text-align: left"><strong></td><td style="text-align: left"><emphasis></td></tr><tr><td style="text-align: left"><em></td><td style="text-align: left"><emphasis></td></tr><tr><td style="text-align: left">"</td><td style="text-align: left"><quote></td></tr></tbody></table></div></div><br class="table-break"/><p> And examples of detailed markup for which there are no real HTML equivalents are listed in the table below. -</p><div class="table"><a id="id533231"/><p class="title"><strong>TableÂ B.5.Â Docbook XML Element Use</strong></p><div class="table-contents"><table summary="Docbook XML Element Use" border="1"><colgroup><col style="text-align: left" class="c1"/><col style="text-align: left" class="c2"/></colgroup><thead><tr><th style="text-align: left">Element</th><th style="text-align: left">Use</th></tr></thead><tbody><tr><td style="text-align: left"><structname></td><td style="text-align: left"><structname>char_traits</structname></td></tr><tr><td style="text-align: left"><classname></td><td style="text-align: left"><classname>string</classname></td></tr><tr><td style="text-align: left"><function></td><td style="text-align: left"> +</p><div class="table"><a id="id513477"/><p class="title"><strong>TableÂ B.5.Â Docbook XML Element Use</strong></p><div class="table-contents"><table summary="Docbook XML Element Use" border="1"><colgroup><col style="text-align: left" class="c1"/><col style="text-align: left" class="c2"/></colgroup><thead><tr><th style="text-align: left">Element</th><th style="text-align: left">Use</th></tr></thead><tbody><tr><td style="text-align: left"><structname></td><td style="text-align: left"><structname>char_traits</structname></td></tr><tr><td style="text-align: left"><classname></td><td style="text-align: left"><classname>string</classname></td></tr><tr><td style="text-align: left"><function></td><td style="text-align: left"> <p><function>clear()</function></p> <p><function>fs.clear()</function></p> </td></tr><tr><td style="text-align: left"><type></td><td style="text-align: left"><type>long long</type></td></tr><tr><td style="text-align: left"><varname></td><td style="text-align: left"><varname>fs</varname></td></tr><tr><td style="text-align: left"><literal></td><td style="text-align: left"> diff --git a/libstdc++-v3/doc/html/manual/extensions.html b/libstdc++-v3/doc/html/manual/extensions.html index ef3d6abcfb5..bd0d864e11c 100644 --- a/libstdc++-v3/doc/html/manual/extensions.html +++ b/libstdc++-v3/doc/html/manual/extensions.html @@ -5,7 +5,7 @@ </th></tr><tr><td align="left"><a accesskey="p" href="io_and_c.html">Prev</a>Â </td><th width="60%" align="center">The GNU C++ Library Manual</th><td align="right">Â <a accesskey="n" href="bk01pt03pr01.html">Next</a></td></tr></table><hr/></div><div class="part" title="PartÂ III.Â Extensions"><div class="titlepage"><div><div><h1 class="title"><a id="manual.ext"/>PartÂ III.Â Extensions - <a id="id484410" class="indexterm"/> + <a id="id464656" class="indexterm"/> </h1></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="preface"><a href="bk01pt03pr01.html"/></span></dt><dt><span class="chapter"><a href="ext_compile_checks.html">16. Compile Time Checks</a></span></dt><dt><span class="chapter"><a href="debug_mode.html">17. Debug Mode</a></span></dt><dd><dl><dt><span class="section"><a href="debug_mode.html#manual.ext.debug_mode.intro">Intro</a></span></dt><dt><span class="section"><a href="bk01pt03ch17s02.html">Semantics</a></span></dt><dt><span class="section"><a href="bk01pt03ch17s03.html">Using</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch17s03.html#debug_mode.using.mode">Using the Debug Mode</a></span></dt><dt><span class="section"><a href="bk01pt03ch17s03.html#debug_mode.using.specific">Using a Specific Debug Container</a></span></dt></dl></dd><dt><span class="section"><a href="bk01pt03ch17s04.html">Design</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch17s04.html#debug_mode.design.goals">Goals</a></span></dt><dt><span class="section"><a href="bk01pt03ch17s04.html#debug_mode.design.methods">Methods</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch17s04.html#debug_mode.design.methods.wrappers">The Wrapper Model</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch17s04.html#debug_mode.design.methods.safe_iter">Safe Iterators</a></span></dt><dt><span class="section"><a href="bk01pt03ch17s04.html#debug_mode.design.methods.safe_seq">Safe Sequences (Containers)</a></span></dt></dl></dd><dt><span class="section"><a href="bk01pt03ch17s04.html#debug_mode.design.methods.precond">Precondition Checking</a></span></dt><dt><span class="section"><a href="bk01pt03ch17s04.html#debug_mode.design.methods.coexistence">Release- and debug-mode coexistence</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch17s04.html#methods.coexistence.compile">Compile-time coexistence of release- and debug-mode components</a></span></dt><dt><span class="section"><a href="bk01pt03ch17s04.html#methods.coexistence.link">Link- and run-time coexistence of release- and debug-mode components</a></span></dt><dt><span class="section"><a href="bk01pt03ch17s04.html#methods.coexistence.alt">Alternatives for Coexistence</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="bk01pt03ch17s04.html#debug_mode.design.other">Other Implementations</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="parallel_mode.html">18. Parallel Mode</a></span></dt><dd><dl><dt><span class="section"><a href="parallel_mode.html#manual.ext.parallel_mode.intro">Intro</a></span></dt><dt><span class="section"><a href="bk01pt03ch18s02.html">Semantics</a></span></dt><dt><span class="section"><a href="bk01pt03ch18s03.html">Using</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch18s03.html#parallel_mode.using.prereq_flags">Prerequisite Compiler Flags</a></span></dt><dt><span class="section"><a href="bk01pt03ch18s03.html#parallel_mode.using.parallel_mode">Using Parallel Mode</a></span></dt><dt><span class="section"><a href="bk01pt03ch18s03.html#parallel_mode.using.specific">Using Specific Parallel Components</a></span></dt></dl></dd><dt><span class="section"><a href="bk01pt03ch18s04.html">Design</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch18s04.html#parallel_mode.design.intro">Interface Basics</a></span></dt><dt><span class="section"><a href="bk01pt03ch18s04.html#parallel_mode.design.tuning">Configuration and Tuning</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch18s04.html#parallel_mode.design.tuning.omp">Setting up the OpenMP Environment</a></span></dt><dt><span class="section"><a href="bk01pt03ch18s04.html#parallel_mode.design.tuning.compile">Compile Time Switches</a></span></dt><dt><span class="section"><a href="bk01pt03ch18s04.html#parallel_mode.design.tuning.settings">Run Time Settings and Defaults</a></span></dt></dl></dd><dt><span class="section"><a href="bk01pt03ch18s04.html#parallel_mode.design.impl">Implementation Namespaces</a></span></dt></dl></dd><dt><span class="section"><a href="bk01pt03ch18s05.html">Testing</a></span></dt><dt><span class="bibliography"><a href="parallel_mode.html#parallel_mode.biblio">Bibliography</a></span></dt></dl></dd><dt><span class="chapter"><a href="profile_mode.html">19. Profile Mode</a></span></dt><dd><dl><dt><span class="section"><a href="profile_mode.html#manual.ext.profile_mode.intro">Intro</a></span></dt><dd><dl><dt><span class="section"><a href="profile_mode.html#manual.ext.profile_mode.using">Using the Profile Mode</a></span></dt><dt><span class="section"><a href="profile_mode.html#manual.ext.profile_mode.tuning">Tuning the Profile Mode</a></span></dt></dl></dd><dt><span class="section"><a href="bk01pt03ch19s02.html">Design</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch19s02.html#manual.ext.profile_mode.design.wrapper">Wrapper Model</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s02.html#manual.ext.profile_mode.design.instrumentation">Instrumentation</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s02.html#manual.ext.profile_mode.design.rtlib">Run Time Behavior</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s02.html#manual.ext.profile_mode.design.analysis">Analysis and Diagnostics</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s02.html#manual.ext.profile_mode.design.cost-model">Cost Model</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s02.html#manual.ext.profile_mode.design.reports">Reports</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s02.html#manual.ext.profile_mode.design.testing">Testing</a></span></dt></dl></dd><dt><span class="section"><a href="bk01pt03ch19s03.html">Extensions for Custom Containers</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s04.html">Empirical Cost Model</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s05.html">Implementation Issues</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch19s05.html#manual.ext.profile_mode.implementation.stack">Stack Traces</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s05.html#manual.ext.profile_mode.implementation.symbols">Symbolization of Instruction Addresses</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s05.html#manual.ext.profile_mode.implementation.concurrency">Concurrency</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s05.html#manual.ext.profile_mode.implementation.stdlib-in-proflib">Using the Standard Library in the Instrumentation Implementation</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s05.html#manual.ext.profile_mode.implementation.malloc-hooks">Malloc Hooks</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s05.html#manual.ext.profile_mode.implementation.construction-destruction">Construction and Destruction of Global Objects</a></span></dt></dl></dd><dt><span class="section"><a href="bk01pt03ch19s06.html">Developer Information</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch19s06.html#manual.ext.profile_mode.developer.bigpic">Big Picture</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s06.html#manual.ext.profile_mode.developer.howto">How To Add A Diagnostic</a></span></dt></dl></dd><dt><span class="section"><a href="bk01pt03ch19s07.html">Diagnostics</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.template">Diagnostic Template</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.containers">Containers</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.hashtable_too_small">Hashtable Too Small</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.hashtable_too_large">Hashtable Too Large</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.inefficient_hash">Inefficient Hash</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.vector_too_small">Vector Too Small</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.vector_too_large">Vector Too Large</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.vector_to_hashtable">Vector to Hashtable</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.hashtable_to_vector">Hashtable to Vector</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.vector_to_list">Vector to List</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.list_to_vector">List to Vector</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.list_to_slist">List to Forward List (Slist)</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.assoc_ord_to_unord">Ordered to Unordered Associative Container</a></span></dt></dl></dd><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.algorithms">Algorithms</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.algorithms.sort">Sort Algorithm Performance</a></span></dt></dl></dd><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.locality">Data Locality</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.locality.sw_prefetch">Need Software Prefetch</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.locality.linked">Linked Structure Locality</a></span></dt></dl></dd><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.mthread">Multithreaded Data Access</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.mthread.ddtest">Data Dependence Violations at Container Level</a></span></dt><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.mthread.false_share">False Sharing</a></span></dt></dl></dd><dt><span class="section"><a href="bk01pt03ch19s07.html#manual.ext.profile_mode.analysis.statistics">Statistics</a></span></dt></dl></dd><dt><span class="bibliography"><a href="profile_mode.html#profile_mode.biblio">Bibliography</a></span></dt></dl></dd><dt><span class="chapter"><a href="mt_allocator.html">20. The mt_allocator</a></span></dt><dd><dl><dt><span class="section"><a href="mt_allocator.html#allocator.mt.intro">Intro</a></span></dt><dt><span class="section"><a href="bk01pt03ch20s02.html">Design Issues</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch20s02.html#allocator.mt.overview">Overview</a></span></dt></dl></dd><dt><span class="section"><a href="bk01pt03ch20s03.html">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch20s03.html#allocator.mt.tune">Tunable Parameters</a></span></dt><dt><span class="section"><a href="bk01pt03ch20s03.html#allocator.mt.init">Initialization</a></span></dt><dt><span class="section"><a href="bk01pt03ch20s03.html#allocator.mt.deallocation">Deallocation Notes</a></span></dt></dl></dd><dt><span class="section"><a href="bk01pt03ch20s04.html">Single Thread Example</a></span></dt><dt><span class="section"><a href="bk01pt03ch20s05.html">Multiple Thread Example</a></span></dt></dl></dd><dt><span class="chapter"><a href="bitmap_allocator.html">21. The bitmap_allocator</a></span></dt><dd><dl><dt><span class="section"><a href="bitmap_allocator.html#allocator.bitmap.design">Design</a></span></dt><dt><span class="section"><a href="bk01pt03ch21s02.html">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch21s02.html#bitmap.impl.free_list_store">Free List Store</a></span></dt><dt><span class="section"><a href="bk01pt03ch21s02.html#bitmap.impl.super_block">Super Block</a></span></dt><dt><span class="section"><a href="bk01pt03ch21s02.html#bitmap.impl.super_block_data">Super Block Data Layout</a></span></dt><dt><span class="section"><a href="bk01pt03ch21s02.html#bitmap.impl.max_wasted">Maximum Wasted Percentage</a></span></dt><dt><span class="section"><a href="bk01pt03ch21s02.html#bitmap.impl.allocate"><code class="function">allocate</code></a></span></dt><dt><span class="section"><a href="bk01pt03ch21s02.html#bitmap.impl.deallocate"><code class="function">deallocate</code></a></span></dt><dt><span class="section"><a href="bk01pt03ch21s02.html#bitmap.impl.questions">Questions</a></span></dt><dd><dl><dt><span class="section"><a href="bk01pt03ch21s02.html#bitmap.impl.question.1">1</a></span></dt><dt><span class="section"><a href="bk01pt03ch21s02.html#bitmap.impl.question.2">2</a></span></dt><dt><span class="section"><a href="bk01pt03ch21s02.html#bitmap.impl.question.3">3</a></span></dt></dl></dd><dt><span class="section"><a href="bk01pt03ch21s02.html#bitmap.impl.locality">Locality</a></span></dt><dt><span class="section"><a href="bk01pt03ch21s02.html#bitmap.impl.grow_policy">Overhead and Grow Policy</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="policy_data_structures.html">22. Policy-Based Data Structures</a></span></dt><dd><dl><dt><span class="section"><a href="policy_data_structures.html#pbds.intro">Intro</a></span></dt><dd><dl><dt><span class="section"><a href="policy_data_structures.html#pbds.intro.issues">Performance Issues</a></span></dt><dd><dl><dt><span class="section"><a href="policy_data_structures.html#pbds.intro.issues.associative">Associative</a></span></dt><dt><span class="section"><a href="policy_data_structures.html#pbds.intro.issues.priority_queue">Priority Que</a></span></dt></dl></dd><dt><span class="section"><a href="policy_data_structures.html#pbds.intro.motivation">Goals</a></span></dt><dd><dl><dt><span class="section"><a href="policy_data_structures.html#pbds.intro.motivation.associative">Associative</a></span></dt><dd><dl><dt><span class="section"><a href="policy_data_structures.html#motivation.associative.policy">Policy Choices</a></span></dt><dt><span class="section"><a href="policy_data_structures.html#motivation.associative.underlying">Underlying Data Structures</a></span></dt><dt><span class="section"><a href="policy_data_structures.html#motivation.associative.iterators">Iterators</a></span></dt><dt><span class="section"><a href="policy_data_structures.html#motivation.associative.functions">Functional</a></span></dt></dl></dd><dt><span class="section"><a href="policy_data_structures.html#pbds.intro.motivation.priority_queue">Priority Queues</a></span></dt><dd><dl><dt><span class="section"><a href="policy_data_structures.html#motivation.priority_queue.policy">Policy Choices</a></span></dt><dt><span class="section"><a href="policy_data_structures.html#motivation.priority_queue.underlying">Underlying Data Structures</a></span></dt><dt><span class="section"><a href="policy_data_structures.html#motivation.priority_queue.binary_heap">Binary Heaps</a></span></dt></dl></dd></dl></dd></dl></dd><dt><span class="section"><a href="policy_data_structures_using.html">Using</a></span></dt><dd><dl><dt><span class="section"><a href="policy_data_structures_using.html#pbds.using.prereq">Prerequisites</a></span></dt><dt><span class="section"><a href="policy_data_structures_using.html#pbds.using.organization">Organization</a></span></dt><dt><span class="section"><a href="policy_data_structures_using.html#pbds.using.tutorial">Tutorial</a></span></dt><dd><dl><dt><span class="section"><a href="policy_data_structures_using.html#pbds.using.tutorial.basic">Basic Use</a></span></dt><dt><span class="section"><a href="policy_data_structures_using.html#pbds.using.tutorial.configuring"> Configuring via Template Parameters diff --git a/libstdc++-v3/doc/html/manual/facets.html b/libstdc++-v3/doc/html/manual/facets.html index c394c39e30a..8b588b252ab 100644 --- a/libstdc++-v3/doc/html/manual/facets.html +++ b/libstdc++-v3/doc/html/manual/facets.html @@ -3,7 +3,7 @@ <html xmlns="http://www.w3.org/1999/xhtml"><head><title>Facets
Facets
PrevÂ ChapterÂ 8.Â Localization - Â Next
Facets
ctype
Implementation
Specializations
+
Â Next
Facets
ctype
Implementation
Specializations
For the required specialization codecvt<wchar_t, char, mbstate_t> , conversions are made between the internal character set (always UCS4 on GNU/Linux) and whatever the currently selected locale for the @@ -50,24 +50,24 @@ characters.
Rename abstract base class. See if just smash-overriding is a better approach. Clarify, add sanity to naming. -
Bibliography
+
Bibliography
The GNU C Library - . Roland McGrath. Ulrich Drepper. Copyright Â© 2007 FSF. Chapters 6 Character Set Handling and 7 Locales and Internationalization.
+ . Roland McGrath. Ulrich Drepper. Copyright Â© 2007 FSF. Chapters 6 Character Set Handling and 7 Locales and Internationalization.
Correspondence - . Ulrich Drepper. Copyright Â© 2002 .
+ . Ulrich Drepper. Copyright Â© 2002 .
ISO/IEC 14882:1998 Programming languages - C++ - . Copyright Â© 1998 ISO.
+ . Copyright Â© 1998 ISO.
ISO/IEC 9899:1999 Programming languages - C - . Copyright Â© 1999 ISO.
+ . Copyright Â© 1999 ISO.
The Open Group Base Specifications, Issue 6 (IEEE Std. 1003.1-2004) . Copyright Â© 1999 - The Open Group/The Institute of Electrical and Electronics Engineers, Inc..
+ The Open Group/The Institute of Electrical and Electronics Engineers, Inc..
The C++ Programming Language, Special Edition . Bjarne Stroustrup. Copyright Â© 2000 Addison Wesley, Inc.. Appendix D. Addison Wesley - .
+ .
Standard C++ IOStreams and Locales . Advanced Programmer's Guide and Reference @@ -410,42 +410,42 @@ codecvt usage.
wchar_t/char internal buffers and conversions between internal/external buffers? -
Bibliography
+
Bibliography
The GNU C Library . Roland McGrath. Ulrich Drepper. Copyright Â© 2007 FSF. Chapters 6 Character Set Handling and 7 Locales and Internationalization - .
+ .
Correspondence - . Ulrich Drepper. Copyright Â© 2002 .
+ . Ulrich Drepper. Copyright Â© 2002 .
ISO/IEC 14882:1998 Programming languages - C++ - . Copyright Â© 1998 ISO.
+ . Copyright Â© 1998 ISO.
ISO/IEC 9899:1999 Programming languages - C - . Copyright Â© 1999 ISO.
+ . Copyright Â© 1999 ISO.
System Interface Definitions, Issue 7 (IEEE Std. 1003.1-2008) . Copyright Â© 2008 The Open Group/The Institute of Electrical and Electronics Engineers, Inc. - .
+ .
The C++ Programming Language, Special Edition . Bjarne Stroustrup. Copyright Â© 2000 Addison Wesley, Inc.. Appendix D. Addison Wesley - .
+ .
Standard C++ IOStreams and Locales . Advanced Programmer's Guide and Reference . Angelika Langer. Klaus Kreft. Copyright Â© 2000 Addison Wesley Longman, Inc.. Addison Wesley Longman - .
+ .
A brief description of Normative Addendum 1 - . Clive Feather. Extended Character Sets.
+ . Clive Feather. Extended Character Sets.
The Unicode HOWTO - . Bruno Haible.
+ . Bruno Haible.
UTF-8 and Unicode FAQ for Unix/Linux @@ -690,39 +690,39 @@ void test01() model. As of this writing, it is unknown how to query to see if a specified message catalog exists using the gettext package. -
Bibliography
+
Bibliography
The GNU C Library . Roland McGrath. Ulrich Drepper. Copyright Â© 2007 FSF. Chapters 6 Character Set Handling, and 7 Locales and Internationalization - .
+ .
Correspondence - . Ulrich Drepper. Copyright Â© 2002 .
+ . Ulrich Drepper. Copyright Â© 2002 .
ISO/IEC 14882:1998 Programming languages - C++ - . Copyright Â© 1998 ISO.
+ . Copyright Â© 1998 ISO.
ISO/IEC 9899:1999 Programming languages - C - . Copyright Â© 1999 ISO.
+ . Copyright Â© 1999 ISO.
System Interface Definitions, Issue 7 (IEEE Std. 1003.1-2008) . Copyright Â© 2008 The Open Group/The Institute of Electrical and Electronics Engineers, Inc. - .
+ .
The C++ Programming Language, Special Edition . Bjarne Stroustrup. Copyright Â© 2000 Addison Wesley, Inc.. Appendix D. Addison Wesley - .
+ .
Standard C++ IOStreams and Locales . Advanced Programmer's Guide and Reference . Angelika Langer. Klaus Kreft. Copyright Â© 2000 Addison Wesley Longman, Inc.. Addison Wesley Longman - .
+ .
API Specifications, Java Platform . java.util.Properties, java.text.MessageFormat, java.util.Locale, java.util.ResourceBundle - .
+ .
GNU gettext tools, version 0.10.38, Native Language Support Library and Tools. diff --git a/libstdc++-v3/doc/html/manual/index.html b/libstdc++-v3/doc/html/manual/index.html index 9f9e19c15ac..884552c8336 100644 --- a/libstdc++-v3/doc/html/manual/index.html +++ b/libstdc++-v3/doc/html/manual/index.html @@ -5,7 +5,7 @@
Table of Contents
I. Introduction -
1. Status
Implementation Status
C++ 1998/2003
Implementation Status
Implementation Specific Behavior
C++ 200x
C++ TR1
C++ TR 24733
License
The Code: GPL
The Documentation: GPL, FDL
Bugs
Implementation Bugs
Standard Bugs
2. Setup
Prerequisites
Configure
Make
3. Using
Command Options
Headers
Header Files
Mixing Headers
The C Headers and namespace std
Precompiled Headers
Macros
Namespaces
Available Namespaces
namespace std
Using Namespace Composition
Linking
Almost Nothing
Finding Dynamic or Shared Libraries
Concurrency
Prerequisites
Thread Safety
Atomics
IO
Structure
Defaults
Future
Alternatives
Containers
Exceptions
Exception Safety
Exception Neutrality
Doing without
Compatibility
With C
With POSIX thread cancellation
Debugging Support
Using g++
Debug Versions of Library Binary Files
Memory Leak Hunting
Data Race Hunting
Using gdb
Tracking uncaught exceptions
Debug Mode
Compile Time Checking
Profile-based Performance Analysis
II. +
1. Status
Implementation Status
C++ 1998/2003
Implementation Status
Implementation Specific Behavior
C++ 2011
C++ TR1
C++ TR 24733
License
The Code: GPL
The Documentation: GPL, FDL
Bugs
Implementation Bugs
Standard Bugs
2. Setup
Prerequisites
Configure
Make
3. Using
Command Options
Headers
Header Files
Mixing Headers
The C Headers and namespace std
Precompiled Headers
Macros
Namespaces
Available Namespaces
namespace std
Using Namespace Composition
Linking
Almost Nothing
Finding Dynamic or Shared Libraries
Concurrency
Prerequisites
Thread Safety
Atomics
IO
Structure
Defaults
Future
Alternatives
Containers
Exceptions
Exception Safety
Exception Neutrality
Doing without
Compatibility
With C
With POSIX thread cancellation
Debugging Support
Using g++
Debug Versions of Library Binary Files
Memory Leak Hunting
Data Race Hunting
Using gdb
Tracking uncaught exceptions
Debug Mode
Compile Time Checking
Profile-based Performance Analysis
II. Standard Contents
4. Support @@ -16,13 +16,13 @@
Exceptions
API Reference
Adding Data to exception
Concept Checking
6. Utilities -
Functors
Pairs
Memory
Allocators
Requirements
Design Issues
Implementation
Interface Design
Selecting Default Allocation Policy
Disabling Memory Caching
Using a Specific Allocator
Custom Allocators
Extension Allocators
auto_ptr
Limitations
Use in Containers
shared_ptr
Requirements
Design Issues
Implementation
Class Hierarchy
Thread Safety
Selecting Lock Policy
Dual C++0x and TR1 Implementation
Related functions and classes
Use
Examples
Unresolved Issues
Acknowledgments
Traits
7. +
Functors
Pairs
Memory
Allocators
Requirements
Design Issues
Implementation
Interface Design
Selecting Default Allocation Policy
Disabling Memory Caching
Using a Specific Allocator
Custom Allocators
Extension Allocators
auto_ptr
Limitations
Use in Containers
shared_ptr
Requirements
Design Issues
Implementation
Class Hierarchy
Thread Safety
Selecting Lock Policy
Dual C++11 and TR1 Implementation
Related functions and classes
Use
Examples
Unresolved Issues
Acknowledgments
Traits
7. Strings
String Classes
Simple Transformations
Case Sensitivity
Arbitrary Character Types
Tokenizing
Shrink to Fit
CString (MFC)
8. Localization -
Locales
locale
Requirements
Design
Implementation
Interacting with "C" locales
Future
Facets
ctype
Implementation
Specializations
Future
codecvt
Requirements
Design
wchar_t Size
Support for Unicode
Other Issues
Implementation
Use
Future
messages
Requirements
Design
Implementation
Models
The GNU Model
Use
Future
9. +
Locales
locale
Requirements
Design
Implementation
Interacting with "C" locales
Future
Facets
ctype
Implementation
Specializations
Future
codecvt
Requirements
Design
wchar_t Size
Support for Unicode
Other Issues
Implementation
Use
Future
messages
Requirements
Design
Implementation
Models
The GNU Model
Use
Future
9. Containers
Sequences
list
list::size() is O(n)
vector
Space Overhead Management
Associative
Insertion Hints
bitset
Size Variable
Type String
Interacting with C
Containers vs. Arrays
10. @@ -125,40 +125,40 @@
Overview
Existing tests
-C++0x Requirements Test Sequence Descriptions -
ABI Policy and Guidelines
The C++ Interface
Versioning
Goals
History
Prerequisites
Configuring
Checking Active
Allowed Changes
Prohibited Changes
Implementation
Testing
Single ABI Testing
Multiple ABI Testing
Outstanding Issues
API Evolution and Deprecation History
3.0
3.1
3.2
3.3
3.4
4.0
4.1
4.2
4.3
4.4
4.5
Backwards Compatibility
First
No ios_base
No cout in ostream.h, no cin in istream.h
Second
Namespace std:: not supported
Illegal iterator usage
isspace from cctype is a macro -
No vector::at, deque::at, string::at
No std::char_traits<char>::eof
No string::clear
+C++11 Requirements Test Sequence Descriptions +
ABI Policy and Guidelines
The C++ Interface
Versioning
Goals
History
Prerequisites
Configuring
Checking Active
Allowed Changes
Prohibited Changes
Implementation
Testing
Single ABI Testing
Multiple ABI Testing
Outstanding Issues
API Evolution and Deprecation History
3.0
3.1
3.2
3.3
3.4
4.0
4.1
4.2
4.3
4.4
4.5
Backwards Compatibility
First
No ios_base
No cout in ostream.h, no cin in istream.h
Second
Namespace std:: not supported
Illegal iterator usage
isspace from cctype is a macro +
No vector::at, deque::at, string::at
No std::char_traits<char>::eof
No string::clear
Removal of ostream::form and istream::scan extensions -
No basic_stringbuf, basic_stringstream
Little or no wide character support
No templatized iostreams
Thread safety issues
Third
Pre-ISO headers moved to backwards or removed
Extension headers hash_map, hash_set moved to ext or backwards
No ios::nocreate/ios::noreplace. -
+
No basic_stringbuf, basic_stringstream
Little or no wide character support
No templatized iostreams
Thread safety issues
Third
Pre-ISO headers moved to backwards or removed
Extension headers hash_map, hash_set moved to ext or backwards
No ios::nocreate/ios::noreplace. +
No stream::attach(int fd) -
+
Support for C++98 dialect. -
+
Support for C++TR1 dialect. -
-Support for C++0x dialect. -
+
+Support for C++11 dialect. +
Container::iterator_type is not necessarily Container::value_type*
C. Free Software Needs Free Documentation
D. GNU General Public License version 3 -
E. GNU Free Documentation License
List of Figures
22.1. Node Invariants
22.2. Underlying Associative Data Structures
22.3. Range Iteration in Different Data Structures
22.4. Point Iteration in Hash Data Structures
22.5. Effect of erase in different underlying data structures
22.6. Underlying Priority Queue Data Structures
22.7. Exception Hierarchy
22.8. Non-unique Mapping Standard Containers
22.9. +
E. GNU Free Documentation License
List of Figures
22.1. Node Invariants
22.2. Underlying Associative Data Structures
22.3. Range Iteration in Different Data Structures
22.4. Point Iteration in Hash Data Structures
22.5. Effect of erase in different underlying data structures
22.6. Underlying Priority Queue Data Structures
22.7. Exception Hierarchy
22.8. Non-unique Mapping Standard Containers
22.9. Effect of embedded lists in std::multimap -
22.10. Non-unique Mapping Containers
22.11. Point Iterator Hierarchy
22.12. Invalidation Guarantee Tags Hierarchy
22.13. Container Tag Hierarchy
22.14. Hash functions, ranged-hash functions, and - range-hashing functions
22.15. Insert hash sequence diagram
22.16. Insert hash sequence diagram with a null policy
22.17. Hash policy class diagram
22.18. Balls and bins
22.19. Insert resize sequence diagram
22.20. Standard resize policy trigger sequence - diagram
22.21. Standard resize policy size sequence - diagram
22.22. Tree node invariants
22.23. Tree node invalidation
22.24. A tree and its update policy
22.25. Restoring node invariants
22.26. Insert update sequence
22.27. Useless update path
22.28. A PATRICIA trie
22.29. A trie and its update policy
22.30. A simple list
22.31. The counter algorithm
22.32. Underlying Priority-Queue Data-Structures.
22.33. Priority-Queue Data-Structure Tags.
B.1. Configure and Build File Dependencies
List of Tables
1.1. C++ 1998/2003 Implementation Status
1.2. C++ 200x Implementation Status
1.3. C++ TR1 Implementation Status
1.4. C++ TR 24733 Implementation Status
3.1. C++ Command Options
3.2. C++ 1998 Library Headers
3.3. C++ 1998 Library Headers for C Library Facilities
3.4. C++ 200x Library Headers
3.5. C++ 200x Library Headers for C Library Facilities
3.6. C++ TR 1 Library Headers
3.7. C++ TR 1 Library Headers for C Library Facilities
3.8. C++ TR 24733 Decimal Floating-Point Header
3.9. C++ ABI Headers
3.10. Extension Headers
3.11. Extension Debug Headers
3.12. Extension Profile Headers
3.13. Extension Parallel Headers
17.1. Debugging Containers
17.2. Debugging Containers C++0x
18.1. Parallel Algorithms
19.1. Profile Code Location
19.2. Profile Diagnostics
21.1. Bitmap Allocator Memory Map
B.1. Doxygen Prerequisites
B.2. HTML to Doxygen Markup Comparison
B.3. Docbook Prerequisites
B.4. HTML to Docbook XML Markup Comparison
B.5. Docbook XML Element Use
B.6. Extension Allocators
B.7. Extension Allocators Continued
List of Equations
22.1. Ranged Hash Function
22.2. Range-Hashing, Division Method
22.3. Division via Prime Modulo
22.4. Division via Bit Mask
22.5. +
22.10. Non-unique Mapping Containers
22.11. Point Iterator Hierarchy
22.12. Invalidation Guarantee Tags Hierarchy
22.13. Container Tag Hierarchy
22.14. Hash functions, ranged-hash functions, and + range-hashing functions
22.15. Insert hash sequence diagram
22.16. Insert hash sequence diagram with a null policy
22.17. Hash policy class diagram
22.18. Balls and bins
22.19. Insert resize sequence diagram
22.20. Standard resize policy trigger sequence + diagram
22.21. Standard resize policy size sequence + diagram
22.22. Tree node invariants
22.23. Tree node invalidation
22.24. A tree and its update policy
22.25. Restoring node invariants
22.26. Insert update sequence
22.27. Useless update path
22.28. A PATRICIA trie
22.29. A trie and its update policy
22.30. A simple list
22.31. The counter algorithm
22.32. Underlying Priority-Queue Data-Structures.
22.33. Priority-Queue Data-Structure Tags.
B.1. Configure and Build File Dependencies
List of Tables
1.1. C++ 1998/2003 Implementation Status
1.2. C++ 2011 Implementation Status
1.3. C++ TR1 Implementation Status
1.4. C++ TR 24733 Implementation Status
3.1. C++ Command Options
3.2. C++ 1998 Library Headers
3.3. C++ 1998 Library Headers for C Library Facilities
3.4. C++ 2011 Library Headers
3.5. C++ 2011 Library Headers for C Library Facilities
3.6. C++ TR 1 Library Headers
3.7. C++ TR 1 Library Headers for C Library Facilities
3.8. C++ TR 24733 Decimal Floating-Point Header
3.9. C++ ABI Headers
3.10. Extension Headers
3.11. Extension Debug Headers
3.12. Extension Profile Headers
3.13. Extension Parallel Headers
17.1. Debugging Containers
17.2. Debugging Containers C++11
18.1. Parallel Algorithms
19.1. Profile Code Location
19.2. Profile Diagnostics
21.1. Bitmap Allocator Memory Map
B.1. Doxygen Prerequisites
B.2. HTML to Doxygen Markup Comparison
B.3. Docbook Prerequisites
B.4. HTML to Docbook XML Markup Comparison
B.5. Docbook XML Element Use
B.6. Extension Allocators
B.7. Extension Allocators Continued
List of Equations
22.1. Ranged Hash Function
22.2. Range-Hashing, Division Method
22.3. Division via Prime Modulo
22.4. Division via Bit Mask
22.5. A Standard String Hash Function -
22.6. +
22.6. Only k String DNA Hash -
22.7. +
22.7. Probability of Probe Sequence of Length k -
22.8. +
22.8. Probability Probe Sequence in Some Bin
PrevÂ Â Â Next
The GNU C++ LibraryÂ Home Â PartÂ I.Â Introduction diff --git a/libstdc++-v3/doc/html/manual/intro.html b/libstdc++-v3/doc/html/manual/intro.html index 821b1696b06..b8b0459be4d 100644 --- a/libstdc++-v3/doc/html/manual/intro.html +++ b/libstdc++-v3/doc/html/manual/intro.html @@ -5,5 +5,5 @@
PrevÂ The GNU C++ Library Manual Â Next
PartÂ I.Â Introduction - -
Table of Contents
1. Status
Implementation Status
C++ 1998/2003
Implementation Status
Implementation Specific Behavior
C++ 200x
C++ TR1
C++ TR 24733
License
The Code: GPL
The Documentation: GPL, FDL
Bugs
Implementation Bugs
Standard Bugs
2. Setup
Prerequisites
Configure
Make
3. Using
Command Options
Headers
Header Files
Mixing Headers
The C Headers and namespace std
Precompiled Headers
Macros
Namespaces
Available Namespaces
namespace std
Using Namespace Composition
Linking
Almost Nothing
Finding Dynamic or Shared Libraries
Concurrency
Prerequisites
Thread Safety
Atomics
IO
Structure
Defaults
Future
Alternatives
Containers
Exceptions
Exception Safety
Exception Neutrality
Doing without
Compatibility
With C
With POSIX thread cancellation
Debugging Support
Using g++
Debug Versions of Library Binary Files
Memory Leak Hunting
Data Race Hunting
Using gdb
Tracking uncaught exceptions
Debug Mode
Compile Time Checking
Profile-based Performance Analysis
PrevÂ Up Â Next
The GNU C++ Library ManualÂ Home Â ChapterÂ 1.Â Status
+ +
Table of Contents
1. Status
Implementation Status
C++ 1998/2003
Implementation Status
Implementation Specific Behavior
C++ 2011
C++ TR1
C++ TR 24733
License
The Code: GPL
The Documentation: GPL, FDL
Bugs
Implementation Bugs
Standard Bugs
2. Setup
Prerequisites
Configure
Make
3. Using
Command Options
Headers
Header Files
Mixing Headers
The C Headers and namespace std
Precompiled Headers
Macros
Namespaces
Available Namespaces
namespace std
Using Namespace Composition
Linking
Almost Nothing
Finding Dynamic or Shared Libraries
Concurrency
Prerequisites
Thread Safety
Atomics
IO
Structure
Defaults
Future
Alternatives
Containers
Exceptions
Exception Safety
Exception Neutrality
Doing without
Compatibility
With C
With POSIX thread cancellation
Debugging Support
Using g++
Debug Versions of Library Binary Files
Memory Leak Hunting
Data Race Hunting
Using gdb
Tracking uncaught exceptions
Debug Mode
Compile Time Checking
Profile-based Performance Analysis
PrevÂ Up Â Next
The GNU C++ Library ManualÂ Home Â ChapterÂ 1.Â Status
diff --git a/libstdc++-v3/doc/html/manual/io.html b/libstdc++-v3/doc/html/manual/io.html index 578c8131a13..e424c2dc28a 100644 --- a/libstdc++-v3/doc/html/manual/io.html +++ b/libstdc++-v3/doc/html/manual/io.html @@ -7,7 +7,7 @@ Standard Contents Â Next
ChapterÂ 13.Â Input and Output - +
Table of Contents
Iostream Objects
Stream Buffers
Derived streambuf Classes
Buffering
Memory Based Streams
Compatibility With strstream
File Based Streams
Copying a File
Binary Input and Output
Interacting with C
Using FILE* and file descriptors
Performance
Iostream Objects
To minimize the time you have to wait on the compiler, it's good to only include the headers you really need. Many people simply include <iostream> when they don't need to -- and that can penalize diff --git a/libstdc++-v3/doc/html/manual/iterators.html b/libstdc++-v3/doc/html/manual/iterators.html index 5187a6b1370..b6bca505920 100644 --- a/libstdc++-v3/doc/html/manual/iterators.html +++ b/libstdc++-v3/doc/html/manual/iterators.html @@ -7,7 +7,7 @@ Standard Contents
Â Next
ChapterÂ 10.Â Iterators - +
Table of Contents
Predefined
Iterators vs. Pointers
One Past the End
Predefined
Iterators vs. Pointers
The following FAQ entry points out that diff --git a/libstdc++-v3/doc/html/manual/localization.html b/libstdc++-v3/doc/html/manual/localization.html index 4fad79f1fec..978537d6df3 100644 --- a/libstdc++-v3/doc/html/manual/localization.html +++ b/libstdc++-v3/doc/html/manual/localization.html @@ -7,8 +7,8 @@ Standard Contents Â Next
ChapterÂ 8.Â Localization - -
Table of Contents
Locales
locale
Requirements
Design
Implementation
Interacting with "C" locales
Future
Facets
ctype
Implementation
Specializations
Future
codecvt
Requirements
Design
wchar_t Size
Support for Unicode
Other Issues
Implementation
Use
Future
messages
Requirements
Design
Implementation
Models
The GNU Model
Use
Future
Locales
locale
+ +
Table of Contents
Locales
locale
Requirements
Design
Implementation
Interacting with "C" locales
Future
Facets
ctype
Implementation
Specializations
Future
codecvt
Requirements
Design
wchar_t Size
Support for Unicode
Other Issues
Implementation
Use
Future
messages
Requirements
Design
Implementation
Models
The GNU Model
Use
Future
Locales
locale
Describes the basic locale object, including nested classes id, facet, and the reference-counted implementation object, class _Impl. @@ -403,29 +403,29 @@ global locale" (emphasis Paolo), that is: What should non-required facet instantiations do? If the generic implementation is provided, then how to end-users provide specializations? -
Bibliography
+
Bibliography
The GNU C Library . Roland McGrath. Ulrich Drepper. Copyright Â© 2007 FSF. Chapters 6 Character Set Handling and 7 Locales and Internationalization - .
+ .
Correspondence - . Ulrich Drepper. Copyright Â© 2002 .
+ . Ulrich Drepper. Copyright Â© 2002 .
ISO/IEC 14882:1998 Programming languages - C++ - . Copyright Â© 1998 ISO.
+ . Copyright Â© 1998 ISO.
ISO/IEC 9899:1999 Programming languages - C - . Copyright Â© 1999 ISO.
+ . Copyright Â© 1999 ISO.
System Interface Definitions, Issue 7 (IEEE Std. 1003.1-2008) . Copyright Â© 2008 The Open Group/The Institute of Electrical and Electronics Engineers, Inc. - .
+ .
The C++ Programming Language, Special Edition . Bjarne Stroustrup. Copyright Â© 2000 Addison Wesley, Inc.. Appendix D. Addison Wesley - .
+ .
Standard C++ IOStreams and Locales . Advanced Programmer's Guide and Reference diff --git a/libstdc++-v3/doc/html/manual/memory.html b/libstdc++-v3/doc/html/manual/memory.html index 3aa2f8b17ce..e0a7e163005 100644 --- a/libstdc++-v3/doc/html/manual/memory.html +++ b/libstdc++-v3/doc/html/manual/memory.html @@ -93,7 +93,7 @@ or loading and unloading shared objects in memory. As such, using caching allocators on systems that do not support abi::__cxa_atexit is not recommended. -
Implementation
Interface Design
+
Implementation
Interface Design
The only allocator interface that is supported is the standard C++ interface. As such, all STL containers have been adjusted, and all external allocators have @@ -106,7 +106,7 @@
The base class that allocator is derived from may not be user-configurable. -
Selecting Default Allocation Policy
+
Selecting Default Allocation Policy
It's difficult to pick an allocation strategy that will provide maximum utility, without excessively penalizing some behavior. In fact, it's difficult just deciding which typical actions to measure @@ -143,7 +143,7 @@ The current default choice for allocator is __gnu_cxx::new_allocator. -
Disabling Memory Caching
+
Disabling Memory Caching
In use, allocator may allocate and deallocate using implementation-specified strategies and heuristics. Because of this, every call to an allocator object's @@ -308,33 +308,33 @@ A high-performance allocator that uses a bit-map to keep track of the used and unused memory locations. It has its own documentation, found here. -
Bibliography
+
Bibliography
ISO/IEC 14882:1998 Programming languages - C++ . isoc++_1998 - 20.4 Memory.
+ 20.4 Memory.
The Standard Librarian: What Are Allocators Good For? . Matt Austern. C/C++ Users Journal - .
+ .
The Hoard Memory Allocator - . Emery Berger.
+ . Emery Berger.
Reconsidering Custom Memory Allocation - . Emery Berger. Ben Zorn. Kathryn McKinley. Copyright Â© 2002 OOPSLA.
+ . Emery Berger. Ben Zorn. Kathryn McKinley. Copyright Â© 2002 OOPSLA.
Allocator Types . Klaus Kreft. Angelika Langer. C/C++ Users Journal - .
The C++ Programming Language. Bjarne Stroustrup. Copyright Â© 2000 . 19.4 Allocators. + .
The C++ Programming Language. Bjarne Stroustrup. Copyright Â© 2000 . 19.4 Allocators. Addison Wesley - .
Yalloc: A Recycling C++ Allocator. Felix Yen.
auto_ptr
Limitations
Explaining all of the fun and delicious things that can + .
Yalloc: A Recycling C++ Allocator. Felix Yen.
auto_ptr
Limitations
Explaining all of the fun and delicious things that can happen with misuse of the auto_ptr class template (called AP here) would take some time. Suffice it to say that the use of AP @@ -429,12 +429,6 @@ and implements shared ownership semantics. The standard deliberately doesn't require a reference-counted implementation, allowing other techniques such as a circular-linked-list. -
- At the time of writing the C++0x working paper doesn't mention how - threads affect shared_ptr, but it is likely to follow the existing - practice set by boost::shared_ptr. The - shared_ptr in libstdc++ is derived from Boost's, so the same rules - apply.

Design Issues
The shared_ptr code is kindly donated to GCC by the Boost @@ -450,7 +444,7 @@ drops to zero. Derived classes override those functions to destroy resources in a context where the correct dynamic type is known. This is an application of the technique known as type erasure. -
Implementation
Class Hierarchy
+
Implementation
Class Hierarchy
A shared_ptr<T> contains a pointer of type T* and an object of type __shared_count. The shared_count contains a @@ -492,11 +486,11 @@ be forwarded to Tp's constructor. Unlike the other _Sp_counted_* classes, this one is parameterized on the type of object, not the type of pointer; this is purely a convenience that simplifies the implementation slightly. -
Thread Safety
-C++0x-only features are: rvalue-ref/move support, allocator support, +
Thread Safety
+C++11-only features are: rvalue-ref/move support, allocator support, aliasing constructor, make_shared & allocate_shared. Additionally, the constructors taking auto_ptr parameters are -deprecated in C++0x mode. +deprecated in C++11 mode.
The Thread @@ -542,7 +536,7 @@ compiler, standard library, platform etc. For the version of shared_ptr in libstdc++ the compiler and library are fixed, which makes things much simpler: we have an atomic CAS or we don't, see Lock Policy below for details. -
Selecting Lock Policy
+
Selecting Lock Policy

There is a single _Sp_counted_base class, which is a template parameterized on the enum @@ -583,30 +577,30 @@ used when libstdc++ is built without --enable-threadsext/atomicity.h, which detect if the program is multi-threaded. If only one thread of execution exists in the program then less expensive non-atomic operations are used. -
Dual C++0x and TR1 Implementation
-The interface of tr1::shared_ptr was extended for C++0x +
Dual C++11 and TR1 Implementation
+The interface of tr1::shared_ptr was extended for C++11 with support for rvalue-references and the other features from N2351. The _Sp_counted_base base class is implemented in tr1/boost_sp_shared_count.h and is common to the TR1 -and C++0x versions of shared_ptr. +and C++11 versions of shared_ptr.
The classes derived from _Sp_counted_base (see Class Hierarchy -above) and __shared_count are implemented separately for C++0x +above) and __shared_count are implemented separately for C++11 and TR1, in bits/shared_ptr.h and tr1/shared_ptr.h respectively.
The TR1 implementation is considered relatively stable, so is unlikely to change unless bug fixes require it. If the code that is common to both -C++0x and TR1 modes needs to diverge further then it might be necessary to +C++11 and TR1 versions needs to diverge further then it might be necessary to duplicate _Sp_counted_base and only make changes to -the C++0x version. -
Related functions and classes
dynamic_pointer_cast, static_pointer_cast, +the C++11 version. +
Related functions and classes
dynamic_pointer_cast, static_pointer_cast, const_pointer_cast
As noted in N2351, these functions can be implemented non-intrusively using the alias constructor. However the aliasing constructor is only available -in C++0x mode, so in TR1 mode these casts rely on three non-standard +in C++11 mode, so in TR1 mode these casts rely on three non-standard constructors in shared_ptr and __shared_ptr. -In C++0x mode these constructors and the related tag types are not needed. +In C++11 mode these constructors and the related tag types are not needed.
enable_shared_from_this
The clever overload to detect a base class of type enable_shared_from_this comes straight from Boost. @@ -633,15 +627,15 @@ is called. Users should not try to use this. As well as the extra constructors, this implementation also needs some members of _Sp_counted_deleter to be protected where they could otherwise be private. -
Use
Examples
+
Use
Examples
Examples of use can be found in the testsuite, under testsuite/tr1/2_general_utilities/shared_ptr, testsuite/20_util/shared_ptr and testsuite/20_util/weak_ptr. -
Unresolved Issues
+
Unresolved Issues
The shared_ptr atomic access - clause in the C++0x working draft is not implemented in GCC. + clause in the C++11 standard is not implemented in GCC.
The _S_single policy uses atomics when used in MT code, because it uses the same dispatcher functions that check @@ -651,7 +645,7 @@ be private.
Unlike Boost, this implementation does not use separate classes for the pointer+deleter and pointer+deleter+allocator cases in - C++0x mode, combining both into _Sp_counted_deleter and using + C++11 mode, combining both into _Sp_counted_deleter and using allocator when the user doesn't specify an allocator. If it was found to be beneficial an additional class could easily be added. With the current implementation, @@ -680,25 +674,25 @@ be private. code to work with, Peter Dimov in particular for his help and invaluable advice on thread safety. Phillip Jordan and Paolo Carlini for the lock policy implementation. -
Bibliography
+
Bibliography
Improving shared_ptr for C++0x, Revision 2 . N2351 - .
+ .
C++ Standard Library Active Issues List . N2456 - .
+ .
Working Draft, Standard for Programming Language C++ . N2461 - .
+ .
Boost C++ Libraries documentation, shared_ptr diff --git a/libstdc++-v3/doc/html/manual/numerics.html b/libstdc++-v3/doc/html/manual/numerics.html index d0197db70b1..b872779fc53 100644 --- a/libstdc++-v3/doc/html/manual/numerics.html +++ b/libstdc++-v3/doc/html/manual/numerics.html @@ -7,7 +7,7 @@ Standard Contents Â Next
ChapterÂ 12.Â Numerics - +
Table of Contents
Complex
complex Processing
Generalized Operations
Interacting with C
Numerics vs. Arrays
C99
Complex

complex Processing

Using complex<> becomes even more comple- er, sorry, diff --git a/libstdc++-v3/doc/html/manual/parallel_mode.html b/libstdc++-v3/doc/html/manual/parallel_mode.html index cf37b7d163a..6af13679837 100644 --- a/libstdc++-v3/doc/html/manual/parallel_mode.html +++ b/libstdc++-v3/doc/html/manual/parallel_mode.html @@ -13,11 +13,11 @@ explicit source declaration or by compiling existing sources with a specific compiler flag.
Intro
The following library components in the include numeric are included in the parallel mode:
std::accumulate
std::adjacent_difference
std::inner_product
std::partial_sum
The following library components in the include -algorithm are included in the parallel mode:
std::adjacent_find
std::count
std::count_if
std::equal
std::find
std::find_if
std::find_first_of
std::for_each
std::generate
std::generate_n
std::lexicographical_compare
std::mismatch
std::search
std::search_n
std::transform
std::replace
std::replace_if
std::max_element
std::merge
std::min_element
std::nth_element
std::partial_sort
std::partition
std::random_shuffle
std::set_union
std::set_intersection
std::set_symmetric_difference
std::set_difference
std::sort
std::stable_sort
std::unique_copy
Bibliography
+algorithm are included in the parallel mode:
std::adjacent_find
std::count
std::count_if
std::equal
std::find
std::find_if
std::find_first_of
std::for_each
std::generate
std::generate_n
std::lexicographical_compare
std::mismatch
std::search
std::search_n
std::transform
std::replace
std::replace_if
std::max_element
std::merge
std::min_element
std::nth_element
std::partial_sort
std::partition
std::random_shuffle
std::set_union
std::set_intersection
std::set_symmetric_difference
std::set_difference
std::sort
std::stable_sort
std::unique_copy
Bibliography
Parallelization of Bulk Operations for STL Dictionaries . Johannes Singler. Leonor Frias. Copyright Â© 2007 . Workshop on Highly Parallel Processing on a Chip (HPPC) 2007. (LNCS) - .
+ .
The Multi-Core Standard Template Library . Johannes Singler. Peter Sanders. Felix Putze. Copyright Â© 2007 . Euro-Par 2007: Parallel Processing. (LNCS 4641) diff --git a/libstdc++-v3/doc/html/manual/policy_data_structures.html b/libstdc++-v3/doc/html/manual/policy_data_structures.html index 19a9b6eb434..fe781b73b33 100644 --- a/libstdc++-v3/doc/html/manual/policy_data_structures.html +++ b/libstdc++-v3/doc/html/manual/policy_data_structures.html @@ -251,7 +251,7 @@ these invariants, one must supply some policy that is aware of these changes. Without this, it would be better to use a linked list (in itself very efficient for these purposes). -
FigureÂ 22.1.Â Node Invariants

Underlying Data Structures
+
FigureÂ 22.1.Â Node Invariants

Underlying Data Structures
The standard C++ library contains associative containers based on red-black trees and collision-chaining hash tables. These are very useful, but they are not ideal for all types of @@ -259,7 +259,7 @@
The figure below shows the different underlying data structures currently supported in this library. -
FigureÂ 22.2.Â Underlying Associative Data Structures

+
FigureÂ 22.2.Â Underlying Associative Data Structures

A shows a collision-chaining hash-table, B shows a probing hash-table, C shows a red-black tree, D shows a splay tree, E shows a tree based on an ordered vector(implicit in the order of the @@ -378,7 +378,7 @@ no guarantee that the elements traversed will coincide with the logical elements between 1 and 5, as in label B. -
FigureÂ 22.3.Â Range Iteration in Different Data Structures

+
FigureÂ 22.3.Â Range Iteration in Different Data Structures

In our opinion, this problem is not caused just because red-black trees are order preserving while collision-chaining hash tables are (generally) not - it @@ -429,7 +429,7 @@ list, as in the graphic below, label B. Here the iterators are as light as can be, but the hash-table's operations are more complicated. -
FigureÂ 22.4.Â Point Iteration in Hash Data Structures

+
FigureÂ 22.4.Â Point Iteration in Hash Data Structures

It should be noted that containers based on collision-chaining hash-tables are not the only ones with this type of behavior; many other self-organizing data structures display it as well. @@ -445,7 +445,7 @@ container. The graphic below shows three cases: A1 and A2 show a red-black tree; B1 and B2 show a probing hash-table; C1 and C2 show a collision-chaining hash table. -
FigureÂ 22.5.Â Effect of erase in different underlying data structures

+
FigureÂ 22.5.Â Effect of erase in different underlying data structures

Erasing 5 from A1 yields A2. Clearly, an iterator to 3 can be de-referenced and incremented. The sequence of iterators changed, but in a way that is well-defined by the interface. @@ -681,7 +681,7 @@ typically less structured than an associative container's tree; the third simply uses an associative container. These are shown in the figure below with labels A1 and A2, B, and C. -
FigureÂ 22.6.Â Underlying Priority Queue Data Structures

+
FigureÂ 22.6.Â Underlying Priority Queue Data Structures

No single implementation can completely replace any of the others. Some have better push and pop amortized performance, some have diff --git a/libstdc++-v3/doc/html/manual/policy_data_structures_design.html b/libstdc++-v3/doc/html/manual/policy_data_structures_design.html index 777dda3528a..f1fca3e706c 100644 --- a/libstdc++-v3/doc/html/manual/policy_data_structures_design.html +++ b/libstdc++-v3/doc/html/manual/policy_data_structures_design.html @@ -171,7 +171,7 @@ naturally; collision-chaining hash tables (label B) store equivalent-key values in the same bucket, the bucket can be arranged so that equivalent-key values are consecutive. -
FigureÂ 22.8.Â Non-unique Mapping Standard Containers

+
FigureÂ 22.8.Â Non-unique Mapping Standard Containers

Put differently, the standards' non-unique mapping associative-containers are associative containers that map primary keys to linked lists that are embedded into the @@ -253,7 +253,7 @@ first graphic above. Labels A and B, respectively. Each shaded box represents some size-type or secondary associative-container. -
FigureÂ 22.10.Â Non-unique Mapping Containers

+
FigureÂ 22.10.Â Non-unique Mapping Containers

In the first example above, then, one would use an associative container mapping each user to an associative container which maps each application id to a start time (see @@ -306,7 +306,7 @@ shows invariants for order-preserving containers: point-type iterators are synonymous with range-type iterators. Orthogonally, Cshows invariants for "set" - containers: iterators are synonymous with const iterators.
FigureÂ 22.11.Â Point Iterator Hierarchy

Note that point-type iterators in self-organizing containers + containers: iterators are synonymous with const iterators.
FigureÂ 22.11.Â Point Iterator Hierarchy

Note that point-type iterators in self-organizing containers (hash-based associative containers) lack movement operators, such as operator++ - in fact, this is the reason why this library differentiates from the standard C++ librarys @@ -345,7 +345,7 @@ to the question of whether point-type iterators and range-type iterators are valid. The graphic below shows tags corresponding to different types of invalidation guarantees. -
FigureÂ 22.12.Â Invalidation Guarantee Tags Hierarchy

+
FigureÂ 22.12.Â Invalidation Guarantee Tags Hierarchy

basic_invalidation_guarantee corresponds to a basic guarantee that a point-type iterator, a found pointer, or a found reference, remains valid as long @@ -429,7 +429,7 @@
This library contains a container tag hierarchy corresponding to the diagram below. -
FigureÂ 22.13.Â Container Tag Hierarchy

+
FigureÂ 22.13.Â Container Tag Hierarchy

Given any container Cntnr, the tag of the underlying data structure can be found via typename Cntnr::container_category. @@ -488,7 +488,7 @@ collision-chaining container, except for the following.
Comb_Probe_Fn describes how to transform a probe sequence into a sequence of positions within the table.
Probe_Fn describes a probe sequence policy.
Some of the default template values depend on the values of other parameters, and are explained below.
Details
Hash Policies
General
Following is an explanation of some functions which hashing - involves. The graphic below illustrates the discussion.
FigureÂ 22.14.Â Hash functions, ranged-hash functions, and + involves. The graphic below illustrates the discussion.
FigureÂ 22.14.Â Hash functions, ranged-hash functions, and range-hashing functions

Let U be a domain (e.g., the integers, or the strings of 3 characters). A hash-table algorithm needs to map elements of U "uniformly" into the range [0,..., m - @@ -505,7 +505,7 @@ Z₊,
which maps a non-negative hash value, and a non-negative range upper-bound into a non-negative integral in the range between 0 (inclusive) and the range upper bound (exclusive), - i.e., for any r in Z₊,
0 â¤ g(r, m) â¤ m - 1
The resulting ranged-hash function, is
EquationÂ 22.1.Â Ranged Hash Function
+ i.e., for any r in Z₊,
0 â¤ g(r, m) â¤ m - 1
The resulting ranged-hash function, is
EquationÂ 22.1.Â Ranged Hash Function
f(u , m) = g(h(u), m)

From the above, it is obvious that given g and h, f can always be composed (however the converse @@ -525,7 +525,7 @@ transforming the sequence of hash values into a sequence of positions.
Range Hashing
Some common choices for range-hashing functions are the division, multiplication, and middle-square methods ([biblio.knuth98sorting]), defined - as
EquationÂ 22.2.Â Range-Hashing, Division Method
+ as
EquationÂ 22.2.Â Range-Hashing, Division Method
g(r, m) = r mod m

g(r, m) = â u/v ( a r mod v ) â
and
g(r, m) = â u/v ( r² mod v ) â
respectively, for some positive integrals u and v (typically powers of 2), and some a. Each of @@ -536,9 +536,9 @@ implement using the low level % (modulo) operation (for any m), or the low level & (bit-mask) operation (for the case where - m is a power of 2), i.e.,
EquationÂ 22.3.Â Division via Prime Modulo
+ m is a power of 2), i.e.,
EquationÂ 22.3.Â Division via Prime Modulo
g(r, m) = r % m -

and
EquationÂ 22.4.Â Division via Bit Mask
+

and
EquationÂ 22.4.Â Division via Bit Mask
g(r, m) = r & m - 1, (with m = 2^k for some k)

respectively.
The % (modulo) implementation has the advantage that for @@ -564,7 +564,7 @@ s = [ s₀,..., s_{t - 1}]
be a string of t characters, each of which is from domain S. Consider the following ranged-hash - function:
EquationÂ 22.5.Â + function:
EquationÂ 22.5.Â A Standard String Hash Function
f₁(s, m) = â _{i =
@@ -576,7 +576,7 @@
of a long DNA sequence (and so S = {'A', 'C', 'G',
'T'}). In this case, scanning the entire string might be
prohibitively expensive. A possible alternative might be to use
- only the first k characters of the string, where
|S|^k â¥ m ,
i.e., using the hash function}
EquationÂ 22.6.Â + only the first k characters of the string, where
|S|^k â¥ m ,
i.e., using the hash function
EquationÂ 22.6.Â Only k String DNA Hash
f₂(s, m) = â _{i
@@ -607,12 +607,12 @@
the container transforms the key into a non-negative integral
using the hash functor (points B and C), and transforms the
result into a position using the combining functor (points D
- and E).}
FigureÂ 22.15.Â Insert hash sequence diagram

If cc_hash_table's + and E).
FigureÂ 22.15.Â Insert hash sequence diagram

If cc_hash_table's hash-functor, Hash_Fn is instantiated by null_type , then Comb_Hash_Fn is taken to be a ranged-hash function. The graphic below shows an insert sequence diagram. The user inserts an element (point A), the container transforms the key into a position using the combining functor - (points B and C).
FigureÂ 22.16.Â Insert hash sequence diagram with a null policy

+ (points B and C).
FigureÂ 22.16.Â Insert hash sequence diagram with a null policy

Probing tables
gp_hash_table is parametrized by Hash_Fn, Probe_Fn, @@ -635,7 +635,7 @@ a linear probe and a quadratic probe function, respectively.
The graphic below shows the relationships. -
FigureÂ 22.17.Â Hash policy class diagram

Resize Policies
General
Hash-tables, as opposed to trees, do not naturally grow or +
FigureÂ 22.17.Â Hash policy class diagram

Resize Policies
General
Hash-tables, as opposed to trees, do not naturally grow or shrink. It is necessary to specify policies to determine how and when a hash table should change its size. Usually, resize policies can be decomposed into orthogonal policies:
A size policy indicating how a hash table @@ -668,10 +668,10 @@ and some load factor be denoted by Î. We would like to calculate the minimal length of k, such that if there were Î m elements in the hash table, a probe sequence of length k would - be found with probability at most 1/m.
FigureÂ 22.18.Â Balls and bins

Denote the probability that a probe sequence of length + be found with probability at most 1/m.
FigureÂ 22.18.Â Balls and bins

Denote the probability that a probe sequence of length k appears in bin i by p_i, the length of the probe sequence of bin i by - l_i, and assume uniform distribution. Then
EquationÂ 22.7.Â + l_i, and assume uniform distribution. Then
EquationÂ 22.7.Â Probability of Probe Sequence of Length k
p₁ = @@ -685,7 +685,7 @@ l_i are negatively-dependent ([biblio.dubhashi98neg]) . Let - I(.) denote the indicator function. Then
EquationÂ 22.8.Â + I(.) denote the indicator function. Then
EquationÂ 22.8.Â Probability Probe Sequence in Some Bin
P( exists_i l_i â¥ k ) = @@ -724,7 +724,7 @@ a resize is needed, and if so, what is the new size (points D to G); following the resize, it notifies the policy that a resize has completed (point H); finally, the element is - inserted, and the policy notified (point I).
FigureÂ 22.19.Â Insert resize sequence diagram

In practice, a resize policy can be usually orthogonally + inserted, and the policy notified (point I).
FigureÂ 22.19.Â Insert resize sequence diagram

In practice, a resize policy can be usually orthogonally decomposed to a size policy and a trigger policy. Consequently, the library contains a single class for instantiating a resize policy: hash_standard_resize_policy @@ -733,8 +733,8 @@ both, and acts as a standard delegate ([biblio.gof]) to these policies.
The two graphics immediately below show sequence diagrams illustrating the interaction between the standard resize policy - and its trigger and size policies, respectively.
FigureÂ 22.20.Â Standard resize policy trigger sequence - diagram

FigureÂ 22.21.Â Standard resize policy size sequence + and its trigger and size policies, respectively.
FigureÂ 22.20.Â Standard resize policy trigger sequence + diagram

FigureÂ 22.21.Â Standard resize policy size sequence diagram

Predefined Policies
The library includes the following instantiations of size and trigger policies:
hash_load_check_resize_trigger implements a load check trigger policy.
cc_hash_max_collision_check_resize_trigger @@ -877,7 +877,7 @@ each node, and maintains node invariants (see [biblio.clrs2001].) The first stores in each node the size of the sub-tree rooted at the node; the second stores at each node the maximal endpoint of the - intervals at the sub-tree rooted at the node.
FigureÂ 22.22.Â Tree node invariants

Supporting such trees is difficult for a number of + intervals at the sub-tree rooted at the node.
FigureÂ 22.22.Â Tree node invariants

Supporting such trees is difficult for a number of reasons:
There must be a way to specify what a node's metadata should be (if any).
Various operations can invalidate node invariants. The graphic below shows how a right rotation, @@ -891,7 +891,7 @@ metadata.
It is not feasible to know in advance which methods trees can support. Besides the usual find method, the first tree can support a find_by_order method, while - the second can support an overlaps method.
FigureÂ 22.23.Â Tree node invalidation

These problems are solved by a combination of two means: + the second can support an overlaps method.
FigureÂ 22.23.Â Tree node invalidation

These problems are solved by a combination of two means: node iterators, and template-template node updater parameters.
Node Iterators
Each tree-based container defines two additional iterator types, const_node_iterator @@ -920,7 +920,7 @@ node_update class, and publicly subclasses node_update. The graphic below shows this scheme, as well as some predefined policies (which are explained - below).
FigureÂ 22.24.Â A tree and its update policy

node_update (an instantiation of + below).
FigureÂ 22.24.Â A tree and its update policy

node_update (an instantiation of Node_Update) must define metadata_type as the type of metadata it requires. For order statistics, e.g., metadata_type might be size_t. @@ -939,7 +939,7 @@ nd_it. For example, say node x in the graphic below label A has an invalid invariant, but its' children, y and z have valid invariants. After the invocation, all three - nodes should have valid invariants, as in label B.
FigureÂ 22.25.Â Restoring node invariants

When a tree operation might invalidate some node invariant, + nodes should have valid invariants, as in label B.
FigureÂ 22.25.Â Restoring node invariants

When a tree operation might invalidate some node invariant, it invokes this method in its node_update base to restore the invariant. For example, the graphic below shows an insert operation (point A); the tree performs some @@ -947,7 +947,7 @@ C, and D). (It is well known that any insert, erase, split or join, can restore all node invariants by a small number of node invariant updates ([biblio.clrs2001]) - .
FigureÂ 22.26.Â Insert update sequence

To complete the description of the scheme, three questions + .
FigureÂ 22.26.Â Insert update sequence

To complete the description of the scheme, three questions need to be answered:
How can a tree which supports order statistics define a method such as find_by_order?
How can the node updater base access methods of the tree?
How can the following cyclic dependency be resolved? @@ -989,7 +989,7 @@ node's metadata (this is halting reducible). In the graphic below, assume the shaded node is inserted. The tree would have to traverse the useless path shown to the root, applying - redundant updates all the way.
FigureÂ 22.27.Â Useless update path

A null policy class, null_node_update + redundant updates all the way.
FigureÂ 22.27.Â Useless update path

A null policy class, null_node_update solves both these problems. The tree detects that node invariants are irrelevant, and defines all accordingly.
Split and Join
Tree-based containers support split and join methods. It is possible to split a tree so that it passes @@ -1072,7 +1072,7 @@ sub-tree with leafs "a" and "as". The maximal common prefix is "a". The internal node contains, consequently, to const iterators, one pointing to 'a', and the other to - 's'.
FigureÂ 22.28.Â A PATRICIA trie

Node Invariants
Trie-based containers support node invariants, as do + 's'.
FigureÂ 22.28.Â A PATRICIA trie

Node Invariants
Trie-based containers support node invariants, as do tree-based containers. There are two minor differences, though, which, unfortunately, thwart sharing them sharing the same node-updating policies:
A trie's Node_Update template-template @@ -1081,7 +1081,7 @@ parametrized by Cmp_Fn.
Tree-based containers store values in all nodes, while trie-based containers (at least in this implementation) store values in leafs.
The graphic below shows the scheme, as well as some predefined - policies (which are explained below).
FigureÂ 22.29.Â A trie and its update policy

This library offers the following pre-defined trie node + policies (which are explained below).
FigureÂ 22.29.Â A trie and its update policy

This library offers the following pre-defined trie node updating policies:
trie_order_statistics_node_update supports order statistics. @@ -1129,7 +1129,7 @@ simple list of integer keys. If we search for the integer 6, we are paying an overhead: the link with key 6 is only the fifth link; if it were the first link, it could be accessed - faster.
FigureÂ 22.30.Â A simple list

List-update algorithms reorder lists as elements are + faster.
FigureÂ 22.30.Â A simple list

List-update algorithms reorder lists as elements are accessed. They try to determine, by the access history, which keys to move to the front of the list. Some of these algorithms require adding some metadata alongside each entry.
For example, in the graphic below label A shows the counter @@ -1139,7 +1139,7 @@ predetermined value, say 10, as shown in label C, the count is set to 0 and the node is moved to the front of the list, as in label D. -
FigureÂ 22.31.Â The counter algorithm

Policies
this library allows instantiating lists with policies +
FigureÂ 22.31.Â The counter algorithm

Policies
this library allows instantiating lists with policies implementing any algorithm moving nodes to the front of the list (policies implementing algorithms interchanging nodes are unsupported).
Associative containers based on lists are parametrized by a @@ -1311,7 +1311,7 @@ sequence; the second uses a tree (or forest of trees), which is typically less structured than an associative container's tree; the third simply uses an associative container. These are - shown in the graphic below, in labels A1 and A2, label B, and label C.
FigureÂ 22.32.Â Underlying Priority-Queue Data-Structures.

Roughly speaking, any value that is both pushed and popped + shown in the graphic below, in labels A1 and A2, label B, and label C.
FigureÂ 22.32.Â Underlying Priority-Queue Data-Structures.

Roughly speaking, any value that is both pushed and popped from a priority queue must incur a logarithmic expense (in the amortized sense). Any priority queue implementation that would avoid this, would violate known bounds on comparison-based @@ -1391,7 +1391,7 @@ container Cntnr, the tag of the underlying data structure can be found via typename Cntnr::container_category; this is one of the possible tags shown in the graphic below. -
FigureÂ 22.33.Â Priority-Queue Data-Structure Tags.

Additionally, a traits mechanism can be used to query a +
FigureÂ 22.33.Â Priority-Queue Data-Structure Tags.

Additionally, a traits mechanism can be used to query a container type for its attributes. Given any container Cntnr, then
__gnu_pbds::container_traits<Cntnr>
is a traits class identifying the properties of the diff --git a/libstdc++-v3/doc/html/manual/policy_data_structures_using.html b/libstdc++-v3/doc/html/manual/policy_data_structures_using.html index ec58b190dd7..28942eb9bf6 100644 --- a/libstdc++-v3/doc/html/manual/policy_data_structures_using.html +++ b/libstdc++-v3/doc/html/manual/policy_data_structures_using.html @@ -62,7 +62,7 @@ In addition, there are the following diagnostics classes, used to report errors specific to this library's data structures. -
FigureÂ 22.7.Â Exception Hierarchy

Tutorial
Basic Use
+
FigureÂ 22.7.Â Exception Hierarchy

Tutorial
Basic Use
For the most part, the policy-based containers containers in namespace __gnu_pbds have the same interface as the equivalent containers in the standard C++ library, except for @@ -83,7 +83,7 @@ __gnu_pbds::cc_hash_table instead of std::unordered_map, since âunordered mapâ does not necessarily mean a hash-based map as implied by - the C++ library (C++0x or TR1). For example, list-based associative + the C++ library (C++11 or TR1). For example, list-based associative containers, which are very useful for the construction of "multimaps," are also unordered.
This snippet shows a red-black tree based container:
diff --git a/libstdc++-v3/doc/html/manual/profile_mode.html b/libstdc++-v3/doc/html/manual/profile_mode.html index c39e23b29ce..d7465a1387c 100644 --- a/libstdc++-v3/doc/html/manual/profile_mode.html +++ b/libstdc++-v3/doc/html/manual/profile_mode.html @@ -138,7 +138,7 @@ vector-size: improvement = 3: call stack = 0x804842c ... call context. (Environment variable not supported.)
-
Bibliography
+
Bibliography
Perflint: A Context Sensitive Performance Advisor for C++ Programs . Lixia Liu. Silvius Rus. Copyright Â© 2009 . Proceedings of the 2009 International Symposium on Code Generation diff --git a/libstdc++-v3/doc/html/manual/status.html b/libstdc++-v3/doc/html/manual/status.html index d72a0c20de2..eeefda61cea 100644 --- a/libstdc++-v3/doc/html/manual/status.html +++ b/libstdc++-v3/doc/html/manual/status.html @@ -3,12 +3,12 @@ ChapterÂ 1.Â Status
ChapterÂ 1.Â Status
PrevÂ PartÂ I.Â Introduction - Â Next
ChapterÂ 1.Â Status
Table of Contents
Implementation Status
C++ 1998/2003
Implementation Status
Implementation Specific Behavior
C++ 200x
C++ TR1
C++ TR 24733
License
The Code: GPL
The Documentation: GPL, FDL
Bugs
Implementation Bugs
Standard Bugs
Implementation Status
C++ 1998/2003
Implementation Status
+Â Next
ChapterÂ 1.Â Status
Table of Contents
Implementation Status
C++ 1998/2003
Implementation Status
Implementation Specific Behavior
C++ 2011
C++ TR1
C++ TR 24733
License
The Code: GPL
The Documentation: GPL, FDL
Bugs
Implementation Bugs
Standard Bugs
Implementation Status
C++ 1998/2003
Implementation Status
This status table is based on the table of contents of ISO/IEC 14882:2003.
This page describes the C++ support in mainline GCC SVN, not in any particular release. -
TableÂ 1.1.Â C++ 1998/2003 Implementation Status
Section Description Status Comments
+
TableÂ 1.1.Â C++ 1998/2003 Implementation Status
Section Description Status Comments
18 Language support @@ -142,22 +142,22 @@ particular release. in this chapter.
[27.8.1.4]/16 Calling fstream::sync when a get area exists will... whatever fflush() does, I think. -
C++ 200x
+
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++0x or --std=c++0x flags must be used to enable language +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 __GXX_EXPERIMENTAL_CXX0X__ is used to check for the presence of the required flag.
-This page describes the C++0x support in mainline GCC SVN, not in any +This page describes the C++11 support in mainline GCC SVN, not in any particular release. -
TableÂ 1.2.Â C++ 200x Implementation Status
Section Description Status Comments
+
TableÂ 1.2.Â C++ 2011 Implementation Status
Section Description Status Comments
18 Language support @@ -196,7 +196,7 @@ particular release. 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 Â
+
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 Partial Missing emplace members
23.2.5 Unordered associative containers Partial Missing emplace members
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 @@ -245,7 +245,7 @@ In this implementation the header names are prefixed by
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 Â +
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. @@ -258,7 +258,7 @@ 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
+
TableÂ 1.4.Â C++ TR 24733 Implementation Status
Section Description Status Comments
0 Introduction diff --git a/libstdc++-v3/doc/html/manual/strings.html b/libstdc++-v3/doc/html/manual/strings.html index ca880069e70..c0d80e3d11f 100644 --- a/libstdc++-v3/doc/html/manual/strings.html +++ b/libstdc++-v3/doc/html/manual/strings.html @@ -7,7 +7,7 @@ Standard Contents Â Next
ChapterÂ 7.Â Strings - +
Table of Contents
String Classes
Simple Transformations
Case Sensitivity
Arbitrary Character Types
Tokenizing
Shrink to Fit
CString (MFC)
String Classes
Simple Transformations
Here are Standard, simple, and portable ways to perform common transformations on a string instance, such as @@ -269,7 +269,7 @@ stringtok(Container &container, string const &in, (see this FAQ entry) but the regular copy constructor cannot be used because libstdc++'s string is Copy-On-Write. -
In C++0x mode you can call +
In C++11 mode you can call s.shrink_to_fit() to achieve the same effect as s.reserve(s.size()).
CString (MFC)
diff --git a/libstdc++-v3/doc/html/manual/support.html b/libstdc++-v3/doc/html/manual/support.html index acaa47aee19..8765da26668 100644 --- a/libstdc++-v3/doc/html/manual/support.html +++ b/libstdc++-v3/doc/html/manual/support.html @@ -7,7 +7,7 @@ Standard Contents
Â Next
ChapterÂ 4.Â Support - +
Table of Contents
Types
Fundamental Types
Numeric Properties
NULL
Dynamic Memory
Termination
Termination Handlers
Verbose Terminate Handler
This part deals with the functions called and objects created automatically during the course of a program's existence. diff --git a/libstdc++-v3/doc/html/manual/test.html b/libstdc++-v3/doc/html/manual/test.html index 9153c93c18a..c4f26a77010 100644 --- a/libstdc++-v3/doc/html/manual/test.html +++ b/libstdc++-v3/doc/html/manual/test.html @@ -392,10 +392,10 @@ Example 1: Testing compilation only // { dg-do compile } Example 2: Testing for expected warnings on line 36, which all targets fail -// { dg-warning "string literals" "" { xfail *-*-* } 36 +// { dg-warning "string literals" "" { xfail *-*-* } 36 } Example 3: Testing for expected warnings on line 36 -// { dg-warning "string literals" "" { target *-*-* } 36 +// { dg-warning "string literals" "" { target *-*-* } 36 } Example 4: Testing for compilation errors on line 41 // { dg-do compile } @@ -493,7 +493,7 @@ only default variables. reporting functions including:
time_counter
resource_counter
report_performance
Special Topics
Qualifying Exception Safety Guarantees - +
Overview
Testing is composed of running a particular test sequence, and looking at what happens to the surrounding code when @@ -548,7 +548,7 @@ container uses an extension allocator, __gnu_cxx::throw_allocator_random, as the allocator type.
- C++0x Container Requirements. + C++11 Container Requirements.
Coverage is currently limited to testing container requirements for exception safety, @@ -563,8 +563,8 @@ as the allocator type. instrumentation to iterator and const_iterator types that throw conditionally on iterator operations. -
-C++0x Requirements Test Sequence Descriptions +
+C++11 Requirements Test Sequence Descriptions
Basic
diff --git a/libstdc++-v3/doc/html/manual/using.html b/libstdc++-v3/doc/html/manual/using.html index a58915b4336..27ee39b1034 100644 --- a/libstdc++-v3/doc/html/manual/using.html +++ b/libstdc++-v3/doc/html/manual/using.html @@ -6,10 +6,10 @@
Â Next
ChapterÂ 3.Â Using
Table of Contents
Command Options
Headers
Header Files
Mixing Headers
The C Headers and namespace std
Precompiled Headers
Macros
Namespaces
Available Namespaces
namespace std
Using Namespace Composition
Linking
Almost Nothing
Finding Dynamic or Shared Libraries
Concurrency
Prerequisites
Thread Safety
Atomics
IO
Structure
Defaults
Future
Alternatives
Containers
Exceptions
Exception Safety
Exception Neutrality
Doing without
Compatibility
With C
With POSIX thread cancellation
Debugging Support
Using g++
Debug Versions of Library Binary Files
Memory Leak Hunting
Data Race Hunting
Using gdb
Tracking uncaught exceptions
Debug Mode
Compile Time Checking
Profile-based Performance Analysis
Command Options
The set of features available in the GNU C++ library is shaped by - several GCC + several GCC Command Options. Options that impact libstdc++ are enumerated and detailed in the table below.
By default, g++ is equivalent to g++ -std=gnu++98. The standard library also defaults to this dialect. -
TableÂ 3.1.Â C++ Command Options
Option Flags Description
-std=c++98 Use the 1998 ISO C++ standard plus amendments.
-std=gnu++98 As directly above, with GNU extensions.
-std=c++0x Use the working draft of the upcoming ISO C++0x standard.
-std=gnu++0x As directly above, with GNU extensions.
-fexceptions See exception-free dialect
-frtti As above, but RTTI-free dialect.
-pthread or -pthreads For ISO C++0x <thread>, <future>, +
TableÂ 3.1.Â C++ Command Options
Option Flags Description
-std=c++98 Use the 1998 ISO C++ standard plus amendments.
-std=gnu++98 As directly above, with GNU extensions.
-std=c++11 Use the 2011 ISO C++ standard.
-std=gnu++11 As directly above, with GNU extensions.
-fexceptions See exception-free dialect
-frtti As above, but RTTI-free dialect.
-pthread or -pthreads For ISO C++11 <thread>, <future>, <mutex>, or <condition_variable>.
-fopenmp For parallel mode.

PrevÂ Up Â Next
MakeÂ Home Â Headers
diff --git a/libstdc++-v3/doc/html/manual/using_dynamic_or_shared.html b/libstdc++-v3/doc/html/manual/using_dynamic_or_shared.html index 9796e4e8a60..4d1d6745b73 100644 --- a/libstdc++-v3/doc/html/manual/using_dynamic_or_shared.html +++ b/libstdc++-v3/doc/html/manual/using_dynamic_or_shared.html @@ -26,7 +26,7 @@ cxxabi.h.
In the - C++0x dialect add + C++11 dialect add
initializer_list
diff --git a/libstdc++-v3/doc/html/manual/using_exceptions.html b/libstdc++-v3/doc/html/manual/using_exceptions.html index 1a8e9bd0c70..a46b55b9ba3 100644 --- a/libstdc++-v3/doc/html/manual/using_exceptions.html +++ b/libstdc++-v3/doc/html/manual/using_exceptions.html @@ -266,7 +266,7 @@ is called. } catch(...) { this->_M_setstate(ios_base::badbit); } -
Bibliography
+
Bibliography
System Interface Definitions, Issue 7 (IEEE Std. 1003.1-2008) @@ -275,39 +275,39 @@ is called. . Copyright Â© 2008 The Open Group/The Institute of Electrical and Electronics Engineers, Inc. - .
+ .
Error and Exception Handling . David Abrahams . Boost - .
+ .
Exception-Safety in Generic Components . David Abrahams. Boost - .
+ .
Standard Library Exception Policy . Matt Austern. WG21 N1077 - .
+ .
ia64 c++ abi exception handling . Richard Henderson. GNU - .
+ .
Appendix E: Standard-Library Exception Safety - . Bjarne Stroustrup.
+ . Bjarne Stroustrup.
Exceptional C++ . Exception-Safety Issues and Techniques - . Herb Sutter.
+ . Herb Sutter.
GCC Bug 25191: exception_defines.h #defines try/catch diff --git a/libstdc++-v3/doc/html/manual/using_headers.html b/libstdc++-v3/doc/html/manual/using_headers.html index db60e432187..99ecff25efa 100644 --- a/libstdc++-v3/doc/html/manual/using_headers.html +++ b/libstdc++-v3/doc/html/manual/using_headers.html @@ -16,45 +16,44 @@ Headers), and all others (TR1, C++ ABI, and Extensions).
Two dialects of standard headers are supported, corresponding to - the 1998 standard as updated for 2003, and the draft of the - upcoming 200x standard. + the 1998 standard as updated for 2003, and the current 2011 standard.
C++98/03 include files. These are available in the default compilation mode, i.e. -std=c++98 or -std=gnu++98. -
TableÂ 3.2.Â C++ 1998 Library Headers
algorithm bitset complex deque exception
fstream functional iomanip ios iosfwd
iostream istream iterator limits list
locale map memory new numeric
ostream queue set sstream stack
stdexcept streambuf string utility typeinfo
valarray vector Â Â Â

TableÂ 3.3.Â C++ 1998 Library Headers for C Library Facilities
cassert cerrno cctype cfloat ciso646
climits clocale cmath csetjmp csignal
cstdarg cstddef cstdio cstdlib cstring
ctime cwchar cwctype Â Â

-C++0x include files. These are only available in C++0x compilation -mode, i.e. -std=c++0x or -std=gnu++0x. -
TableÂ 3.4.Â C++ 200x Library Headers
algorithm array bitset chrono complex
condition_variable deque exception forward_list fstream
functional future initalizer_list iomanip ios
iosfwd iostream istream iterator limits
list locale map memory mutex
new numeric ostream queue random
ratio regex set sstream stack
stdexcept streambuf string system_error thread
tuple type_traits typeinfo unordered_map unordered_set
utility valarray vector Â Â

TableÂ 3.5.Â C++ 200x Library Headers for C Library Facilities
cassert ccomplex cctype cerrno cfenv
cfloat cinttypes ciso646 climits clocale
cmath csetjmp csignal cstdarg cstdbool
cstddef cstdint cstdlib cstdio cstring
ctgmath ctime cuchar cwchar cwctype

+
TableÂ 3.2.Â C++ 1998 Library Headers
algorithm bitset complex deque exception
fstream functional iomanip ios iosfwd
iostream istream iterator limits list
locale map memory new numeric
ostream queue set sstream stack
stdexcept streambuf string utility typeinfo
valarray vector Â Â Â

TableÂ 3.3.Â C++ 1998 Library Headers for C Library Facilities
cassert cerrno cctype cfloat ciso646
climits clocale cmath csetjmp csignal
cstdarg cstddef cstdio cstdlib cstring
ctime cwchar cwctype Â Â

+C++11 include files. These are only available in C++11 compilation +mode, i.e. -std=c++11 or -std=gnu++11. +
TableÂ 3.4.Â C++ 2011 Library Headers
algorithm array bitset chrono complex
condition_variable deque exception forward_list fstream
functional future initalizer_list iomanip ios
iosfwd iostream istream iterator limits
list locale map memory mutex
new numeric ostream queue random
ratio regex set sstream stack
stdexcept streambuf string system_error thread
tuple type_traits typeinfo unordered_map unordered_set
utility valarray vector Â Â

TableÂ 3.5.Â C++ 2011 Library Headers for C Library Facilities
cassert ccomplex cctype cerrno cfenv
cfloat cinttypes ciso646 climits clocale
cmath csetjmp csignal cstdarg cstdbool
cstddef cstdint cstdlib cstdio cstring
ctgmath ctime cuchar cwchar cwctype

In addition, TR1 includes as: -
TableÂ 3.6.Â C++ TR 1 Library Headers
tr1/array tr1/complex tr1/memory tr1/functional tr1/random
tr1/regex tr1/tuple tr1/type_traits tr1/unordered_map tr1/unordered_set
tr1/utility Â Â Â Â

TableÂ 3.7.Â C++ TR 1 Library Headers for C Library Facilities
tr1/ccomplex tr1/cfenv tr1/cfloat tr1/cmath tr1/cinttypes
tr1/climits tr1/cstdarg tr1/cstdbool tr1/cstdint tr1/cstdio
tr1/cstdlib tr1/ctgmath tr1/ctime tr1/cwchar tr1/cwctype

Decimal floating-point arithmetic is available if the C++ +
TableÂ 3.6.Â C++ TR 1 Library Headers
tr1/array tr1/complex tr1/memory tr1/functional tr1/random
tr1/regex tr1/tuple tr1/type_traits tr1/unordered_map tr1/unordered_set
tr1/utility Â Â Â Â

TableÂ 3.7.Â C++ TR 1 Library Headers for C Library Facilities
tr1/ccomplex tr1/cfenv tr1/cfloat tr1/cmath tr1/cinttypes
tr1/climits tr1/cstdarg tr1/cstdbool tr1/cstdint tr1/cstdio
tr1/cstdlib tr1/ctgmath tr1/ctime tr1/cwchar tr1/cwctype

Decimal floating-point arithmetic is available if the C++ compiler supports scalar decimal floating-point types defined via __attribute__((mode(SD|DD|LD))). -
TableÂ 3.8.Â C++ TR 24733 Decimal Floating-Point Header
decimal/decimal

+
TableÂ 3.8.Â C++ TR 24733 Decimal Floating-Point Header
decimal/decimal

Also included are files for the C++ ABI interface: -
TableÂ 3.9.Â C++ ABI Headers
cxxabi.h cxxabi_forced.h

+
TableÂ 3.9.Â C++ ABI Headers
cxxabi.h cxxabi_forced.h

And a large variety of extensions. -
TableÂ 3.10.Â Extension Headers
ext/algorithm ext/atomicity.h ext/array_allocator.h ext/bitmap_allocator.h ext/cast.h
ext/codecvt_specializations.h ext/concurrence.h ext/debug_allocator.h ext/enc_filebuf.h ext/extptr_allocator.h
ext/functional ext/iterator ext/malloc_allocator.h ext/memory ext/mt_allocator.h
ext/new_allocator.h ext/numeric ext/numeric_traits.h ext/pb_ds/assoc_container.h ext/pb_ds/priority_queue.h
ext/pod_char_traits.h ext/pool_allocator.h ext/rb_tree ext/rope ext/slist
ext/stdio_filebuf.h ext/stdio_sync_filebuf.h ext/throw_allocator.h ext/typelist.h ext/type_traits.h
ext/vstring.h Â Â Â Â

TableÂ 3.11.Â Extension Debug Headers
debug/bitset debug/deque debug/list debug/map debug/set
debug/string debug/unordered_map debug/unordered_set debug/vector Â

TableÂ 3.12.Â Extension Profile Headers
profile/bitset profile/deque profile/list profile/map
profile/set profile/unordered_map profile/unordered_set profile/vector

TableÂ 3.13.Â Extension Parallel Headers
parallel/algorithm parallel/numeric

Mixing Headers
A few simple rules. +
TableÂ 3.10.Â Extension Headers
ext/algorithm ext/atomicity.h ext/array_allocator.h ext/bitmap_allocator.h ext/cast.h
ext/codecvt_specializations.h ext/concurrence.h ext/debug_allocator.h ext/enc_filebuf.h ext/extptr_allocator.h
ext/functional ext/iterator ext/malloc_allocator.h ext/memory ext/mt_allocator.h
ext/new_allocator.h ext/numeric ext/numeric_traits.h ext/pb_ds/assoc_container.h ext/pb_ds/priority_queue.h
ext/pod_char_traits.h ext/pool_allocator.h ext/rb_tree ext/rope ext/slist
ext/stdio_filebuf.h ext/stdio_sync_filebuf.h ext/throw_allocator.h ext/typelist.h ext/type_traits.h
ext/vstring.h Â Â Â Â

TableÂ 3.11.Â Extension Debug Headers
debug/bitset debug/deque debug/list debug/map debug/set
debug/string debug/unordered_map debug/unordered_set debug/vector Â

TableÂ 3.12.Â Extension Profile Headers
profile/bitset profile/deque profile/list profile/map
profile/set profile/unordered_map profile/unordered_set profile/vector

TableÂ 3.13.Â Extension Parallel Headers
parallel/algorithm parallel/numeric

Mixing Headers
A few simple rules.
First, mixing different dialects of the standard headers is not possible. It's an all-or-nothing affair. Thus, code like
#include <array> #include <functional> -
Implies C++0x mode. To use the entities in <array>, the C++0x -compilation mode must be used, which implies the C++0x functionality +
Implies C++11 mode. To use the entities in <array>, the C++11 +compilation mode must be used, which implies the C++11 functionality (and deprecations) in <functional> will be present.
Second, the other headers can be included with either dialect of -the standard headers, although features and types specific to C++0x -are still only enabled when in C++0x compilation mode. So, to use +the standard headers, although features and types specific to C++11 +are still only enabled when in C++11 compilation mode. So, to use rvalue references with __gnu_cxx::vstring, or to use the debug-mode versions of std::unordered_map, one must use -the std=gnu++0x compiler flag. (Or std=c++0x, of course.) -
A special case of the second rule is the mixing of TR1 and C++0x +the std=gnu++11 compiler flag. (Or std=c++11, of course.) +
A special case of the second rule is the mixing of TR1 and C++11 facilities. It is possible (although not especially prudent) to -include both the TR1 version and the C++0x version of header in the +include both the TR1 version and the C++11 version of header in the same translation unit:
#include <tr1/type_traits> #include <type_traits> -
Several parts of C++0x diverge quite substantially from TR1 predecessors. +
Several parts of C++11 diverge quite substantially from TR1 predecessors.
The C Headers and namespace std
The standard specifies that if one includes the C-style header (<math.h> in this case), the symbols will be available diff --git a/libstdc++-v3/doc/html/manual/using_macros.html b/libstdc++-v3/doc/html/manual/using_macros.html index 6fdd4bd8af0..8e35d01a7a5 100644 --- a/libstdc++-v3/doc/html/manual/using_macros.html +++ b/libstdc++-v3/doc/html/manual/using_macros.html @@ -45,7 +45,7 @@ removes older ARM-style iostreams code, and other anachronisms from the API. This macro is dependent on the version of the standard being tracked, and as a result may give different results for - -std=c++98 and -std=c++0x. This may + -std=c++98 and -std=c++11. This may be useful in updating old C++ code which no longer meet the requirements of the language, or for checking current code against new language standards. diff --git a/libstdc++-v3/doc/html/manual/utilities.html b/libstdc++-v3/doc/html/manual/utilities.html index 454c272ba53..44807f91e2d 100644 --- a/libstdc++-v3/doc/html/manual/utilities.html +++ b/libstdc++-v3/doc/html/manual/utilities.html @@ -7,8 +7,8 @@ Standard Contents
Â Next
ChapterÂ 6.Â Utilities - -
Table of Contents
Functors
Pairs
Memory
Allocators
Requirements
Design Issues
Implementation
Interface Design
Selecting Default Allocation Policy
Disabling Memory Caching
Using a Specific Allocator
Custom Allocators
Extension Allocators
auto_ptr
Limitations
Use in Containers
shared_ptr
Requirements
Design Issues
Implementation
Class Hierarchy
Thread Safety
Selecting Lock Policy
Dual C++0x and TR1 Implementation
Related functions and classes
Use
Examples
Unresolved Issues
Acknowledgments
Traits
Functors
If you don't know what functors are, you're not alone. Many people + +
Table of Contents
Functors
Pairs
Memory
Allocators
Requirements
Design Issues
Implementation
Interface Design
Selecting Default Allocation Policy
Disabling Memory Caching
Using a Specific Allocator
Custom Allocators
Extension Allocators
auto_ptr
Limitations
Use in Containers
shared_ptr
Requirements
Design Issues
Implementation
Class Hierarchy
Thread Safety
Selecting Lock Policy
Dual C++11 and TR1 Implementation
Related functions and classes
Use
Examples
Unresolved Issues
Acknowledgments
Traits
Functors
If you don't know what functors are, you're not alone. Many people get slightly the wrong idea. In the interest of not reinventing the wheel, we will refer you to the introduction to the functor concept written by SGI as chapter of their STL, in diff --git a/libstdc++-v3/doc/xml/faq.xml b/libstdc++-v3/doc/xml/faq.xml index 4be79df6762..af9b6da82fe 100644 --- a/libstdc++-v3/doc/xml/faq.xml +++ b/libstdc++-v3/doc/xml/faq.xml @@ -694,7 +694,7 @@ Long answer: See the implementation status pages for C++98, TR1, and - C++0x. + C++11. diff --git a/libstdc++-v3/doc/xml/manual/backwards_compatibility.xml b/libstdc++-v3/doc/xml/manual/backwards_compatibility.xml index 41193bb549d..74a451f0867 100644 --- a/libstdc++-v3/doc/xml/manual/backwards_compatibility.xml +++ b/libstdc++-v3/doc/xml/manual/backwards_compatibility.xml @@ -693,14 +693,15 @@ other usage is correct. At this time most of the features of the SGI STL extension have been replaced by standardized libraries. - In particular, the unordered_map and unordered_set containers of TR1 - are suitable replacement for the non-standard hash_map and hash_set - containers in the SGI STL. + In particular, the unordered_map and + unordered_set containers of TR1 and C++ 2011 are suitable + replacements for the non-standard hash_map and + hash_set containers in the SGI STL. Header files hash_map and hash_set moved to ext/hash_map and ext/hash_set, respectively. At the same time, all types in these files are enclosed -in namespace __gnu_cxx. Later versions move deprecate +in namespace __gnu_cxx. Later versions deprecate these files, and suggest using TR1's unordered_map and unordered_set instead. @@ -832,7 +833,7 @@ No stream::attach(int fd) -
+<section xml:id="backwards.support_cxx98"><info><title> Support for C++98 dialect. @@ -908,7 +909,7 @@ AC_DEFUN([AC_HEADER_STDCXX_98], [
-
+<section xml:id="backwards.support_tr1"><info><title> Support for C++TR1 dialect. @@ -1000,19 +1001,19 @@ AC_DEFUN([AC_HEADER_TR1_UNORDERED_SET], [
-
-Support for C++0x dialect. +<section xml:id="backwards.support_cxx11"><info><title> +Support for C++11 dialect. -Check for baseline language coverage in the compiler for the C++0xstandard. +Check for baseline language coverage in the compiler for the C++11 standard. -# AC_COMPILE_STDCXX_OX -AC_DEFUN([AC_COMPILE_STDCXX_0X], [ - AC_CACHE_CHECK(if g++ supports C++0x features without additional flags, - ac_cv_cxx_compile_cxx0x_native, +# AC_COMPILE_STDCXX_11 +AC_DEFUN([AC_COMPILE_STDCXX_11], [ + AC_CACHE_CHECK(if g++ supports C++11 features without additional flags, + ac_cv_cxx_compile_cxx11_native, [AC_LANG_SAVE AC_LANG_CPLUSPLUS AC_TRY_COMPILE([ @@ -1030,16 +1031,16 @@ AC_DEFUN([AC_COMPILE_STDCXX_0X], [ typedef check<int> check_type; check_type c; check_type&& cr = c;],, - ac_cv_cxx_compile_cxx0x_native=yes, ac_cv_cxx_compile_cxx0x_native=no) + ac_cv_cxx_compile_cxx11_native=yes, ac_cv_cxx_compile_cxx11_native=no) AC_LANG_RESTORE ]) - AC_CACHE_CHECK(if g++ supports C++0x features with -std=c++0x, - ac_cv_cxx_compile_cxx0x_cxx, + AC_CACHE_CHECK(if g++ supports C++11 features with -std=c++11, + ac_cv_cxx_compile_cxx11_cxx, [AC_LANG_SAVE AC_LANG_CPLUSPLUS ac_save_CXXFLAGS="$CXXFLAGS" - CXXFLAGS="$CXXFLAGS -std=c++0x" + CXXFLAGS="$CXXFLAGS -std=c++11" AC_TRY_COMPILE([ template <typename T> struct check @@ -1055,17 +1056,17 @@ AC_DEFUN([AC_COMPILE_STDCXX_0X], [ typedef check<int> check_type; check_type c; check_type&& cr = c;],, - ac_cv_cxx_compile_cxx0x_cxx=yes, ac_cv_cxx_compile_cxx0x_cxx=no) + ac_cv_cxx_compile_cxx11_cxx=yes, ac_cv_cxx_compile_cxx11_cxx=no) CXXFLAGS="$ac_save_CXXFLAGS" AC_LANG_RESTORE ]) - AC_CACHE_CHECK(if g++ supports C++0x features with -std=gnu++0x, - ac_cv_cxx_compile_cxx0x_gxx, + AC_CACHE_CHECK(if g++ supports C++11 features with -std=gnu++11, + ac_cv_cxx_compile_cxx11_gxx, [AC_LANG_SAVE AC_LANG_CPLUSPLUS ac_save_CXXFLAGS="$CXXFLAGS" - CXXFLAGS="$CXXFLAGS -std=gnu++0x" + CXXFLAGS="$CXXFLAGS -std=gnu++11" AC_TRY_COMPILE([ template <typename T> struct check @@ -1081,33 +1082,33 @@ AC_DEFUN([AC_COMPILE_STDCXX_0X], [ typedef check<int> check_type; check_type c; check_type&& cr = c;],, - ac_cv_cxx_compile_cxx0x_gxx=yes, ac_cv_cxx_compile_cxx0x_gxx=no) + ac_cv_cxx_compile_cxx11_gxx=yes, ac_cv_cxx_compile_cxx11_gxx=no) CXXFLAGS="$ac_save_CXXFLAGS" AC_LANG_RESTORE ]) - if test "$ac_cv_cxx_compile_cxx0x_native" = yes || - test "$ac_cv_cxx_compile_cxx0x_cxx" = yes || - test "$ac_cv_cxx_compile_cxx0x_gxx" = yes; then - AC_DEFINE(HAVE_STDCXX_0X,,[Define if g++ supports C++0x features. ]) + if test "$ac_cv_cxx_compile_cxx11_native" = yes || + test "$ac_cv_cxx_compile_cxx11_cxx" = yes || + test "$ac_cv_cxx_compile_cxx11_gxx" = yes; then + AC_DEFINE(HAVE_STDCXX_11,,[Define if g++ supports C++11 features. ]) fi ]) -Check for library coverage of the C++0xstandard. +Check for library coverage of the C++2011 standard. -# AC_HEADER_STDCXX_0X -AC_DEFUN([AC_HEADER_STDCXX_0X], [ - AC_CACHE_CHECK(for ISO C++ 0x include files, - ac_cv_cxx_stdcxx_0x, - [AC_REQUIRE([AC_COMPILE_STDCXX_0X]) +# AC_HEADER_STDCXX_11 +AC_DEFUN([AC_HEADER_STDCXX_11], [ + AC_CACHE_CHECK(for ISO C++11 include files, + ac_cv_cxx_stdcxx_11, + [AC_REQUIRE([AC_COMPILE_STDCXX_11]) AC_LANG_SAVE AC_LANG_CPLUSPLUS ac_save_CXXFLAGS="$CXXFLAGS" - CXXFLAGS="$CXXFLAGS -std=gnu++0x" + CXXFLAGS="$CXXFLAGS -std=gnu++11" AC_TRY_COMPILE([ #include <cassert> @@ -1175,12 +1176,12 @@ AC_DEFUN([AC_HEADER_STDCXX_0X], [ #include <valarray> #include <vector> ],, - ac_cv_cxx_stdcxx_0x=yes, ac_cv_cxx_stdcxx_0x=no) + ac_cv_cxx_stdcxx_11=yes, ac_cv_cxx_stdcxx_11=no) AC_LANG_RESTORE CXXFLAGS="$ac_save_CXXFLAGS" ]) - if test "$ac_cv_cxx_stdcxx_0x" = yes; then - AC_DEFINE(STDCXX_0X_HEADERS,,[Define if ISO C++ 0x header files are present. ]) + if test "$ac_cv_cxx_stdcxx_11" = yes; then + AC_DEFINE(STDCXX_11_HEADERS,,[Define if ISO C++11 header files are present. ]) fi ]) @@ -1193,11 +1194,11 @@ AC_DEFUN([AC_HEADER_STDCXX_0X], [ AC_DEFUN([AC_HEADER_UNORDERED_MAP], [ AC_CACHE_CHECK(for unordered_map, ac_cv_cxx_unordered_map, - [AC_REQUIRE([AC_COMPILE_STDCXX_0X]) + [AC_REQUIRE([AC_COMPILE_STDCXX_11]) AC_LANG_SAVE AC_LANG_CPLUSPLUS ac_save_CXXFLAGS="$CXXFLAGS" - CXXFLAGS="$CXXFLAGS -std=gnu++0x" + CXXFLAGS="$CXXFLAGS -std=gnu++11" AC_TRY_COMPILE([#include <unordered_map>], [using std::unordered_map;], ac_cv_cxx_unordered_map=yes, ac_cv_cxx_unordered_map=no) CXXFLAGS="$ac_save_CXXFLAGS" @@ -1214,11 +1215,11 @@ AC_DEFUN([AC_HEADER_UNORDERED_MAP], [ AC_DEFUN([AC_HEADER_UNORDERED_SET], [ AC_CACHE_CHECK(for unordered_set, ac_cv_cxx_unordered_set, - [AC_REQUIRE([AC_COMPILE_STDCXX_0X]) + [AC_REQUIRE([AC_COMPILE_STDCXX_11]) AC_LANG_SAVE AC_LANG_CPLUSPLUS ac_save_CXXFLAGS="$CXXFLAGS" - CXXFLAGS="$CXXFLAGS -std=gnu++0x" + CXXFLAGS="$CXXFLAGS -std=gnu++11" AC_TRY_COMPILE([#include <unordered_set>], [using std::unordered_set;], ac_cv_cxx_unordered_set=yes, ac_cv_cxx_unordered_set=no) CXXFLAGS="$ac_save_CXXFLAGS" @@ -1229,6 +1230,17 @@ AC_DEFUN([AC_HEADER_UNORDERED_SET], [ fi ]) + + + Some C++11 features first appeared in GCC 4.3 and could be enabled by + and for GCC + releases which pre-date the 2011 standard. Those C++11 features and GCC's + support for them were still changing until the 2011 standard was finished, + but the autoconf checks above could be extended to test for incomplete + C++11 support with and + . + +

@@ -1237,7 +1249,7 @@ AC_DEFUN([AC_HEADER_UNORDERED_SET], [ <para> - This is a change in behavior from the previous version. Now, most + This is a change in behavior from older versions. Now, most <type>iterator_type</type> typedefs in container classes are POD objects, not <type>value_type</type> pointers. </para> diff --git a/libstdc++-v3/doc/xml/manual/configure.xml b/libstdc++-v3/doc/xml/manual/configure.xml index 6b1efa8006e..5d893d7a1be 100644 --- a/libstdc++-v3/doc/xml/manual/configure.xml +++ b/libstdc++-v3/doc/xml/manual/configure.xml @@ -172,7 +172,7 @@ <listitem><para>Enables link-type checks for the availability of the clock_gettime clocks, used in the implementation of [time.clock], and of the nanosleep and sched_yield functions, used in the - implementation of [thread.thread.this] of the current C++0x draft. + implementation of [thread.thread.this] of the 2011 ISO C++ standard. The choice OPTION=yes checks for the availability of the facilities in libc and libposix4. In case of need the latter is also linked to libstdc++ as part of the build process. OPTION=rt also searches diff --git a/libstdc++-v3/doc/xml/manual/debug_mode.xml b/libstdc++-v3/doc/xml/manual/debug_mode.xml index c58bde34065..89b2c31b811 100644 --- a/libstdc++-v3/doc/xml/manual/debug_mode.xml +++ b/libstdc++-v3/doc/xml/manual/debug_mode.xml @@ -267,12 +267,12 @@ which always works correctly. </tgroup> </table> -<para>In addition, when compiling in C++0x mode, these additional +<para>In addition, when compiling in C++11 mode, these additional containers have additional debug capability. </para> <table frame="all"> -<title>Debugging Containers C++0x +Debugging Containers C++11 @@ -588,7 +588,7 @@ template<typename _Tp, typename _Allocator = allocator<_Tp> Achieving link- and run-time coexistence is not a trivial implementation task. To achieve this goal we required a small - extension to the GNU C++ compiler (since incorporated into the C++0x language specification, described in the GCC Manual for the C++ language as + extension to the GNU C++ compiler (since incorporated into the C++11 language specification, described in the GCC Manual for the C++ language as namespace association), and a complex organization of debug- and release-modes. The end result is that we have achieved per-use @@ -630,7 +630,7 @@ namespace std defined in the namespace __cxx1998) and also the debug-mode container. The debug-mode container is defined within the namespace __debug, which is associated with namespace -std via the C++0x namespace association language feature. This +std via the C++11 namespace association language feature. This method allows the debug and release versions of the same component to coexist at compile-time and link-time without causing an unreasonable maintenance burden, while minimizing confusion. Again, this boils down diff --git a/libstdc++-v3/doc/xml/manual/diagnostics.xml b/libstdc++-v3/doc/xml/manual/diagnostics.xml index 1a6a3f17dc2..fd21442b992 100644 --- a/libstdc++-v3/doc/xml/manual/diagnostics.xml +++ b/libstdc++-v3/doc/xml/manual/diagnostics.xml @@ -117,7 +117,7 @@ Please note that the checks are based on the requirements in the original - C++ standard, some of which have changed in the upcoming C++0x revision. + C++ standard, some of which have changed in the new C++11 revision. Additionally, some correct code might be rejected by the concept checks, for example template argument types may need to be complete when used in a template definition, rather than at the point of instantiation. diff --git a/libstdc++-v3/doc/xml/manual/evolution.xml b/libstdc++-v3/doc/xml/manual/evolution.xml index 08876deb18a..145c11f28cc 100644 --- a/libstdc++-v3/doc/xml/manual/evolution.xml +++ b/libstdc++-v3/doc/xml/manual/evolution.xml @@ -399,7 +399,7 @@ Backward include edit. - Added in C++0x + Added in C++11 auto_ptr.h and binders.h diff --git a/libstdc++-v3/doc/xml/manual/extensions.xml b/libstdc++-v3/doc/xml/manual/extensions.xml index fb2f5ca83e8..9932a020dd9 100644 --- a/libstdc++-v3/doc/xml/manual/extensions.xml +++ b/libstdc++-v3/doc/xml/manual/extensions.xml @@ -201,7 +201,7 @@ extensions, be aware of two things: The SGI hashing classes hash_set and hash_set have been deprecated by the unordered_set, unordered_multiset, unordered_map, - unordered_multimap containers in TR1 and the upcoming C++0x, and + unordered_multimap containers in TR1 and C++11, and may be removed in future releases. diff --git a/libstdc++-v3/doc/xml/manual/intro.xml b/libstdc++-v3/doc/xml/manual/intro.xml index 36e07b4370f..7621de9c2b1 100644 --- a/libstdc++-v3/doc/xml/manual/intro.xml +++ b/libstdc++-v3/doc/xml/manual/intro.xml @@ -29,8 +29,8 @@ - - + + @@ -577,7 +577,7 @@ requirements of the license of GCC. std::complex over-encapsulated Add the real(T) and imag(T) - members; in C++0x mode, also adjust the existing + members; in C++11 mode, also adjust the existing real() and imag() members and free functions. @@ -709,7 +709,7 @@ requirements of the license of GCC. 550: What should the return type of pow(float,int) be? - In C++0x mode, remove the pow(float,int), etc., signatures. + In C++11 mode, remove the pow(float,int), etc., signatures. 586: @@ -739,7 +739,7 @@ requirements of the license of GCC. 691: const_local_iterator cbegin, cend missing from TR1 - In C++0x mode add cbegin(size_type) and cend(size_type) + In C++11 mode add cbegin(size_type) and cend(size_type) to the unordered containers. @@ -764,7 +764,7 @@ requirements of the license of GCC. 761: unordered_map needs an at() member function - In C++0x mode, add at() and at() const. + In C++11 mode, add at() and at() const. 775: @@ -776,13 +776,13 @@ requirements of the license of GCC. 776: Undescribed assign function of std::array - In C++0x mode, remove assign, add fill. + In C++11 mode, remove assign, add fill. 781: std::complex should add missing C99 functions - In C++0x mode, add std::proj. + In C++11 mode, add std::proj. 809: @@ -794,7 +794,7 @@ requirements of the license of GCC. 844: complex pow return type is ambiguous - In C++0x mode, remove the pow(complex<T>, int) signature. + In C++11 mode, remove the pow(complex<T>, int) signature. 853: diff --git a/libstdc++-v3/doc/xml/manual/policy_data_structures.xml b/libstdc++-v3/doc/xml/manual/policy_data_structures.xml index 4ecb933a0e5..11fad5e018d 100644 --- a/libstdc++-v3/doc/xml/manual/policy_data_structures.xml +++ b/libstdc++-v3/doc/xml/manual/policy_data_structures.xml @@ -1365,7 +1365,7 @@ __gnu_pbds::cc_hash_table instead of std::unordered_map, since unordered map does not necessarily mean a hash-based map as implied by - the C++ library (C++0x or TR1). For example, list-based associative + the C++ library (C++11 or TR1). For example, list-based associative containers, which are very useful for the construction of "multimaps," are also unordered. diff --git a/libstdc++-v3/doc/xml/manual/shared_ptr.xml b/libstdc++-v3/doc/xml/manual/shared_ptr.xml index 78cc8c4ba83..6e3392f88ee 100644 --- a/libstdc++-v3/doc/xml/manual/shared_ptr.xml +++ b/libstdc++-v3/doc/xml/manual/shared_ptr.xml @@ -32,14 +32,6 @@ and implements shared ownership semantics. circular-linked-list. - - At the time of writing the C++0x working paper doesn't mention how - threads affect shared_ptr, but it is likely to follow the existing - practice set by boost::shared_ptr. The - shared_ptr in libstdc++ is derived from Boost's, so the same rules - apply. - -
@@ -163,10 +155,10 @@ that simplifies the implementation slightly. -C++0x-only features are: rvalue-ref/move support, allocator support, +C++11-only features are: rvalue-ref/move support, allocator support, aliasing constructor, make_shared & allocate_shared. Additionally, the constructors taking auto_ptr parameters are -deprecated in C++0x mode. +deprecated in C++11 mode. @@ -293,20 +285,20 @@ used when libstdc++ is built without --enable-threads. -
Dual C++0x and TR1 Implementation +
Dual C++11 and TR1 Implementation -The interface of tr1::shared_ptr was extended for C++0x +The interface of tr1::shared_ptr was extended for C++11 with support for rvalue-references and the other features from N2351. The _Sp_counted_base base class is implemented in tr1/boost_sp_shared_count.h and is common to the TR1 -and C++0x versions of shared_ptr. +and C++11 versions of shared_ptr. The classes derived from _Sp_counted_base (see Class Hierarchy -above) and __shared_count are implemented separately for C++0x +above) and __shared_count are implemented separately for C++11 and TR1, in bits/shared_ptr.h and tr1/shared_ptr.h respectively. @@ -314,9 +306,9 @@ and TR1, in bits/shared_ptr.h and The TR1 implementation is considered relatively stable, so is unlikely to change unless bug fixes require it. If the code that is common to both -C++0x and TR1 modes needs to diverge further then it might be necessary to +C++11 and TR1 versions needs to diverge further then it might be necessary to duplicate _Sp_counted_base and only make changes to -the C++0x version. +the C++11 version.
@@ -332,9 +324,9 @@ the C++0x version. As noted in N2351, these functions can be implemented non-intrusively using the alias constructor. However the aliasing constructor is only available -in C++0x mode, so in TR1 mode these casts rely on three non-standard +in C++11 mode, so in TR1 mode these casts rely on three non-standard constructors in shared_ptr and __shared_ptr. -In C++0x mode these constructors and the related tag types are not needed. +In C++11 mode these constructors and the related tag types are not needed. @@ -431,7 +423,7 @@ the following types, depending on how the shared_ptr is constructed. The shared_ptr atomic access - clause in the C++0x working draft is not implemented in GCC. + clause in the C++11 standard is not implemented in GCC. @@ -445,7 +437,7 @@ the following types, depending on how the shared_ptr is constructed. Unlike Boost, this implementation does not use separate classes for the pointer+deleter and pointer+deleter+allocator cases in - C++0x mode, combining both into _Sp_counted_deleter and using + C++11 mode, combining both into _Sp_counted_deleter and using allocator when the user doesn't specify an allocator. If it was found to be beneficial an additional class could easily be added. With the current implementation, diff --git a/libstdc++-v3/doc/xml/manual/status_cxx200x.xml b/libstdc++-v3/doc/xml/manual/status_cxx200x.xml deleted file mode 100644 index db4ecb69019..00000000000 --- a/libstdc++-v3/doc/xml/manual/status_cxx200x.xml +++ /dev/null @@ -1,2621 +0,0 @@ -
- - -C++ 200x - - - ISO 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 mainline GCC SVN, not in any -particular release. - - - - - -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 - Y - - - - 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 - 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 - Partial - Missing rebind - - - - 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 - Partial - Missing rebind_alloc and rebind_traits - - - 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 ratios - Y - - - - 20.10.5 - Comparison of ratios - 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 - Partial - - - - 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 - Partial - - - - 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> - 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 - Partial - Missing emplace members - - - - 23.2.5 - Unordered associative containers - Partial - Missing emplace members - - - 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 - 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 - 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 - 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 - Timed waiting functions do not return future_status - - - - 30.6.7 - Class template shared_future - Partial - Timed waiting functions do not return 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 - - - - - - -
- - -
diff --git a/libstdc++-v3/doc/xml/manual/status_cxx2011.xml b/libstdc++-v3/doc/xml/manual/status_cxx2011.xml new file mode 100644 index 00000000000..2502b07bd7c --- /dev/null +++ b/libstdc++-v3/doc/xml/manual/status_cxx2011.xml @@ -0,0 +1,2622 @@ +
+ + +C++ 2011 + + + ISO 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 +__GXX_EXPERIMENTAL_CXX0X__ 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. + + + + + +C++ 2011 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 + Y + + + + 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 + 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 + Partial + Missing rebind + + + + 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 + Partial + Missing rebind_alloc and rebind_traits + + + 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 ratios + Y + + + + 20.10.5 + Comparison of ratios + 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 + Partial + + + + 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 + Partial + + + + 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> + 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 + Partial + Missing pop_back + + + 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 + Partial + Missing emplace members + + + + 23.2.5 + Unordered associative containers + Partial + Missing emplace members + + + 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 + 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 + 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 + 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 + Timed waiting functions do not return future_status + + + + 30.6.7 + Class template shared_future + Partial + Timed waiting functions do not return 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 + + + + + + +
+ + +
diff --git a/libstdc++-v3/doc/xml/manual/strings.xml b/libstdc++-v3/doc/xml/manual/strings.xml index 4d9fc64f766..1387189ece4 100644 --- a/libstdc++-v3/doc/xml/manual/strings.xml +++ b/libstdc++-v3/doc/xml/manual/strings.xml @@ -359,7 +359,7 @@ stringtok(Container &container, string const &in, entry) but the regular copy constructor cannot be used because libstdc++'s string is Copy-On-Write. - In C++0x mode you can call + In C++11 mode you can call s.shrink_to_fit() to achieve the same effect as s.reserve(s.size()). diff --git a/libstdc++-v3/doc/xml/manual/test.xml b/libstdc++-v3/doc/xml/manual/test.xml index 84664107db3..88bf14dffef 100644 --- a/libstdc++-v3/doc/xml/manual/test.xml +++ b/libstdc++-v3/doc/xml/manual/test.xml @@ -896,7 +896,7 @@ as the allocator type. - C++0x Container Requirements. + C++11 Container Requirements. @@ -924,7 +924,7 @@ as the allocator type.
-C++0x Requirements Test Sequence Descriptions +C++11 Requirements Test Sequence Descriptions diff --git a/libstdc++-v3/doc/xml/manual/using.xml b/libstdc++-v3/doc/xml/manual/using.xml index 49541165868..f081ed4bc44 100644 --- a/libstdc++-v3/doc/xml/manual/using.xml +++ b/libstdc++-v3/doc/xml/manual/using.xml @@ -8,7 +8,7 @@ The set of features available in the GNU C++ library is shaped by - several GCC + several GCC Command Options. Options that impact libstdc++ are enumerated and detailed in the table below. @@ -43,12 +43,12 @@ - -std=c++0x - Use the working draft of the upcoming ISO C++0x standard. + -std=c++11 + Use the 2011 ISO C++ standard. - -std=gnu++0x + -std=gnu++11 As directly above, with GNU extensions. @@ -64,7 +64,7 @@ -pthread or -pthreads - For ISO C++0x <thread>, <future>, + For ISO C++11 <thread>, <future>, <mutex>, or <condition_variable>. @@ -108,8 +108,7 @@ Two dialects of standard headers are supported, corresponding to - the 1998 standard as updated for 2003, and the draft of the - upcoming 200x standard. + the 1998 standard as updated for 2003, and the current 2011 standard. @@ -218,13 +217,13 @@
-C++0x include files. These are only available in C++0x compilation -mode, i.e. -std=c++0x or -std=gnu++0x. +C++11 include files. These are only available in C++11 compilation +mode, i.e. -std=c++11 or -std=gnu++11. -C++ 200x Library Headers +C++ 2011 Library Headers @@ -310,7 +309,7 @@ mode, i.e. -std=c++0x or -std=gnu++0x.

-C++ 200x Library Headers for C Library Facilities +C++ 2011 Library Headers for C Library Facilities @@ -632,22 +631,22 @@ possible. It's an all-or-nothing affair. Thus, code like #include <functional> -Implies C++0x mode. To use the entities in <array>, the C++0x -compilation mode must be used, which implies the C++0x functionality +Implies C++11 mode. To use the entities in <array>, the C++11 +compilation mode must be used, which implies the C++11 functionality (and deprecations) in <functional> will be present. Second, the other headers can be included with either dialect of -the standard headers, although features and types specific to C++0x -are still only enabled when in C++0x compilation mode. So, to use +the standard headers, although features and types specific to C++11 +are still only enabled when in C++11 compilation mode. So, to use rvalue references with __gnu_cxx::vstring, or to use the debug-mode versions of std::unordered_map, one must use -the std=gnu++0x compiler flag. (Or std=c++0x, of course.) +the std=gnu++11 compiler flag. (Or std=c++11, of course.) -A special case of the second rule is the mixing of TR1 and C++0x +A special case of the second rule is the mixing of TR1 and C++11 facilities. It is possible (although not especially prudent) to -include both the TR1 version and the C++0x version of header in the +include both the TR1 version and the C++11 version of header in the same translation unit: @@ -656,7 +655,7 @@ same translation unit: #include <type_traits> - Several parts of C++0x diverge quite substantially from TR1 predecessors. + Several parts of C++11 diverge quite substantially from TR1 predecessors. @@ -841,7 +840,7 @@ g++ -Winvalid-pch -I. -include stdc++.h -H -g -O2 hello.cc -o test.exe removes older ARM-style iostreams code, and other anachronisms from the API. This macro is dependent on the version of the standard being tracked, and as a result may give different results for - -std=c++98 and -std=c++0x. This may + -std=c++98 and -std=c++11. This may be useful in updating old C++ code which no longer meet the requirements of the language, or for checking current code against new language standards. @@ -1093,7 +1092,7 @@ namespace gtk In the - C++0x dialect add + C++11 dialect add