______________________________________________________________________

  17   Library introduction                      [lib.library]

  ______________________________________________________________________

1 This clause describes the contents of the C++ Standard library, how  a
  well-formed C++ program makes use of the library, and how a conforming
  implementation may provide the entities in the library.

2 The C++ Standard library provides an extensible  framework,  and  con­
  tains  components  for:  language support, diagnostics, general utili­
  ties, strings, locales, containers, iterators,  algorithms,  numerics,
  and  input/output.   The  language  support components are required by
  certain  parts  of  the  C++  language,  such  as  memory   allocation
  (_expr.new_, _expr.delete_) and exception processing (_except.intro_).

3 The general utilities include components used by  other  library  ele­
  ments, such as a predefined storage allocator for dynamic storage man­
  agement (_basic.stc.dynamic_).  The diagnostics components  provide  a
  consistent  framework for reporting errors in a C++ program, including
  predefined exception classes.

4 The strings components provide support for  manipulating  text  repre­
  sented  as  sequences  of  type  char,  sequences  of type wchar_t, or
  sequences of any other ``character-like'' type.  The localization com­
  ponents  extend Internationalization support for such text processing.

5 The containers, iterators, and algorithms provide a C++  program  with
  access  to a subset of the most widely used algorithms and data struc­
  tures.

6 Numeric algorithms and the complex number  components  extend  support
  for  numeric  processing.  The valarray components provide support for
  n-at-a-time processing, potentially implemented as parallel operations
  on platforms that support such processing.

7 The  iostreams  components  are  the primary mechanism for C++ program
  input/output.  They can easily be used  with  other  elements  of  the
  library, particularly strings, locales, and iterators.

8 This  library  also  makes  available the facilities of the Standard C
  library, suitably adjusted to ensure static type safety.

9 The following subclauses describe the definitions (_lib.definitions_),
  and  method  of description (_lib.description_) for the library.  Sub­
  clauses  (_lib.requirements_)  and  (_lib.language.support_)   through
  (_lib.input.output_)  specify the contents of the library, and library
  requirements and constraints on  both  well-formed  C++  programs  and

  conforming implementations.

  17.1  Definitions                                    [lib.definitions]

  --category:  A  logical  collection  of  library entities.  Subclauses
    _lib.language.support_ through _lib.input.output_  each  describe  a
    single category of entities within the library.

  --comparison  function:  An operator function (_over.oper_) for any of
    the equality (_expr.eq_) or relational (_expr.rel_) operators.

  --component: A group of library entities directly related as  members,
    parameters, or return types.  For example, the class wstring and the
    non-member functions that operate on wide-character strings  can  be
    considered the wstring component.

  --default  behavior: A description of replacement function and handler
    function semantics.  Any specific behavior provided by the implemen­
    tation, within the scope of the required behavior.

  --handler  function:  A non- reserved function whose definition may be
    provided by a C++ program.  A C++ program may  designate  a  handler
    function  at various points in its execution, by supplying a pointer
    to the function when calling  any  of  the  library  functions  that
    install handler functions (_lib.language.support_).

  --modifier  function:  A  class  member function (_class.mfct_), other
    than constructors, assignment, or destructor, that alters the  state
    of  an  object of the class.  The state of an object can be obtained
    by using one or more observer functions

  --observer function:  A  class  member  function  (_class.mfct_)  that
    accesses  the  state  of  an object of the class, but does not alter
    that state.  Observer functions are specified as const member  func­
    tions (_class.this_).

  --replacement  function:  A non- reserved function whose definition is
    provided by a C++ program.  Only one definition for such a  function
    is  in  effect  for  the duration of the program's execution, as the
    result of creating the program (_lex.phases_) and resolving the def­
    initions of all translation units (_basic.link_).

  --required behavior: A description of replacement function and handler
    function semantics, applicable to both the behavior provided by  the
    implementation  and the behavior that shall be provided by any func­
    tion definition in the program.  If a function defined in a C++ pro­
    gram  fails  to  meet  the  required  behavior when it executes, the
    behavior is undefined.

  --reserved function: A function, specified as part of the C++ Standard
    library,  that must be defined by the implementation.  If a C++ pro­
    gram provides a definition for any reserved  function,  the  results
    are undefined.  Subclause _intro.defs_ defines additional terms used

    elsewhere in this International Standard.

  17.2  Method of description (Informative)            [lib.description]

1 This subclause describes the conventions  used  to  describe  the  C++
  Standard  library.   It  describes  the  structures  of  the normative
  clauses     _lib.language.support_     through      _lib.input.output_
  (_lib.structure_), conventions used to specify constraints on template
  arguments(_lib.template.constraints_), conventions to  describe  types
  defined  by  an implementation (_lib.implementation.types_), and other
  editorial conventions (_lib.res.and.conventions_).

  17.2.1  Structure of each subclause                    [lib.structure]

1 Subclause _lib.organization_ provides a summary of  the  C++  Standard
  library's contents.  Other Library clauses provide detailed specifica­
  tions for each of the components in the library, as shown in Table 1:

                       Table 1--Library Categories

                Clause                   Category

                _lib.language.support_   Language support
                _lib.diagnostics_        Diagnostics
                _lib.utilities_          General utilities
                _lib.strings_            Strings
                _lib.localization_       Localization
                _lib.containers_         Containers
                _lib.iterators_          Iterators
                _lib.algorithms_         Algorithms
                _lib.numerics_           Numerics
                _lib.input.output_       Input/output

2 Each Library clause contains the following elements, as applicable:1)

  --Summary

  --Requirements

  --Detailed specifications

  --References to the Standard C library

  _________________________
  1) To save space, items that do not apply to  a  clause  are  omitted.
  For example, if a clause does not specify any requirements on template
  arguments, there will be no ``Requirements'' subclause.

  17.2.1.1  Summary                              [lib.structure.summary]

1 The Summary provides a synopsis of the category,  and  introduces  the
  first-level subclauses.  Each subclause also provides a summary, list­
  ing the headers specified in the subclause and  the  library  entities
  provided in each header.

2 Paragraphs  labelled  ``Note(s):'' or ``Example(s):'' are informative,
  other paragraphs are normative.

3 The summary and the  detailed  specifications  are  presented  in  the
  order:

  --Macros

  --Values

  --Types

  --Classes

  --Functions

  --Objects

  17.2.1.2  Requirements                    [lib.structure.requirements]

1 The  library can be extended by a C++ program.  Each clause, as appli­
  cable, describes the requirements  that  such  extensions  must  meet.
  Such extensions are generally one of the following:

  --Template arguments

  --Derived classes

  --Containers, iterators, and/or algorithms that meet an interface con­
    vention

2 The string and iostreams components use an explicit representation  of
  operations  required of template arguments.  They use a template class
  name XXX_traits to define these constraints.

3 Interface convention requirements are stated as generally as possible.
  Instead  of  stating  ``class X has to define a member function opera­
  tor++(), the interfce requires ``for any object x of class X,  ++x  is
  defined.''   That  is,  whether  the  operator is a member or a global
  function is unspecified.

4 Requirements are stated in terms of  well-defined  expressions,  which
  define  valid  terms  of the types that satisfy the requirements.  For
  every set of requirements there is a table that specifies  an  initial
  set  of  the valid expressions and their semantics.  Any generic algo­
  rithm that uses the requirements is described in terms  of  the  valid
  expressions for its formal type parameters.

5 In  some  cases  the  semantic requirements are presented as C++ code.
  Such code is intended as a specification of equivalence of a construct
  to another construct, not necessarily as the way the construct must be
  implemented.2)

  17.2.1.3  Specifications                [lib.structure.specifications]

1 The detailed specifications each contain the following elements:3)

  --Name and brief description

  --Synopsis (class definition or function prototype, as appropriate)

  --Restrictions on template arguments, if any

  --Decription of class invariants

  --Description of function semantics

2 Descriptions  of  class  member  functions  follow   the   order   (as
  appropriate):4)

  --Constructor(s) and destructor

  --Copying & assignment functions

  --Comparison functions

  --Modifier functions

  --Observer functions

  --Operators and other non-member functions

3 Descriptions  of function semantics contain the following elements (as
  appropriate):5)

  --Requires, the preconditions for calling the function

  --Effects, the actions performed by the function

  --Postconditions, the observable results established by the function
  _________________________
  2) Although in some cases the code given is unambiguously the  optimum
  implementation.
  3) The form of these specifications was designed to follow the conven­
  tions established by existing C++ library vendors.
  4) To save space, items that do not apply to a class are omitted.  For
  example, if a class does not specify any comparison  functions,  there
  will be no ``Comparison functions'' subclause.
  5) To save space, items that do not apply to a function  are  omitted.
  For  example,  if a function does not specify any preconditions, there
  will be no ``Requires'' paragraph.

  --Returns, a description of the value(s) returned by the function

  --Throws, any exceptions thrown by the function,  and  the  conditions
    that would cause the exception

4 Complexity, the time and/or space complexity of the function

5 For non-reserved replacement and handler functions, this clause speci­
  fies two behaviors for the functions in question: their  required  and
  default  behavior.   The default behavior describes a function defini­
  tion provided by the implementation.  The required behavior  describes
  the  semantics  of a function definition provided by either the imple­
  mentation or a C++ program.  Where no distinction is  explicitly  made
  in the description, the behavior described is the required behavior.

6 If  an operation is required to be linear time, it means no worse than
  linear time, and a constant time operation satisfies the  requirement.

  17.2.1.4  C Library                           [lib.structure.see.also]

1 Paragraphs labelled ``SEE ALSO:'' contain cross-references to the rel­
  evant portions of this Standard and  the  ISO  C  standard,  which  is
  incorporated into this Standard by reference.

  17.2.2  Other conventions                            [lib.conventions]

1 This   subclause  describes  several  editorial  conventions  used  to
  describe the contents of the C++ Standard library.  These  conventions
  are       for       describing       implementation-defined      types
  (_lib.type.descriptions_), class and class template  member  functions
  (_lib.functions.within.classes_),            private           members
  (_lib.objects.within.classes_),       and       convenient       names
  (_lib.unreserved.names_).

  +-------                 BEGIN BOX 1                -------+
  ISSUE:  this subclause needs more discussion by the Library WG.
  +-------                  END BOX 1                 -------+

  17.2.2.1  Type descriptions                    [lib.type.descriptions]

1 The  Requirements  subclauses  describe names that are used to specify
  constraints on template arguments.  These names are used,  instead  of
  the keyword class, to describe the types that may be supplied as argu­
  ments by a C++ program when instantiating template components from the
  library.

2 Certain  types defined in this clause are used to describe implementa­
  tion-defined types.  They are based on other  types,  but  with  added
  constraints.

  17.2.2.1.1  Enumerated types                    [lib.enumerated.types]

1 Several  types  defined  in  Clause  _lib.input.output_ are enumerated
  types.  Each enumerated type may be implemented as an  enumeration  or
  as a synonym for an enumeration.

2 The enumerated type enumerated can be written:
          enum secret {
                  V0, V1, V2, V3, .....};
          typedef secret enumerated;
          static const enumerated C0(V0);
          static const enumerated C1(V1);
          static const enumerated C2(V2);
          static const enumerated C3(V3);
                  .....

3 Here,  the  names C0, C1, etc.  represent enumerated elements for this
  particular enumerated type.  All such elements have distinct values.

  17.2.2.1.2  Bitmask types                          [lib.bitmask.types]

1 Several types defined in Clause _lib.input.output_ are bitmask  types.
  Each  bitmask type can be implemented as an enumerated type that over­
  loads certain operators.

2 The bitmask type bitmask can be written:
          enum secret {
                  V0 = 1 << 0, V1 = 1 << 1, V2 = 1 << 2, V3 = 1 << 3, .....};
          typedef secret bitmask;
          static const bitmask C0(V0);
          static const bitmask C1(V1);
          static const bitmask C2(V2);
          static const bitmask C3(V3);
                  .....
          bitmask& operator&=(bitmask& X, bitmask Y)
                  {X = (bitmask)(X & Y); return (X); }
          bitmask& operator|=(bitmask& X, bitmask Y)
                  {X = (bitmask)(X | Y); return (X); }
          bitmask& operator^=(bitmask& X, bitmask Y)
                  {X = (bitmask)(X ^ Y); return (X); }
          bitmask operator&(bitmask X, bitmask Y)
                  {return ((bitmask)(X & Y)); }
          bitmask operator|(bitmask X, bitmask Y)
                  {return ((bitmask)(X | Y)); }
          bitmask operator^(bitmask X, bitmask Y)
                  {return ((bitmask)(X ^ Y)); }
          bitmask operator~(bitmask X)
                  {return ((bitmask)~X); }

3 Here, the names C0, C1, etc.  represent bitmask elements for this par­
  ticular  bitmask  type.   All  such elements have distinct values such
  that, for any pair Ci and Cj, Ci & Ci is nonzero and Ci & Cj is  zero.

4 The following terms apply to objects and values of bitmask types:

  --To  set  a value Y in an object X is to evaluate the expression X |=
    Y.

  --To clear a value Y in an object X is to evaluate the expression X &=
    ~Y.

  --The  value  Y  is  set  in  the  object X if the expression X & Y is
    nonzero.

  17.2.2.1.3  Character sequences                    [lib.character.seq]

1 The Standard C library makes widespread use of characters and  charac­
  ter sequences that follow a few uniform conventions:

  --A  letter  is any of the 26 lowercase or 26 uppercase letters in the
    basic execution character set.6)

  --The  decimal-point  character is the (single-byte) character used by
    functions that convert between a  (single-byte)  character  sequence
    and  a  value of one of the floating-point types.  It is used in the
    character sequence to denote the beginning of a fractional part.  It
    is  represented  in  this clause by a period, '.', which is also its
    value in the "C" locale, but may change during program execution  by
    a   call   to   setlocale(int,   const  char*),  declared  in  <clo­
    cale>(_lib.c.locales_).

  --A character sequence is an array object (_dcl.array_) A that can  be
    declared as T A[N], where T is any of the types char, unsigned char,
    or signed char (_basic.fundamental_), optionally  qualified  by  any
    combination of const or volatile.  The initial elements of the array
    have defined contents up to and including an element  determined  by
    some predicate.  A character sequence can be designated by a pointer
    value S that points to its first element.

  17.2.2.1.3.1  Byte strings                          [lib.byte.strings]

1 A null-terminated byte string, or NTBS, is a character sequence  whose
  highest-addressed element with defined content has the value zero (the
  terminating null character).7)

2 The  length of an NTBS is the number of elements that precede the ter­
  minating null character.  An empty NTBS has a length of zero.

  _________________________
  6) Note that this definition differs from the definition in ISO C sub­
  clause 7.1.1.
  7) Many of the objects manipulated by function signatures declared  in
  <cstring>(_lib.c.strings_) are character sequences or NTBSs.  The size
  of some of these character sequences is limited  by  a  length  value,
  maintained separately from the character sequence.

3 The value of an NTBS is the sequence of values of the elements  up  to
  and including the terminating null character.

4 A static NTBS is an NTBS with static storage duration.8)

  17.2.2.1.3.2  Multibyte strings                [lib.multibyte.strings]

1 A  null-terminated multibyte string, or NTMBS, is an NTBS that consti­
  tutes a sequence of valid multibyte characters, beginning  and  ending
  in the initial shift state.9)

2 A static NTMBS is an NTMBS with static storage duration.

  17.2.2.1.3.3  Wide-character sequences           [lib.wide.characters]

1 A  wide-character sequence is an array object (_dcl.array_) A that can
  be declared as T A[N], where T is type  wchar_t  (_basic.fundmental_),
  optionally  qualified  by  any  combination of const or volatile.  The
  initial elements of the array have defined contents up to and  includ­
  ing an element determined by some predicate.  A character sequence can
  be designated by a pointer value S that designates its first  element.

2 A null-terminated wide-character string, or NTWCS, is a wide-character
  sequence whose highest-addressed element with defined content has  the
  value zero.10)

3 The length of an NTWCS is the number of elements that precede the ter­
  minating null wide character.  An empty NTWCS has a length of zero.

4 The  value of an NTWCS is the sequence of values of the elements up to
  and including the terminating null character.

5 A static NTWCS is an NTWCS with static storage duration.11)

  17.2.2.2  Functions within classes      [lib.functions.within.classes]

1 For  the  sake  of  exposition, Clauses _lib.language.support_ through
  _lib.input.output_ do not describe copy constructors, assignment oper­
  ators,  or  (non-virtual) destructors with the same apparent semantics
  as those that can be generated by default (_class.ctor_, _class.dtor_,
  _class.copy_).

2 It is unspecified whether the implementation provides explicit defini­
  tions for such member function signatures, or for virtual  destructors
  _________________________
  8) A string literal, such as abc, is a static NTBS.
  9)  An  NTBS  that  contains  characters only from the basic execution
  character set is also an NTMBS.  Each multibyte  character  then  con­
  sists of a single byte.
  10) Many of the objects manipulated by function signatures declared in
  <cwchar> are wide-character sequences or NTWCSs.
  11) A wide string literal, such as L"abc", is a static NTWCS.

  that can be generated by default.

3 For  the  sake  of  exposition, Clauses _lib.language.support_ through
  _lib.input.output_ repeat in derived class  declarations  any  virtual
  member  functions  inherited from a base class.  All such declarations
  are enclosed in a comment that ends with inherited, as in:
          //      virtual void do_raise();        inherited

4 If a virtual member function in the  base  class  meets  the  semantic
  requirements  of  the  derived  class,  it  is unspecified whether the
  derived class provides an overriding definition for the function  sig­
  nature.

  17.2.2.3  Private members                 [lib.objects.within.classes]

1 Objects  of  certain  classes  are  sometimes required by the external
  specifications of their classes to store data,  apparently  in  member
  objects.  For the sake of exposition, this clause provides representa­
  tive declarations,  and  semantic  requirements,  for  private  member
  objects  of  classes  that  meet  the  external  specifications of the
  classes.  The declarations for such member objects and the definitions
  of  related member types in this clause are enclosed in a comment that
  ends with exposition only, as in:
          //      streambuf* sb;  exposition only

2 Any alternate implementation that provides equivalent external  behav­
  ior is equally acceptable.

  +-------                 BEGIN BOX 2                -------+
  Editorial  Proposal:  Eliminate the ``exposition only'' implementation
  specification.  Instead,  describe  member  function  pre-  and  post-
  conditions  in  terms of observer functions.  Retained state, and side
  effects to that state, will require careful wording.
  +-------                  END BOX 2                 -------+

  17.2.2.4  Convenient names                      [lib.unreserved.names]

1 Certain types defined in C headers are  sometimes  needed  to  express
  declarations  in other headers, where the required type names are nei­
  ther defined nor reserved.  In such cases, the implementation provides
  a  synonym  for the required type, using a name reserved to the imple­
  mentation.  Such cases are explicitly stated in this clause, and indi­
  cated by writing the required type name in constant-width italic char­
  acters.

2 Certain names are sometimes convenient to supply for the sake of expo­
  sition,  in the descriptions in this clause, even though the names are
  neither defined nor  reserved.   In  such  cases,  the  implementation
  either  omits  the  name,  where that is permitted, or provides a name
  reserved to the implementation.  Such cases are also indicated in this
  clause by writing the convenient name in constant-width italic charac­
  ters.

3 For example:

4 The class filebuf, defined in <fstream>, is  described  as  containing
  the private member object:
                  FILE* file;

5 This  notation indicates that the member file is a pointer to the type
  FILE, defined in <cstdio>, but the names file  and  FILE  are  neither
  defined  nor reserved in <fstream>.  An implementation need not imple­
  ment class filebuf with an explicit member of type FILE*.  If it  does
  so,  it can choose 1) to replace the name file with a name reserved to
  the implementation, and 2) to replace FILE  with  an  incomplete  type
  whose name is reserved, such as in:
                  struct _Filet* _Fname;

6 If  the  program needs to have type FILE defined, it must also include
  <cstdio>, which completes the definition of _Filet.

  17.3  Library-wide requirements                     [lib.requirements]

1 This subclause specifies requirements that apply  to  the  entire  C++
  Standard     library.     Clauses    _lib.language.support_    through
  _lib.input.output_ specify the  requirements  of  individual  entities
  within the library.

2 The following subclauses describe the library's contents and organiza­
  tion (_lib.organization_), how well-formed C++ programs gain access to
  library   entities   (_lib.using_),   constraints   on  such  programs
  (_lib.constraints_), and  constraints  on  conforming  implementations
  (_lib.conforming_).

  17.3.1  Library contents and organization           [lib.organization]

1 This  subclause  provides a summary of the entities defined in the C++
  Standard library.  Subclause _lib.contents_ provides  an  alphabetical
  listing of entities by type, while subclause _lib.headers_ provides an
  alphabetical listing of library headers.

  17.3.1.1  Library contents                              [lib.contents]

1 The C++ Standard library provides definitions for the following  types
  of entities:

  --Macros

  --Values

  --Types

  --Templates

  --Classes

  --Functions

  --Objects

2 All library entities shall be defined within the namespace std.

3 The  C++  Standard  library  provides  54 standard macros, as shown in
  Table 2.

4 The header names (enclosed in < and >) indicate that the macro may  be
  defined in more than one header.  All such definitions shall be equiv­
  alent (_basic.def.odr_).

                         Table 2--Standard Macros

  +----------------------------------------------------------------------------+
  |assert           LC_ALL           NULL <cstring>   SIGILL    va_arg         |
  |BUFSIZ           LC_COLLATE       NULL <ctime>     SIGINT    va_end         |
  |CLOCKS_PER_SEC   LC_CTYPE         NULL <cwchar>    SIGSEGV   va_start       |
  |EDOM             LC_MONETARY      offsetof         SIGTERM   WCHAR_MAX      |
  |EOF              LC_NUMERIC       RAND_MAX         SIG_DFL   WCHAR_MIN      |
  |ERANGE           LC_TIME          SEEK_CUR         SIG_ERR   WEOF <cwchar>  |
  |EXIT_FAILURE     L_tmpnam         SEEK_END         SIG_IGN   WEOF <cwctype> |
  |EXIT_SUCCESS     MB_CUR_MAX       SEEK_SET         stderr    _IOFBF         |
  |FILENAME_MAX     NDEBUG           setjmp           stdin     _IOLBF         |
  |FOPEN_MAX        NULL <cstddef>   SIGABRT          stdout    _IONBF         |
  |HUGE_VAL         NULL <cstdio>    SIGFPE           TMP_MAX                  |
  +----------------------------------------------------------------------------+

5 The C++ Standard library provides 46  standard  values,  as  shown  in
  Table 3:

                         Table 3--Standard Values

     +---------------------------------------------------------------+
     |CHAR_BIT         FLT_DIG          INT_MIN           MB_LEN_MAX |
     |CHAR_MAX         FLT_EPSILON      LDBL_DIG          NPOS       |
     |CHAR_MIN         FLT_MANT_DIG     LDBL_EPSILON      SCHAR_MAX  |
     |DBL_DIG          FLT_MAX          LDBL_MANT_DIG     SCHAR_MIN  |
     |DBL_EPSILON      FLT_MAX_10_EXP   LDBL_MAX          SHRT_MAX   |
     |DBL_MANT_DIG     FLT_MAX_EXP      LDBL_MAX_10_EXP   SHRT_MIN   |
     |DBL_MAX          FLT_MIN          LDBL_MAX_EXP      UCHAR_MAX  |
     |DBL_MAX_10_EXP   FLT_MIN_10_EXP   LDBL_MIN          UINT_MAX   |
     |DBL_MAX_EXP      FLT_MIN_DIG      LDBL_MIN_10_EXP   ULONG_MAX  |
     |DBL_MIN          FLT_RADIX        LDBL_MIN_DIG      USHRT_MAX  |
     |DBL_MIN_10_EXP   FLT_ROUNDS       LONG_MAX                     |
     |DBL_MIN_DIG      INT_MAX          LONG_MIN                     |
     +---------------------------------------------------------------+

6 The C++ Standard library provides 51 standard types, as shown in Table
  4:

                         Table 4--Standard Types

  +--------------------------------------------------------------------------+
  |clock_t         new_handler          streamoff            wint_t <stddef> |
  |div_t           ofstream             streampos            wios            |
  |FILE            ostream              string               wios            |
  |filebuf         ostringstream        stringbuf            wistream        |
  |fpos_t          ptrdiff_t <stddef>   terminate_handler    wistringstream  |
  |fvoid_t         ptrdiff_t<cstddef>   unexpected_handler   wofstream       |
  |ifstream        sig_atomic_t         va_list              wostream        |
  |ios             size_t <cstddef>     wctrans_t            wostringstream  |
  |istream         size_t <cstdio>      wctype_t             wstreambuf      |
  |istringstream   size_t <cstring>     wfilebuf             wstreampos      |
  |jmp_buf         size_t <ctime>       wifstream            wstring         |
  |ldiv_t          size_t <stddef>      wint_t <cwchar>      wstringbuf      |
  |mbstate_t       streambuf            wint_t <cwctype>                     |
  +--------------------------------------------------------------------------+

7 The C++ Standard library provides 68  standard  template  classes,  as
  shown in Table 5:

                    Table 5--Standard Template classes

           +--------------------------------------------------+
           |allocator              mask_array                 |
           |auto_ptr               messages                   |
           |back_insert_iterator   messages_byname            |
           |basic_convbuf          moneypunct                 |
           |basic_filebuf          moneypunct_byname          |
           |basic_ifstream         money_get                  |
           |basic_ios              money_put                  |
           |basic_istream          multimap                   |
           |basic_istringstream    multiset                   |
           |basic_ofstream         numeric_limits             |
           |basic_ostream          numpunct                   |
           |basic_ostringstream    num_get                    |
           |basic_streambuf        num_put                    |
           |basic_string           ostreambuf_iterator        |
           |basic_stringbuf        ostream_iterator           |
           |binary_negate          pointer_to_binary_function |
           |binder1st              pointer_to_unary_function  |
           |binder2nd              priority_queue             |
           +--------------------------------------------------+

         +-------------------------------------------------------+
         |bits                    queue                          |
         |codecvt                 raw_storage_iterator           |
         |codecvt_byname          restrictor                     |
         |collate                 reverse_bidirectional_iterator |
         |collate_byname          reverse_iterator               |
         |complex                 set                            |
         |ctype                   slice_array                    |
         |ctype_byname            stack                          |
         |deque                   time_get                       |
         |front_insert_iterator   time_get_byname                |
         |gslice_array            time_put                       |
         |indirect_array          time_put_byname                |
         |insert_iterator         unary_negate                   |
         |istreambuf_iterator     valarray                       |
         |istream_iterator        vector                         |
         |list                                                   |
         |map                                                    |
         +-------------------------------------------------------+

8 The  C++ Standard library provides 26 standard template structures, as
  shown in Table 6:

                    Table 6--Standard Template structs

   +------------------------------------------------------------------+
   |bidirectional_iterator   ios_conv_traits   negate                 |
   |binary_function          ios_traits        not_equal_to           |
   |conv_traits              less              pair                   |
   |divides                  less_equal        plus                   |
   |equal_to                 logical_and       random_access_iterator |
   |forward_iterator         logical_not       string_char_traits     |
   |greater                  logical_or        times                  |
   |greater_equal            minus             unary_function         |
   |input_iterator           modulus                                  |
   +------------------------------------------------------------------+

9 The C++ Standard library provides 78 standard template operator  func­
  tions, as shown in Table 7.

10Types shown (enclosed in ( and ) ) indicate that the given function is
  overloaded by that type.  Numbers shown (enclosed in [ and ]  )  indi­
  cate how many overloaded functions are overloaded by that type.

                   Table 7--Standard Template operators

  +--------------------------------------------------------------------+
  |operator!= (basic_string) [5]      operator<  (vector)              |
  |operator!= (complex) [3]           operator<< (complex)             |
  |operator!= (istreambuf_iterator)   operator<< (valarray) [3]        |
  |operator!= (ostreambuf_iterator)   operator<<=(valarray) [2]        |
  |operator!= (T)                     operator<= (T)                   |
  |operator!= (valarray) [3]          operator<= (valarray) [3]        |
  |operator%  (valarray) [3]          operator== (basic_string) [5]    |
  |operator%= (valarray) [2]          operator== (complex) [3]         |
  |operator&  (valarray) [3]          operator== (deque)               |
  |operator&& (valarray) [3]          operator== (istreambuf_iterator) |
  |operator&= (valarray) [2]          operator== (istream_iterator)    |
  |operator*  (complex) [3]           operator== (list)                |
  |operator*  (valarray) [3]          operator== (map)                 |
  |operator*= (complex)               operator== (multimap)            |
  |operator*= (valarray) [2]          operator== (multiset)            |
  |operator+  (basic_string) [5]      operator== (ostreambuf_iterator) |
  |operator+  (complex) [4]           operator== (pair)                |
  |operator+  (reverse_iterator)      operator== (queue)               |
  |operator+  (valarray) [3]          operator== (restrictor)          |
  |operator+= (complex)               operator== (reverse_bidir_iter)  |
  |operator+= (valarray) [2]          operator== (reverse_iterator)    |
  |operator-  (complex) [4]           operator== (set)                 |
  |operator-  (reverse_iterator)      operator== (stack)               |
  |operator-  (valarray) [3]          operator== (valarray) [3]        |
  |operator-= (complex)               operator== (vector)              |
  |operator-= (valarray) [2]          operator>  (T)                   |
  |operator/  (complex) [3]           operator>  (valarray) [3]        |
  |operator/  (valarray) [3]          operator>= (T)                   |
  |operator/= (complex)               operator>= (valarray) [3]        |
  |operator/= (valarray) [2]          operator>> (basic_string)        |
  |operator<  (deque)                 operator>> (complex)             |
  |operator<  (list)                  operator>> (valarray) [3]        |
  |operator<  (map)                   operator>>=(valarray) [2]        |
  |operator<  (multimap)              operator^  (valarray) [3]        |
  |operator<  (multiset)              operator^= (valarray) [2]        |
  |operator<  (pair)                  operator|  (valarray) [3]        |
  |operator<  (restrictor)            operator|= (valarray) [2]        |
  |operator<  (reverse_iterator)      operator|| (valarray) [3]        |
  |operator<  (set)                                                    |
  |operator<  (valarray) [3]                                           |
  +--------------------------------------------------------------------+

11The  C++ Standard library provides 135 standard template functions, as
  shown in Table 8:

                   Table 8--Standard Template functions

   +-------------------------------------------------------------------+
   |abs  (complex)                        make_heap [2]                |
   |abs  (valarray)                       make_pair                    |
   |accumulate [2]                        max [2]                      |
   |acos (valarray)                       max_element [2]              |
   |adjacent_difference [2]               merge [2]                    |
   |adjacent_find [2]                     min [2]                      |
   |advance                               min_element [2]              |
   |allocate                              mismatch [2]                 |
   |arg  (complex)                        next_permutation [2]         |
   |asin (valarray)                       norm (complex)               |
   |atan (valarray)                       not1                         |
   |atan2(valarray) [3]                   not2                         |
   |back_inserter                         nth_element [2]              |
   |binary_search [2]                     partial_sort [2]             |
   |bind1st                               partial_sort_copy [2]        |
   |bind2nd                               partial_sum [2]              |
   |conj (complex)                        partition                    |
   |construct                             polar(complex)               |
   |copy                                  pop_heap [2]                 |
   |copy_backward                         pow  (complex)               |
   |cos  (complex)                        pow  (valarray) [3]          |
   |cos  (valarray)                       prev_permutation [2]         |
   |cosh (complex)                        ptr_fun [2]                  |
   |cosh (valarray)                       push_heap [2]                |
   |count                                 random_shuffle [2]           |
   |count_if                              real (complex)               |
   |deallocate                            remove                       |
   |destroy [2]                           remove_copy                  |
   |distance                              remove_copy_if               |
   |distance_type (istreambuf_iterator)   remove_if                    |
   |distance_type [5]                     replace                      |
   |equal [2]                             replace_copy                 |
   |equal_range [2]                       replace_copy_if              |
   |exp  (complex)                        replace_if                   |
   |exp  (valarray)                       reverse                      |
   |fill                                  reverse_copy                 |
   |fill_n                                rotate                       |
   |find                                  rotate_copy                  |
   |find_end [4]                          search [4]                   |
   |find_first_of [2]                     set_difference [2]           |
   |find_if                               set_intersection [2]         |
   |for_each                              set_symmetric_difference [2] |
   |front_inserter                        set_union [2]                |
   |generate                              sin  (complex)               |
   +-------------------------------------------------------------------+

           +---------------------------------------------------+
           |generate_n                    sin  (valarray)      |
           |get_temporary_buffer          sinh (complex)       |
           |imag (complex)                sinh (valarray)      |
           |includes [2]                  sort [2]             |
           |inner_product [2]             sort_heap [2]        |
           |inplace_merge [2]             sqrt (complex)       |
           |inserter                      sqrt (valarray)      |
           |isalnum                       stable_partition     |
           |isalpha                       stable_sort [2]      |
           |iscntrl                       swap                 |
           |isdigit                       swap_ranges          |
           |isgraph                       tan  (valarray)      |
           |islower                       tanh (valarray)      |
           |isprint                       tolower              |
           |ispunct                       toupper              |
           |isspace                       transform [2]        |
           |isupper                       uninitialized_copy   |
           |isxdigit                      uninitialized_fill_n |
           |iterator_category [7]         unique [2]           |
           |lexicographical_compare [2]   unique_copy [2]      |
           |log  (complex)                unititialized_fill   |
           |log  (valarray)               upper_bound [2]      |
           |log10(valarray)               value_type [7]       |
           |lower_bound [2]                                    |
           +---------------------------------------------------+

12The C++ Standard library provides 25 standard  classes,  as  shown  in
  Table 9.

13Type  names  (enclosed  in  < and > ) indicate that these are specific
  instances of templates.

                        Table 9--Standard Classes

    +-----------------------------------------------------------------+
    |bad_alloc              exception          out_of_range           |
    |bad_cast               gslice             overflow_error         |
    |bad_typeid             invalid_argument   range_error            |
    |complex<double>        ios_base           runtime_error          |
    |complex<float>         length_error       slice                  |
    |complex<long double>   locale             type_info              |
    |ctype<char>            locale::facet      vector<bool,allocator> |
    |ctype_byname<char>     locale::id                                |
    |domain_error           logic_error                               |
    +-----------------------------------------------------------------+

14The C++ Standard library provides 21 standard structures, as shown  in
  Table 10:

                        Table 10--Standard Structs

       +----------------------------------------------------------+
       |bidirectional_iterator_tag    money_base                  |
       |codecvt_base                  money_base::pattern         |
       |conv_traits<wchar_t>          output_iterator             |
       |ctype_base                    output_iterator_tag         |
       |empty                         random_access_iterator_tag  |
       |forward_iterator_tag          string_char_traits<char>    |
       |input_iterator_tag            string_char_traits<wchar_t> |
       |ios_conv_traits<wstreampos>   time_base                   |
       |ios_traits<char>              tm <ctime>                  |
       |ios_traits<wchar_t>           tm <cwchar>                 |
       |lconv                                                     |
       +----------------------------------------------------------+

15The  C++  Standard library provides 18 standard operator functions, as
  shown in Table 11:

                  Table 11--Standard Operator functions

  +--------------------------------------------------------------------------+
  |operator delete                       operator<< (bits)                   |
  |operator delete[]                     operator<< (locale)                 |
  |operator new                          operator== (empty)                  |
  |operator new (void*)                  operator== (vector<bool,allocator>) |
  |operator new[]                        operator>> (bits)                   |
  |operator new[] (void*)                operator>> (locale)                 |
  |operator&  (bits)                     operator^  (bits)                   |
  |operator<  (empty)                    operator|  (bits)                   |
  |operator<  (vector<bool,allocator>)                                       |
  |operator<< (basic_string)                                                 |
  +--------------------------------------------------------------------------+

16The C++ Standard library provides 243 standard functions, as shown  in
  Table 12:

                       Table 12--Standard Functions

      +------------------------------------------------------------+
      |abort      getenv              oct               strxfrm    |
      |abs        getline             perror            swprintf   |
      |acos       gets                pow               swscanf    |
      |asctime    getwc               printf            system     |
      |asin       getwchar            putc              tan        |
      |atan       gmtime              puts              tanh       |
      |atan2      hex                 putwc             terminate  |
      |atexit     internal            putwchar          time       |
      |atof       isalnum             qsort             tmpfile    |
      |atoi       isalpha             raise             tmpnam     |
      |atol       iscntrl             rand              tolower    |
      |bsearch    isdigit             realloc           toupper    |
      |btowc      isgraph             remove            towctrans  |
      |calloc     islower             rename            towlower   |
      |ceil       isprint             resetiosflags     towupper   |
      |clearerr   ispunct             rewind            unexpected |
      |clock      isspace             right             ungetc     |
      |cos        isupper             scanf             ungetwc    |
      |cosh       iswalnum            scientific        uppercase  |
      |ctime      iswalpha            setbase           vfwprintf  |
      |dec        iswcntrl            setbuf            vprintf    |
      |difftime   iswctype            setfill           vprintf    |
      |div        iswdigit            setiosflags       vsprintf   |
      |endl       iswgraph            setlocale         vswprintf  |
      |ends       iswlower            setprecision      vwprintf   |
      |exit       iswprint            setvbuf           wcrtomb    |
      |exp        iswpunct            setw              wcscat     |
      |fabs       iswspace            set_new_handler   wcschr     |
      |fclose     iswupper            set_terminate     wcscmp     |
      |feof       iswxdigit           set_unexpected    wcscoll    |
      |ferror     isxdigit            showbase          wcscpy     |
      |fflush     iterator_category   showpoint         wcscspn    |
      |fgetc      labs                showpos           wcsftime   |
      |fgetpos    ldexp               signal            wcslen     |
      |fgets      ldiv                sin               wcsncat    |
      |fgetwc     left                sinh              wcsncmp    |
      |fgetws     localeconv          skipws            wcsncpy    |
      |fixed      localtime           sprintf           wcspbrk    |
      |floor      log                 sqrt              wcsrchr    |
      |flush      log10               srand             wcsrtombs  |
      |fmod       longjmp             sscanf            wcsspn     |
      |fopen      malloc              strcat            wcsstr     |
      +------------------------------------------------------------+

              +---------------------------------------------+
              |fprintf    mblen         strchr     wcstod   |
              |fputc      mbrlen        strcmp     wcstok   |
              |fputs      mbrtowc       strcoll    wcstol   |
              |fputwc     mbsinit       strcpy     wcstombs |
              |fputws     mbsrtowcs     strcspn    wcstoul  |
              |fread      mbstowcs      strerror   wcsxfrm  |
              |free       mbtowc        strftime   wctob    |
              |freopen    memchr        strlen     wctomb   |
              |frexp      memcmp        strncat    wctrans  |
              |fscanf     memcpy        strncmp    wctype   |
              |fseek      memmove       strncpy    wmemchr  |
              |fsetpos    memset        stroul     wmemcmp  |
              |ftell      mktime        strpbrk    wmemcpy  |
              |fwide      modf          strrchr    wmemmove |
              |fwprintf   noshowbase    strspn     wmemset  |
              |fwrite     noshowpoint   strstr     wprintf  |
              |fwscanf    noshowpos     strtod     ws       |
              |getc       noskipws      strtok     wscanf   |
              |getchar    nouppercase   strtol              |
              +---------------------------------------------+

17The  C++  Standard  library  provides  9 standard objects, as shown in
  Table 13:

                        Table 13--Standard Objects

      +------------------------------------------------------------+
      |cerr   cin   clog   cout   errno   werr   win   wlog   wout |
      +------------------------------------------------------------+

  17.3.1.2  Headers                                        [lib.headers]

1 The elements of the C++ Standard library are declared or  defined  (as
  appropriate) in a header.

2 The  C++  Standard  library provides 34 C++ headers, as shown in Table
  14:

  _________________________
  12)  A  header is not necessarily a source file, nor are the sequences
  delimited by < and > in header names  necessarily  valid  source  file
  names (_cpp.include_).

                      Table 14--C++ Library Headers

   +-------------------------------------------------------------------+
   |<algorithm>   <functional>   <limits>    <ostream>     <streambuf> |
   |<bits>        <iomanip>      <list>      <queue>       <string>    |
   |<complex>     <ios>          <locale>    <set>         <typeinfo>  |
   |<cstream>     <iosforward>   <map>       <sstream>     <utility>   |
   |<deque>       <iostream>     <memory>    <stack>       <valarray>  |
   |<exception>   <istream>      <new>       <stddef>      <vector>    |
   |<fstream>     <iterator>     <numeric>   <stdexcept>               |
   +-------------------------------------------------------------------+

3 The facilities of the Standard C Library are provided in 18 additional
  headers, as shown in Table 15:

              Table 15--C++ Headers for C Library Facilities

           +--------------------------------------------------+
           |<cassert> <ciso646> <csetjmp> <cstdio>  <cwchar>  |
           |<cctype>  <climits> <csignal> <cstdlib> <cwctype> |
           |<cerrno>  <clocale> <cstdarg> <cstring>           |
           |<cfloat>  <cmath>   <cstddef> <ctime>             |
           +--------------------------------------------------+

  +-------                 BEGIN BOX 3                -------+
  ISSUE: Header <ciso646> is not needed:  see _lex.key_, Table 4.
  +-------                  END BOX 3                 -------+

4 Except    as   noted   in   Clauses   _lib.language.support_   through
  _lib.input.output_, the contents of each header c name  shall  be  the
  same  as that of the corresponding header name .h, as specified in ISO
  C (Clause 4), or Amendment 1, (Clause 7), as appropriate.  In this C++
  Standard library, however, the declarations and definitions are within
  namespace scope (_basic.scope.namespace_) of the namespace std.

5 Subclause _diff.library_ describes the effects of using the name .h (C
  header) form in a C++ program.

  17.3.1.3  Freestanding implementations                [lib.compliance]

1 Two  kinds  of  implementations  are  defined: hosted and freestanding
  (_intro.compliance_).  For a hosted implementation, this International
  Standard definesdescribes the set of available headers.

2 A freestanding implementation is one in which execution may take place
  without the benefit of an operating system, and has an implementation-
  defined set of headers.  This set shall include at least the following
  8 headers:

  +-------                 BEGIN BOX 4                -------+
  ISSUE: TBS.  Requires a definition of a freestanding environment.
  +-------                  END BOX 4                 -------+

  --the headers <new>, <exception>, and <typeinfo> that provide C++ lan­
    guage support (as described in _lib.language.support_)

  --the C++ headers <cfloat>, <climits>, <cstdarg>, and <cstddef>

  --a  version  of  the  C++ header <cstdlib> that declares at least the
    functions abort, atexit, and exit.

  17.3.2  Using the library                                  [lib.using]

1 This subclause describes how a C++ program gains access to the facili­
  ties  of  the  C++  Standard  library.   Subclause _lib.using.headers_
  describes  effects  during  translation  phase  4,   while   subclause
  _lib.using.linkage_ describes effects during phase 8 (_lex.phases_).

  17.3.2.1  Headers                                  [lib.using.headers]

1 The entities in the C++ Standard library are defined in headers, whose
  contents are made available to a translation unit when it contains the
  appropriate #include preprocessing directive (_cpp.include_).

2 A  translation  unit may include library headers in any order (_lex_).
  Each may be included more than once, with  no  effect  different  from
  being  included  exactly  once,  except  that  the effect of including
  either <cassert> or <assert.h> depends each time on the lexically cur­
  rent definition of NDEBUG.

3 A translation unit shall include a header only outside of any external
  declaration or definition, and  shall  include  the  header  lexically
  before the first reference to any of the entities it declares or first
  defines in that translation unit.

  17.3.2.2  Linkage                                  [lib.using.linkage]

1 Entities  in  the  C++  Standard   library   have   external   linkage
  (_basic.link_).   Unless  otherwise  specified,  objects and functions
  have the default "extern "C++"" linkage (_dcl.link_).

2 Objects and functions defined in the library and  required  by  a  C++
  program  are  included  in  the program prior to program startup.  SEE
  ALSO: replacement  functions  (_lib.replacement.functions_),  run-time
  changes (_lib.handler.functions_).

  17.3.3  Constraints on programs                      [lib.constraints]

1 This  subclause  describes  restrictions  on C++ programs that use the
  facilities of the C++  Standard  library.   The  following  subclauses
  specify constraints on the program's namespace (_lib.reserved.names_),

  its use of headers (_lib.alt.headers_), classes derived from  standard
  library  classes  (_lib.derived.classes_),  definitions of replacement
  functions (_lib.replacement.functions_), and installation  of  handler
  functions during execution (_lib.handler.functions_).

  17.3.3.1  Reserved names                          [lib.reserved.names]

1 The C++ Standard library reserves the following kinds of names:

  +-------                 BEGIN BOX 5                -------+
  ISSUE: This topics needs further discussion.  For example, implementa­
  tion names could be required to be in a separate implementation names­
  pace.
  +-------                  END BOX 5                 -------+

  --Macros

  --Global names

  --Names with external linkage

2 If  the  program  declares  or defines a name in a context where it is
  reserved, other than as explicitly allowed by this clause, the  behav­
  ior is undefined.

  17.3.3.1.1  Macro names                              [lib.macro.names]

1 Each  name defined as a macro in a header is reserved to the implemen­
  tation for any use if the translation unit includes the header.13)

2 A translation unit that includes a header shall not contain any macros
  that define names declared or defined in that header.  Nor shall  such
  a translation unit define macros for names lexically identical to key­
  words.

  17.3.3.1.2  Global names                            [lib.global.names]

1 Each header also optionally declares or defines names which are always
  reserved  to  the implementation for any use and names reserved to the
  implementation for use at file scope.

2 Certain sets of names and function signatures are reserved whether  or
  not a translation unit includes a header:

3 Each  name that begins with an underscore and either an uppercase let­
  ter or another underscore (_lex.key_) is reserved to  the  implementa­
  tion for any use.

  _________________________
  13) It is not permissible to remove a library macro definition by  us­
  ing the #undef directive.

4 Each  name that begins with an underscore is reserved to the implemen­
  tation for use as a name with file scope or within the  namespace  std
  in the ordinary name space.

  17.3.3.1.3  External linkage                        [lib.extern.names]

1 Each  name  declared as an object with external linkage in a header is
  reserved to the implementation to designate that library  object  with
  external linkage.14)

2 Each global function signature declared with  external  linkage  in  a
  header  is  reserved  to the implementation to designate that function
  signature with external linkage.  15)

3 Each name having two consecutive underscores (_lex.key_)  is  reserved
  to  the  implementation  for  use  as  a name with both extern C"" and
  extern C++"" linkage.

  17.3.3.2  Headers                                    [lib.alt.headers]

1 If a file has a name equivalent to the derived file name  for  one  of
  the  C++  Standard  library  headers,  is  not provided as part of the
  implementation, and is placed in any of  the  standard  places  for  a
  source file to be included (_cpp.include_), the behavior is undefined.

  17.3.3.3  Derived classes                        [lib.derived.classes]

1 Virtual member function signatures defined for a base class in the C++
  Standard  library  may be overridden in a derived class by definitions
  in the program.

  17.3.3.4  Replacement functions            [lib.replacement.functions]

1 This clause describes the behavior of numerous  functions  defined  by
  the  C++ Standard library.  Under some circumstances, however, certain
  of these function descriptions also  apply  to  replacement  functions
  defined in the program (_lib.definitions_).

2 A  C++ program may provide the definition for any of four dynamic mem­
  ory    allocation    function    signatures    declared    in    <new>
  (_basic.stc.dynamic_, _lib.language.support_):16)

  --operator new(size_t)

  --operator new[](size_t)

  _________________________
  14)  The  list  of such reserved names includes errno, declared or de­
  fined in <cerrno>.
  15) The list of such reserved function signatures with external  link­
  age  includes  setjmp(jmp_buf),  declared or defined in <csetjmp>, and
  va_end(va_list), declared or defined in <cstdarg>.

  --operator delete(void*)

  --operator delete[](void*)

3 The  program's  definitions  are  used instead of the default versions
  supplied by  the  implementation  (_dcl.fct.def_).   Such  replacement
  occurs prior to program startup (_basic.def.odr_, _basic.start_).

  17.3.3.5  Handler functions                    [lib.handler.functions]

1 The  C++  Standard library provides default versions of the three han­
  dler functions (_lib.language.support_):

  --new_handler

  --unexpected_handler

  --terminate_handler

2 A C++ program may install different handler  functions  during  execu­
  tion,  by  supplying a pointer to a function defined in the program or
  the library as an argument to (respectively):

  --set_new_handler

  --set_unexpected

  --set_terminate

3
  17.3.3.6  Function arguments                    [lib.res.on.arguments]

1 Each of the following statements applies to all arguments to functions
  defined  in  the C++ Standard library, unless explicitly stated other­
  wise in this clause.

  --If an argument to a function has an invalid value (such as  a  value
    outside  the  domain  of  the function, or a pointer invalid for its
    intended use), the behavior is undefined.

  --If a function argument is described as being an array,  the  pointer
    actually  passed  to  the  function shall have a value such that all
    address computations and accesses to objects (that would be valid if
    the  pointer did point to the first element of such an array) are in
    fact valid.

  17.3.4  Conforming implementations                    [lib.conforming]

1 This subclause describes the constraints upon, and latitude of, imple­
  mentations  of  the  C++  Standard  library.  The following subclauses
  describe an implementation's use  of  headers  (_lib.res.on.headers_),
  macros      (_lib.res.on.macro.definitions_),     global     functions
  (_lib.global.functions_), member  functions  (_lib.member.functions_),

  access  specifiers (_lib.protection.within.classes_), class derivation
  (_lib.derivation_), and exceptions  (_lib.res.on.exception.handling_).

  +-------                 BEGIN BOX 6                -------+
  ISSUE: all of these have to be discussed by the Library WG.
  +-------                  END BOX 6                 -------+

  17.3.4.1  Headers                                 [lib.res.on.headers]

1 Certain  types  and  macros  are defined in more than one header.  For
  such an entity, a second or subsequent header that also defines it may
  be included after the header that provides its initial definition.

2 None  of  the C headers includes any of the other headers, except that
  each C header includes its  corresponding  C++  header,  as  described
  above.   None  of the C++ headers includes any of the C headers.  How­
  ever, any of the C++ headers can include any of the other C++ headers,
  and must include a C++ header that contains any needed definition.16)

  17.3.4.2  Restrictions on macro         [lib.res.on.macro.definitions]
       definitions

1 Only the names or global function signatures  described  in  subclause
  _lib.contents_ are reserved to the implementation.17)

2 All object-like  macros  defined  by  the  C++  Standard  library  and
  described in this clause as expanding to integral constant expressions
  are also suitable for use  in  #if  preprocessing  directives,  unless
  explicitly stated otherwise.

  17.3.4.3  Global functions                      [lib.global.functions]

1 A call to a global function signature described in this clause behaves
  the same as if the implementation declares no additional global  func­
  tion signatures.18)

  _________________________
  16)  Including any one of the C++ headers can introduce all of the C++
  headers into a translation unit, or just the one that is named in  the
  #include preprocessing directive.
  17) A global function cannot be declared by the implementation as tak­
  ing additional default arguments.  Also, the use of masking macros for
  function signatures declared in C headers is disallowed, notwithstand­
  ing the latitude granted in subclause 7.1.7 of the  C  Standard.   The
  use  of a masking macro can often be replaced by defining the function
  signature as inline.
  18) A valid C++ program always calls the expected library global func­
  tion.  An implementation may also define additional  global  functions
  that would otherwise not be called by a valid C++ program.

  17.3.4.4  Member functions                      [lib.member.functions]

1 An  implementation  can declare additional non-virtual member function
  signatures within a class:

  --by adding arguments with default values to a member function  signa­
    ture described in this clause; Hence, taking the address of a member
    function has an unspecified type.  The same latitude does not extend
    to the implementation of virtual or global functions, however.

  --by  replacing a member function signature with default values by two
    or more member function signatures with equivalent behavior;

  --by adding a member function signature for  a  member  function  name
    described in this clause.

2 A call to a member function signature described in this clause behaves
  the same as if the implementation declares no additional member  func­
  tion signatures.19)

  17.3.4.5  Reentrancy                                  [lib.reentrancy]

1 Which of the functions in the C++ Standard Library are  not  reentrant
  subroutines is implementation-defined.

  17.3.4.6  Protection within            [lib.protection.within.classes]
       classes

1 It is unspecified whether a member described in this clause as private
  is  private, protected, or public.  It is unspecified whether a member
  described as protected is protected or public.

  +-------                 BEGIN BOX 7                -------+
  Does this make any sense?
  +-------                  END BOX 7                 -------+

  A member described as public is always public.

2 It is unspecified whether a function signature or class  described  in
  this clause is a friend of another class described in this clause.

  17.3.4.7  Derived classes                             [lib.derivation]

1 Certain  classes defined in this clause are derived from other classes
  in the C++ Standard library:

  --It is unspecified whether a class described in this clause as a base
  _________________________
  19) A valid C++ program always calls the expected library member func­
  tion, or one with equivalent behavior.  An implementation may also de­
  fine additional member functions that would otherwise not be called by
  a valid C++ program.

    class is itself derived from other base classes (with names reserved
    to the implementation).

  --It is unspecified whether  a  class  described  in  this  clause  as
    derived  from  another class is derived from that class directly, or
    through other classes (with names reserved  to  the  implementation)
    that are derived from the specified base class.

2 In any case:

  --A base class described as virtual in this clause is always virtual;

  --A  base  class described as non-virtual in this clause is never vir­
    tual;

  --Unless explicitly stated otherwise, types  with  distinct  names  in
    this clause are distinct types.20)

  17.3.4.8  Restrictions on              [lib.res.on.exception.handling]
       exception handling

1 Any  of the functions defined in the C++ Standard library can report a
  failure  to  allocate  storage  by  throwing  an  exception  of   type
  bad_alloc, or a class derived from bad_alloc.

2 Otherwise,  none  of the functions defined in the C++ Standard library
  throw an exception that must be caught outside  the  function,  unless
  explicitly stated otherwise.

  +-------                 BEGIN BOX 8                -------+
  ISSUE:  aren't  these  two statements conveyed by exception specifica­
  tions?
  +-------                  END BOX 8                 -------+

  _________________________
  20) An implicit exception to this rule are types described as synonyms
  for basic integral types, such as size_t and streamoff.