______________________________________________________________________

  27   Input/output library                 [lib.input.output]

  ______________________________________________________________________

1 This clause describes components that C++ programs may use to  perform
  input/output operations.

2 The  following subclauses describe requirements for stream parameters,
  and components  for  forward  declarations  of  iostreams,  predefined
  iostreams  objects,  base  iostreams classes, stream buffering, stream
  formatting and manipulators, string streams, and file streams, as sum­
  marized in Table 1:

                  Table 1--Input/output library summary

    +----------------------------------------------------------------+
    |                    Subclause                        Header(s)  |
    +----------------------------------------------------------------+
    |_lib.iostreams.requirements_ Requirements                       |
    +----------------------------------------------------------------+
    |_lib.iostream.forward_ Forward declarations         <iosfwd>    |
    +----------------------------------------------------------------+
    |_lib.iostream.objects_ Standard iostream objects    <iostream>  |
    +----------------------------------------------------------------+
    |_lib.iostreams.base_ Iostreams base classes         <ios>       |
    +----------------------------------------------------------------+
    |_lib.stream.buffers_ Stream buffers                 <streambuf> |
    +----------------------------------------------------------------+
    |                                                    <istream>   |
    |_lib.iostream.format_ Formatting and manipulators   <ostream>   |
    |                                                    <iomanip>   |
    +----------------------------------------------------------------+
    |_lib.string.streams_ String streams                 <sstream>   |
    |                                                    <cstdlib>   |
    +----------------------------------------------------------------+
    |                                                    <cstream>   |
    |_lib.file.streams_ File streams                     <fstream>   |
    |                                                    <cstdio>    |
    |                                                    <cwchar>    |
    +----------------------------------------------------------------+

  27.1  Iostreams requirements              [lib.iostreams.requirements]

  27.1.1  Definitions                        [lib.iostreams.definitions]

1 Additional definitions:

  --character  In this clause, the term ``character'' means the general­
    ized element of text data.  Each text data consist of a sequence  of
    character.   So  the  term does not only means the char type object,
    and the wchar_t type object, but also any sort of classes which pro­
    vides the definitions specified in (_lib.string.char.traits_).

  --character  container  type  Character container type is a class or a
    type which represents a character.  It is used for one of  the  tem­
    plate parameter of the template iostream classes.

  --template iostream classes The template iostream classes are the tem­
    plate classes which takes two template parameters: charT and traits.
    The  class,  charT, represents the character container class and the
    class, traits, represents the traits structure  which  provides  the
    definition  of the functionality necessary to implement the template
    iostream classes.

  --narrow-oriented  iostream  classes  The   narrow-oriented   iostream
    classes  are  the versions of the template iostream classes special­
    ized with the character  container  class,  char.   The  traditional
    iostream  classes  are  regarded  as  the  narrow-oriented  iostream
    classes (_lib.narrow.stream.objects_).

  --wide-oriented iostream classes The  wide-oriented  iostream  classes
    are  the  versions of the template iostream classes specialized with
    the character container class, wchar_t  (_lib.wide.stream.objects_).

  --repositional  streams and arbitrary-positional streams There are two
    types of stream:  repositional and arbitrary-positional.

  +-------                 BEGIN BOX 1                -------+
  There are also non-positional streams in which no seeking is possible.
  +-------                  END BOX 1                 -------+

2 With  a repositional stream, we can seek to only the position where we
  previously  encountered.   On  the  other  hand,  with  an  arbitrary-
  positionalstream,  we  can  seek  to  any integral position within the
  length of the stream.

3 For a stream buffer which is corresponding to  a  repositional  stream
  (but  not  an arbitrary-positional stream), all we can do is either to
  fetch the current position of the stream buffer or to specify the pre­
  vious position which we have already fetched from the stream buffer.

4 Every arbitrary-positional stream is repositional.

5 If  a  repositional stream returns a POS_T object, and some arithmetic
  operations  (  operator+=,  operator-,  operator+=,  operator-=)   are
  applied,  the behavior of the stream after restoring the position with
  the modified POS_T object is undefined.  It means that a POS_T  object
  whose  parent  stream  is  repositional shall not apply any arithmetic
  operations.

6 It is not ensured that in case the validity of a certain POS_T  object
  is  broken,  the error shall be informed.  Or there is no way to check
  the validity of a certain POS_T object.

  --Invalid POS_T value The stream operations whose return type is POS_T
    may  return POS_T((OFF_T)(-1)) as signal to some error occurs.  This
    return value is called the  invalid  POS_T  value.   The  conversion
    POS_T((OFF_T)(-1))  constructs  the  invalid  POS_T  value, which is
    available only for comparing to the  return  value  of  such  member
    functions.

  27.1.2  Type requirements                  [lib.iostreams.type.reqmts]

1 There are several types and functions needed for implementing the tem­
  plate iostream classes.  Some of these types and functions  depend  on
  the  definition  of  the  character container type.  The collection of
  these functions describes the behavior which the implementation of the
  template iostream class expects to the character container class.

  27.1.2.1  Type CHAR_T                           [lib.iostreams.char.t]

1 Those who provide a character container type as the template parameter
  have to provide all of these functions as well as the container  class
  itself.  The collection of these functions can be regarded as the col­
  lection of the common definitions for the implementation of the  char­
  acter container class.

2 No  special  definition/declaration  is provided here.  The base class
  (or  struct),  string_char_traits  provides  the  definitions   common
  between the template string classes and the template iostream classes.

3 Convertible to type INT_T.

  27.1.2.2  Type INT_T                             [lib.iostreams.int.t]

1 Another character container type which can also  hold  an  end-of-file
  value.   It  is  used as the return type of some of the iostream class
  member functions.  If CHAR_T is either char or wchar_t, INT_T shall be
  int or wint_t, respectively.

  27.1.2.3  Type OFF_T                             [lib.iostreams.off.t]

1 A type that can represent offsets to positional information.1)  It  is
  _________________________
  1)  It is usually a synonym for one if the signed basic integral types
  whose representation at least as many bits as type long.

  used to represent:

  --a  signed  displacement,  measured  in  characters, from a specified
    position within a sequence.

  --an absolute position within a sequence.

2 The value OFF_T(-1) can be used as an error indicator.

3 If an OFF_T object has a value other than the  parent  stream  returns
  (for  example, assigned an arbitrary integer), the value may not apply
  to any streams.

4 Convertible to type POS_T.2) But no validity of  the  resulting  POS_T
  value is ensured, whether or not the OFF_T value is valid.

  27.1.2.4  Type POS_T                             [lib.iostreams.pos.t]

1 An  implementation-defined type for seek operations which describes an
  object that can store all the information necessary to  reposition  to
  the position.

2 The  type POS_T describes an object that can store all the information
  necessary to restore an arbitrary sequence to a previous stream  posi­
  tion and conversion state.3)

3 A  class  or  built-in type P satisfies the requirements of a position
  type, and a class or built-in type O satisfies the requirements of  an
  offset  type if the following expressions are valid, as shown in Table
  2.

4 In the following table,

  --P refers to type POS_T,

  --p and q refer to an values of type POS_T,

  --O refers to type OFF_T,

  --o refers to a value of type OFF_T, and

  --i refers to a value of type int.

  _________________________
  2) An implementation may use the same type for both OFF_T and POS_T.
  3)  The  conversion state is used for sequences that translate between
  wide-character and generalized multibyte  encoding,  as  described  in
  Amendment 1 to the C Standard.

                    Table 2--Position type requirements

  +--------------------------------------------------------------------------------+
  |expression       return type       operational           assertion/note         |
  |                                    semantics          pre/post-condition       |
  +--------------------------------------------------------------------------------+
  |P(i)                                             p == P(i)                      |
  |                                                 note: a destructor is assumed. |
  +--------------------------------------------------------------------------------+
  |P p(i);                                                                         |
  |P p = i;                                         post: p == P(i).               |
  +--------------------------------------------------------------------------------+
  |P(o)         POS_T                               converts from offset           |
  +--------------------------------------------------------------------------------+
  |O(p)         OFF_T                               converts to offset             |
  +--------------------------------------------------------------------------------+
  |p == q       convertible to bool                 == is an equivalence relation  |
  +--------------------------------------------------------------------------------+
  |p != q       convertible to bool   !(p==q)                                      |
  +--------------------------------------------------------------------------------+
  |q = p + o    POS_T                 + offset      q-o == p                       |
  |p += o                                                                          |
  +--------------------------------------------------------------------------------+
  |q = p - o    POS_T                 - offset      q+o == p                       |
  |p -= o                                                                          |
  +--------------------------------------------------------------------------------+
  |o = p - q    OFF_T                 distance      q+o == p                       |
  +--------------------------------------------------------------------------------+

  27.2  Forward declarations                      [lib.iostream.forward]

  Header <iosfwd> synopsis

  namespace std {
    template<class charT> class basic_ios;
    template<class charT> class basic_istream;
    template<class charT> class basic_ostream;

    typedef basic_ios<char>     ios;
    typedef basic_ios<wchar_t> wios;

    typedef basic_istream<char>     istream;
    typedef basic_istream<wchar_t> wistream;

    typedef basic_ostream<char>     ostream;
    typedef basic_ostream<wchar_t> wostream;
  }

1 The template class basic_ios<charT,traits> serves as a base class  for
  the          classes          basic_istream<charT,traits>          and
  basic_ostream<charT,traits>.

2 The class ios is an instance of the template class basic_ios, special­
  ized by the type char.

3 The  class  wios is a version of the template class basic_ios special­
  ized by the type wchar_t.

  27.3  Standard iostream objects                 [lib.iostream.objects]

  Header <iostream> synopsis

  #include <fstream>

  namespace std {
    extern ifstream cin;
    extern ofstream cout;
    extern ofstream cerr;
    extern ofstream clog;

    extern wifstream win;
    extern wofstream wout;
    extern wofstream werr;
    extern wofstream wlog;
  }

1 The header <iostream> declares objects that associate objects with the
  standard  C streams provided for by the functions declared in <cstdio>
  (_lib.c.files_).

2 Mixing operations on corresponding wide- and narrow-character  streams
  follows  the  same  semantics  as mixing such operations on FILE s, as
  specified in Amendment 1 of the ISO C standard.

  +-------                 BEGIN BOX 2                -------+
  ISSUE: These objects need to be constructed  and  associations  estab­
  lished before dynamic initialization of file scope variables is begun.
  +-------                  END BOX 2                 -------+

  The objects are constructed, and the associations are established, the
  first  time  an  object of class basic_ios<charT,traits>::Init is con­
  structed.  The objects are not destroyed during program execution.4)

  27.3.1  Narrow stream objects              [lib.narrow.stream.objects]

  27.3.1.1  Object cin                                         [lib.cin]

  ifstream cin;

  _________________________
  4) Constructors and destructors for static objects  can  access  these
  objects  to read input from stdin or write output to stdout or stderr.

1 The object cin controls input from an unbuffered stream buffer associ­
  ated with the object stdin, declared in <cstdio>.

2 After the object cin is initialized, cin.tie() returns cout.

  27.3.1.2  Object cout                                       [lib.cout]

  ofstream cout;

1 The object cout controls output to an unbuffered stream buffer associ­
  ated with the object stdout, declared in <cstdio> (_lib.c.files_).

  27.3.1.3  Object cerr                                       [lib.cerr]

  ofstream cerr;

1 The object cerr controls output to an unbuffered stream buffer associ­
  ated with the object stderr, declared in <cstdio> (_lib.c.files_).

2 After  the  object  cerr  is  initialized,  cerr.flags()  & unitbuf is
  nonzero.

  27.3.1.4  Object clog                                       [lib.clog]

  ofstream clog;

1 The object clog controls output to a stream buffer associated with the
  object stderr, declared in <cstdio> (_lib.c.files_).

  +-------                 BEGIN BOX 3                -------+
  ISSUE: The destination of clog ought to be implementation defined.
  +-------                  END BOX 3                 -------+

  27.3.2  Wide stream objects                  [lib.wide.stream.objects]

1
  27.3.2.1  Object win                                         [lib.win]

  wifstream win;

1 The object win controls input from an unbuffered stream buffer associ­
  ated with the object stdin, declared in <cstdio>.

2 After the object win is initialized, win.tie() returns wout.

  27.3.2.2  Object wout                                       [lib.wout]

  wofstream wout;

1 The object wout controls output to an unbuffered stream buffer associ­
  ated with the object stdout, declared in <cstdio> (_lib.c.files_).

  27.3.2.3  Object werr                                       [lib.werr]

  wofstream werr;

1 The object werr controls output to an unbuffered stream buffer associ­
  ated with the object stderr, declared in <cstdio> (_lib.c.files_).

2 After the object  werr  is  initialized,  werr.flags()  &  unitbuf  is
  nonzero.

  27.3.2.4  Object wlog                                       [lib.wlog]

  wofstream wlog;

1 The object wlog controls output to a stream buffer associated with the
  object stderr, declared in <cstdio> (_lib.c.files_).

  +-------                 BEGIN BOX 4                -------+
  ISSUE: The destination of wlog ought to be implementation defined.
  +-------                  END BOX 4                 -------+

  27.4  Iostreams base classes                      [lib.iostreams.base]

  Header <ios> synopsis

  namespace std {
    typedef OFF_T  streamoff;
    typedef OFF_T wstreamoff;
    typedef INT_T streamsize;

    template <class charT> struct ios_traits<charT>;
    struct ios_traits<char>;
    struct ios_traits<wchar_t>;

    class ios_base;
    template<class charT, class traits = ios_traits<charT> >
      class basic_ios;
    typedef basic_ios<char>     ios;
    typedef basic_ios<wchar_t> wios;

  // _lib.std.ios.manip_, manipulators:
    ios_base& boolalpha  (ios_base& str);
    ios_base& noboolalpha(ios_base& str);
    ios_base& showbase   (ios_base& str);
    ios_base& noshowbase (ios_base& str);
    ios_base& showpoint  (ios_base& str);
    ios_base& noshowpoint(ios_base& str);
    ios_base& showpos    (ios_base& str);
    ios_base& noshowpos  (ios_base& str);
    ios_base& skipws     (ios_base& str);
    ios_base& noskipws   (ios_base& str);
    ios_base& uppercase  (ios_base& str);
    ios_base& nouppercase(ios_base& str);
  // adjustfield:
    ios_base& internal   (ios_base& str);
    ios_base& left       (ios_base& str);
    ios_base& right      (ios_base& str);
  // basefield:
    ios_base& dec        (ios_base& str);
    ios_base& hex        (ios_base& str);
    ios_base& oct        (ios_base& str);
  // floatfield:
    ios_base& fixed      (ios_base& str);
    ios_base& scientific (ios_base& str);
  }

  27.4.1  Types                                       [lib.stream.types]

  27.4.1.1  Type streamoff                               [lib.streamoff]

  typedef OFF_T streamoff;

1 The type streamoff is an implementation-defined  type  that  satisfies
  the requirements of type OFF_T(_lib.iostreams.off.t_).

  27.4.1.2  Type wstreamoff                             [lib.wstreamoff]

  typedef OFF_T wstreamoff;

1 The  type  wstreamoff is an implementation-defined type that satisfies
  the requirements of type OFF_T(_lib.iostreams.off.t_).

  27.4.1.3  Type streampos                               [lib.streampos]

  typedef POS_T streampos;

1 The type streampos is an implementation-defined  type  that  satisfies
  the requirements of type POS_T(_lib.iostreams.pos.t_).

  27.4.1.4   Type wstreampos                            [lib.wstreampos]

  typedef POS_T wstreampos;

1 The  type  streampos  is an implementation-defined type that satisfies
  the requirements of type POS_T(_lib.iostreams.pos.t_).

  27.4.1.5  Type streamsize                             [lib.streamsize]

  typedef INT_T streamsize;

1 The type streamsize is a synonym for one of the signed basic  integral
  types.   It  is used to represent the number of characters transferred
  in an I/O operation, or the size of I/O buffers.5)

  27.4.2  Template struct ios_traits                    [lib.ios.traits]
  namespace std {
    template <class charT> struct ios_traits<charT> {
      typedef charT char_type;
      typedef INT_T int_type;
      typedef POS_T pos_type;
      typedef OFF_T off_type;
      typedef INT_T state_type;
      static char_type  to_char_type(int_type);
      static int_type   to_int_type (char_type);
      static bool       eq_char_type(char_type, char_type);
      static bool       eq_int_type (int_type, int_type);
      static int_type   eof();
      static int_type   not_eof(char_type c);
      static bool       is_eof (int_type);
      static char_type  newline();
      static bool       is_whitespace(ctype<char_type> ctype, char_type c);
      static char_type  eos();
      static size_t     length(const char_type* s);
      static char_type* copy(char_type* dst, const char_type* src, size_t n) ;
    };
  }

1 The template struct ios_traits<charT> is a traits  class  which  main­
  tains  the  definitions of the types and functions necessary to imple­
  ment the template iostream classes.  The template parameter charT rep­
  resents the character container type and each specialized version pro­
  vides the default definitions corresponding to the specialized charac­
  ter container type.
  _________________________
  5) streamsize is used in most places where ISO  C  would  use  size_t.
  Most  of  the  uses  of  streamsize  could  use size_t, except for the
  strstreambuf constructors, which require negative values.   It  should
  probably  be  the  signed  type corresponding to size_t (which is what
  Posix.2 calls ssize_t).

2 An  implementation  may  provide  the following two specializations of
  ios_traits:

  struct ios_traits<char>
  struct ios_traits<wchar_t>;

  27.4.2.1  Member functions                    [lib.ios.traits.members]

  27.4.2.1.1                         [lib.ios.char.traits::to.char.type]
       ios_traits::to_char_type

  char_type to_char_type(int_type c);

  Effects:
    Converts a valid character value represented in the int_type to  the
    corresponding  char_type  value.  If c is the end-of-file value, the
    return value is unspecified.

  27.4.2.1.2                          [lib.ios.char.traits::to.int.type]
       ios_traits::to_int_type

  int_type to_int_type(char_type c);

  Effects:
    Converts a valid character value represented in the char_type to the
    corresponding int_type value.

  27.4.2.1.3                         [lib.ios.char.traits::eq.char.type]
       ios_traits::eq_char_type

  bool eq_char_type(char_type c1, char_type c2);

  Returns:
    true if c1 and c2 represent the same character.

  27.4.2.1.4                          [lib.ios.char.traits::eq.int.type]
       ios_traits::eq_int_type

  bool eq_int_type(int_type c1, int_type c2);

  Returns:
    true if c1 and c2 represent the same character.

  27.4.2.1.5  ios_traits::eof                 [lib.ios.char.traits::eof]

  int_type eof();

  Returns:
    an  int_type value which represents the end-of-file.  It is returned
    by several functions to indicate end-of-file state  (no  more  input
    from  an  input  sequence  or  no more output permitted to an output
    sequence), or to indicate an invalid return value.

  27.4.2.1.6  ios_traits::not_eof         [lib.ios.char.traits::not.eof]

  int_type not_eof(char_type c);

  +-------                 BEGIN BOX 5                -------+
  Should the argument type be int_type?
  +-------                  END BOX 5                 -------+

  Returns:
    a value other than the end-of-file, even if c==eof().
  Notes:
    It is used in basic_streambuf<charT,traits>::overflow().
  Returns:
    int_type(c) if c!=eof().

  27.4.2.1.7  ios_traits::is_eof           [lib.ios.char.traits::is.eof]

  bool is_eof(int_type c);

  Returns:
    true if c represents the end-of-file.

  27.4.2.1.8  ios_traits::newline         [lib.ios.char.traits::newline]

  char_type newline();

  Returns:
    a character value which represent the newline character of the basic
    character set.
  Notes:
    It      appears      as      the      default      parameter      of
    basic_istream<charT,traits>::getline().

  27.4.2.1.9                        [lib.ios.char.traits::is.whitespace]
       ios_traits::is_whitespace

  bool is_whitespace(char_type c, ctype<char_type> ctype);

  Returns:
    true if c represents one of the white space characters.  The default
    definition is as if it returns ctype .isspace(c).

1 An  implementation of the template iostream classes may use all of the
  above static member functions in addition to the following three func­
  tions provided from the base struct string_char_traits<CHAR_T>.

  27.4.2.1.10  ios_traits::eos                [lib.ios.char.traits::eos]

  char_type eos();

  Returns:
    The  null  character  which  is  used  for  the  terminator  of null

    terminated character strings.  The default constructor for the char­
    acter container type provides the value.

  27.4.2.1.11  ios_traits::length          [lib.ios.char.traits::length]

  size_t length(const char_type* s);

  Effects:
    Determines  the length of a null terminated character string pointed
    to by s.

  27.4.2.1.12  ios_traits::copy              [lib.ios.char.traits::copy]

  char_type* copy(char_type* dest, const char_type* src, size_t n);

  Effects:
    Copies n characters from the object  pointed  to  by  src  into  the
    object  pointed  to by dest.  If copying takes place between objects
    that overlap, the behavior is undefined.

  27.4.3  Class ios_base                                  [lib.ios.base]
  namespace std {
    class ios_base {
      class failure;
      typedef T1 fmtflags;
      static const fmtflags boolalpha;
      static const fmtflags dec;
      static const fmtflags fixed;
      static const fmtflags hex;
      static const fmtflags internal;
      static const fmtflags left;
      static const fmtflags oct;
      static const fmtflags right;
      static const fmtflags scientific;
      static const fmtflags showbase;
      static const fmtflags showpoint;
      static const fmtflags showpos;
      static const fmtflags skipws;
      static const fmtflags unitbuf;
      static const fmtflags uppercase;
      static const fmtflags adjustfield;
      static const fmtflags basefield;
      static const fmtflags floatfield;
      typedef T2 iostate;
      static const iostate badbit;
      static const iostate eofbit;
      static const iostate failbit;
      static const iostate goodbit;

      typedef T3 openmode;
      static const openmode app;
      static const openmode ate;
      static const openmode binary;
      static const openmode in;
      static const openmode out;
      static const openmode trunc;
      typedef T4 seekdir;
      static const seekdir beg;
      static const seekdir cur;
      static const seekdir end;
      class Init;
      operator bool() const
      bool operator!() const
      ios_type& copyfmt(const ios_type& rhs);
      iostate rdstate() const;
      void clear(iostate state = goodbit);
      void setstate(iostate state);
      bool good() const;
      bool eof()  const;
      bool fail() const;
      bool bad()  const;
      iostate exceptions() const;
      void exceptions(iostate except);
      fmtflags flags() const;
      fmtflags flags(fmtflags fmtfl);
      fmtflags setf(fmtflags fmtfl);
      fmtflags setf(fmtflags fmtfl, fmtflags mask);
      void unsetf(fmtflags mask);
      int_type fill() const;
      int_type fill(int_type ch);
      int precision() const;
      int precision(int prec);
      int width() const;
      int width(int wide);
      locale imbue(const locale& loc);
      locale getloc() const;
      static int xalloc();
      long&  iword(int index);
      void*& pword(int index);
  protected:      // ?
      ios_base();
    private:
  //  static int index;   exposition only
  //  int* iarray;        exposition only
  //  void** parray;      exposition only
    };
  }

  +-------                 BEGIN BOX 6                -------+
  ISSUE: fill can't work in the  non-template  base  class.   Specifying
  fill character.  It is represented as int_type.
  +-------                  END BOX 6                 -------+

1 ios_base defines several member types:

  --a class failure derived from exception;

  --a class Init;

  --three bitmask types, fmtflags, iostate, and openmode;

  --an enumerated type, seekdir.

2 It maintains several kinds of data:

  --state information that reflects the integrity of the stream buffer;

  --control  information that influences how to interpret (format) input
    sequences and how to generate (format) output sequences;

  --additional information that is stored by the program for its private
    use.

  +-------                 BEGIN BOX 7                -------+
  For the sake of exposition, the maintained data is presented here as:

  --static  int index, specifies the next available unique index for the
    integer or pointer arrays maintained for the private use of the pro­
    gram, initialized to an unspecified value;

  --int*  iarray,  points  to  the  first element of an arbitrary-length
    integer array maintained for the private use of the program;

  --void** parray, points to the first element  of  an  arbitrary-length
    pointer array maintained for the private use of the program.
  +-------                  END BOX 7                 -------+

  27.4.3.1  Types                                        [lib.ios.types]

  27.4.3.1.1  Class ios_base::failure                 [lib.ios::failure]

  namespace std {
    class ios_base::failure : public exception {
    public:
      failure(const string& what = message);
      virtual ~failure();
  //  virtual string what() const;        inherited
    };
  }

1 The  class failure defines the base class for the types of all objects
  thrown as exceptions, by functions in the iostreams library, to report
  errors detected during stream buffer operations.

  27.4.3.1.1.1  ios_base::failure           [lib.ios.base::failure.cons]
       constructor

  failure(const string& what = message);

  Effects:
    Constructs an object of class failure, initializing the  base  class
    with exception(what).

1 The string message is an implementation-defined default value.

  27.4.3.1.2  Type ios_base::fmtflags                [lib.ios::fmtflags]

  typedef T1 fmtflags;

1 The  type  fmtflags  is a bitmask type (_lib.bitmask.types_).  Setting
  its elements has the effects indicated in Table 3:

                        Table 3--fmtflags effects

  +---------------------------------------------------------------------+
  |    Element                          Effect(s) if set                |
  +---------------------------------------------------------------------+
  |   boolalpha             insert and extract bool type  in  alpha­    |
  |                         betic format                                |
  |   dec                   converts  integer input or generates in­    |
  |                         teger output in decimal base                |
  |   fixed                 generate floating-point output in fixed-    |
  |                         point notation;                             |
  |   hex                   converts  integer input or generates in­    |
  |                         teger output in hexadecimal base;           |
  |   internal              adds fill characters at a designated in­    |
  |                         ternal  point  in certain generated out­    |
  |                         put;                                        |
  |   left                  adds fill characters on the  left  (ini­    |
  |                         tial  positions)  of  certain  generated    |
  |                         output;                                     |
  |   oct                   converts integer input or generates  in­    |
  |                         teger output in octal base;                 |
  |   right                 adds fill characters on the right (final    |
  |                         positions) of certain generated output;     |
  |   scientific            generates floating-point output in  sci­    |
  |                         entific notation;                           |
  |   showbase              generates a prefix indicating the numer­    |
  |                         ic base of generated integer output;        |
  |   showpoint             generates a decimal-point character  un­    |
  |                         conditionally   in  generated  floating-    |
  |                         point output;                               |
  |   showpos               generates a + sign in non-negative  gen­    |
  |                         erated numeric output;                      |
  |   skipws                skips leading white space before certain    |
  |                         input operations;                           |
  |   unitbuf               flushes output after each output  opera­    |
  |                         tion;                                       |
  |   uppercase             replaces  certain lowercase letters with    |
  |                         their uppercase equivalents in generated    |
  |                         output.                                     |
  +---------------------------------------------------------------------+

2 Type fmtflags also defines the constants indicated in Table 4:

                       Table 4--fmtflags constants

                 +--------------------------------------+
                 | Constant        Allowable values     |
                 +--------------------------------------+
                 |adjustfield   left | right | internal |
                 |basefield     dec | oct | hex         |
                 |floatfield    scientific | fixed      |
                 +--------------------------------------+

  27.4.3.1.3  Type ios_base::iostate                  [lib.ios::iostate]

  typedef T2 iostate;

1 The type iostate is a bitmask type (_lib.bitmask.types_) that contains
  the elements indicated in Table 5:

                         Table 5--iostate effects

  +---------------------------------------------------------------------+
  |    Element                         Effect(s) if set                 |
  +---------------------------------------------------------------------+
  |    badbit              indicates a loss of integrity in an  in­     |
  |                        put  or  output sequence (such as an ir­     |
  |                        recoverable read error from a file);         |
  |    eofbit              indicates  that   an   input   operation     |
  |                        reached the end of an input sequence;        |
  |    failbit             indicates that an input operation failed     |
  |                        to read the expected characters, or that     |
  |                        an  output  operation failed to generate     |
  |                        the desired characters.                      |
  +---------------------------------------------------------------------+

2 Type iostate also defines the constant:

  --goodbit, the value zero.

  27.4.3.1.4  Type ios_base::openmode                [lib.ios::openmode]

  typedef T3 openmode;

1 The type openmode is a bitmask type  (_lib.bitmask.types_).   It  con­
  tains the elements indicated in Table 6:

                        Table 6--openmode effects

  +---------------------------------------------------------------------+
  |    Element                         Effect(s) if set                 |
  +---------------------------------------------------------------------+
  |    app                 seek to end-of-file before each write to     |
  |                        the file                                     |
  |    ate                 open a file and seek to end-of-file im­      |
  |                        mediately after opening the file             |
  |    binary              perform input and output in binary mode      |
  |                        (as opposed to text mode)                    |
  |    in                  open a file for input                        |
  |    out                 open a file for output                       |
  |    trunc               truncate an existing file when opening       |
  |                        it                                           |
  +---------------------------------------------------------------------+

  27.4.3.1.5  Type ios_base::seekdir                  [lib.ios::seekdir]

  typedef T4 seekdir;

1 The  type  seekdir is an enumerated type (_lib.enumerated.types_) that
  contains the elements indicated in Table 7:

                         Table 7--seekdir effects

  +---------------------------------------------------------------------+
  |    Element                             Meaning                      |
  +---------------------------------------------------------------------+
  |    beg                 request a seek (positioning for subse­       |
  |                        quent input or output within a sequence)     |
  |                        relative to the beginning of the stream      |
  |    cur                 request a seek relative to the current       |
  |                        position within the sequence                 |
  |    end                 request a seek relative to the current       |
  |                        end of the sequence                          |
  +---------------------------------------------------------------------+

  27.4.3.1.6  Class ios_base::Init                       [lib.ios::Init]

  namespace std {
    class ios_base::Init {
    public:
      Init();
     ~Init();
    private:
  //  static int init_cnt;        exposition only
    };
  }

1 The class Init describes an object whose construction ensures the con­
  struction  of  the  four objects declared in <iostream> that associate
  file stream buffers with the standard C streams provided  for  by  the
  functions declared in <cstdio> (_lib.c.files_).

  +-------                 BEGIN BOX 8                -------+
  For the sake of exposition, the maintained data is presented here as:

  --static int init_cnt, counts the number of constructor and destructor
    calls for class Init, initialized to zero.
  +-------                  END BOX 8                 -------+

  27.4.3.1.6.1  ios_base::Init                 [lib.ios.base::init.cons]
       constructor

  Init();

  Effects:
    Constructs  an object of class Init.  If init_cnt is zero, the func­
    tion stores the value one in init_cnt, then constructs and  initial­
    izes   the   objects   cin   (_lib.cin_),  cout  (_lib.cout_),  cerr
    (_lib.cerr_), clog (_lib.clog_), win (_lib.win_), wout (_lib.wout_),
    werr (_lib.werr_), and wlog (_lib.wlog_).  In any case, the function
    then adds one to the value stored in init_cnt.

  27.4.3.1.6.2  ios_base::Init destructor       [lib.ios.base::init.des]

  ~Init();

  Effects:
    Destroys an object of class Init.  The function subtracts  one  from
    the  value  stored in init_cnt and, if the resulting stored value is
    one, calls cout.flush(), cerr.flush(), and clog.flush().

  27.4.3.2  Member functions                           [lib.ios.members]

  27.4.3.2.1  ios_base::operator bool           [lib.ios::operator.bool]

  operator bool() const

  Returns:
    fail() | bad().

  27.4.3.2.2  ios_base::operator!                   [lib.ios::operator!]

  bool operator!() const

  Returns:
    if fail() | bad().

  27.4.3.2.3  ios_base::copyfmt                       [lib.ios::copyfmt]

  ios_base<charT,traits>& copyfmt(const ios_base<charT,traits>& rhs);

  Effects:
    Assigns to the member objects  of  *this  the  corresponding  member
    objects of rhs, except that:

  --sb and rdstate() are left unchanged;

  --exceptions() is altered last by calling exception(rhs.except).

  --The  contents of arrays pointed at by pword and iword are copied not
    the pointers themselves.6)

1 If any newly stored pointer values in *this point  at  objects  stored
  outside  the  object  rhs, and those objects are destroyed when rhs is
  destroyed, the newly stored pointer values are  altered  to  point  at
  newly constructed copies of the objects.
  Returns:
    *this.

  27.4.3.2.4  ios_base::rdstate                       [lib.ios::rdstate]

  iostate rdstate() const;

  Returns:
    The control state of the stream buffer.

  27.4.3.2.5  ios_base::clear(iostate)        [lib.ios::clear.basic.ios]

  void clear(iostate state = goodbit);

  Postcondition:
    state  == rdstate().
  Effects:
    If  sb is a null pointer, the function sets badbit in rdstate().  If
    rdstate() & exceptions() is zero, returns.  Otherwise, the  function
    throws  an  object  fail of class failure, constructed with argument
  _________________________
  6) This suggests an infinite amount of copying, but the implementation
  can  keep track of the maximum element of the arrays that is non-zero.

    values that are implementation-defined.

  27.4.3.2.6                               [lib.ios::setstate.basic.ios]
       ios_base::setstate(iostate)

  void setstate(iostate state);

  Effects:
    Calls clear(rdstate() | state).

  27.4.3.2.7  ios_base::good                             [lib.ios::good]

  bool good() const;

  Returns:
    rdstate() == 0

  27.4.3.2.8  ios_base::eof                               [lib.ios::eof]

  bool eof() const;

  Returns:
    true if eofbit is set in rdstate().

  27.4.3.2.9  ios_base::fail                             [lib.ios::fail]

  bool fail() const;

  Returns:
    true if failbit or badbit is set in rdstate().7)

  27.4.3.2.10  ios_base::bad                              [lib.ios::bad]

  bool bad() const;

  Returns:
    true if badbit is set in rdstate().

  27.4.3.2.11  ios_base::exceptions                [lib.ios::exceptions]

  iostate exceptions() const;

  Returns:
    A  mask  that determines what elements set in rdstate() cause excep­
    tions to be thrown.

    void exceptions(iostate except);

  Postcondition:
    except  == exceptions().
  _________________________
  7) Checking badbit also for fail() is historical practice.

  Effects:
    Calls clear(rdstate()).

  27.4.3.2.12  ios_base::flags                          [lib.ios::flags]

  fmtflags flags() const;

  Returns:
    The format control information for both input and output.

    fmtflags flags(fmtflags fmtfl);

  Postcondition:
    fmtfl  == flags().
  Returns:
    The previous value of flags().

  27.4.3.2.13  ios_base::setf(fmtflags)                  [lib.ios::setf]

  fmtflags setf(fmtflags fmtfl);

  Effects:
    Sets fmtfl in flags().
  Returns:
    The previous value of flags().

    fmtflags setf(fmtflags fmtfl, fmtflags mask);

  Effects:
    Clears mask in flags(), sets fmtfl & mask in flags().
  Returns:
    The previous value of flags().

  27.4.3.2.14  ios_base::unsetf(fmtflags)              [lib.ios::unsetf]

  void unsetf(fmtflags mask);

  Effects:
    Clears mask in flags().

  27.4.3.2.15  basic_ios::fill                           [lib.ios::fill]

  int_type fill() const;

  Returns:
    The character to use to pad (fill) an output conversion to the spec­
    ified field width.

    int_type fill(int_type fillch);

  Postcondition:
    fillch  == fill().

  Returns:
    The previous value of fill().

  27.4.3.2.16  ios_base::precision                  [lib.ios::precision]

  int precision() const;

  Returns:
    The precision (number of digits after the decimal point) to generate
    on certain output conversions.

    int precision(int prec);

  Postcondition:
    prec  == precision().
  Returns:
    The previous value of precision().

  27.4.3.2.17  ios_base::width                          [lib.ios::width]

  int width() const;

  Returns:
    The field width (number of characters) to generate on certain output
    conversions.

    int width(int wide);

  Postcondition:
    wide  == width().
  Returns:
    The previous value of width().

  27.4.3.2.18  ios_base::imbue                          [lib.ios::imbue]

  locale imbue(const locale loc);

  Postcondition:
    loc  == getloc().
  Notes:
    In  case  the member pointer sb of the basic_streambuf<charT,traits>
    has already initialized, the function also imbues the object pointed
    to by sb.
  Returns:
    The previous value of getloc().

  27.4.3.2.19  ios_base::getloc                        [lib.ios::getloc]

  locale getloc() const;

  Returns:
    The  classic  C  locale  if  no  locale has been imbued.  Otherwise,
    returns the locale in which to perform  locale-dependent  input  and

    output operations.

  27.4.3.2.20  ios_base::xalloc                        [lib.ios::xalloc]

  static int xalloc();

  Returns:
    index ++.

  27.4.3.2.21  ios_base::iword                          [lib.ios::iword]

  long& iword(int idx);

  Effects:
    If  iarray  is a null pointer, allocates an array of int of unspeci­
    fied size and stores a pointer to its first element in iarray.   The
    function then extends the array pointed at by iarray as necessary to
    include the element iarray[idx].  Each newly  allocated  element  of
    the array is initialized to zero.
  Returns:
    iarray[idx].
  Notes:
    After  a subsequent call to iword(int) for the same object, the ear­
    lier return value may no longer be valid.8)

  27.4.3.2.22  ios_base::pword                          [lib.ios::pword]

  void* & pword(int idx);

  Effects:
    If parray is a null pointer, allocates an array of pointers to  void
    of  unspecified  size  and  stores a pointer to its first element in
    parray.  The function then extends the array pointed at by parray as
    necessary  to include the element parray[idx].  Each newly allocated
    element of the array is initialized to a null pointer.
  Returns:
    parray[idx].
  Notes:
    After a subsequent call to pword(int) for the same object, the  ear­
    lier return value may no longer be valid.

  27.4.3.2.23  ios_base constructor                  [lib.ios.base.cons]

  ios_base();

  Effects:
    Constructs  an object of class ios_base, assigning initial values to
    its member objects by calling init(0).
  _________________________
  8) An implementation is free  to  implement  both  the  integer  array
  pointed  at  by  iarray  and the pointer array pointed at by parray as
  sparse data structures, possibly with a one-element cache for each.

  27.4.3.2.24  ios_base::init                       [lib.ios.base::init]

  void init(basic_streambuf<charT,traits>* sb);

  Effects:
    The postconditions of this function are indicated in Table 8:

                           Table 8--init effects

         +--------------------------------------------------------+
         |  Element                       Value                   |
         +--------------------------------------------------------+
         |rdstate()      goodbit if sb is  not  a  null  pointer, |
         |               otherwise badbit.                        |
         |exceptions()   goodbit                                  |
         |flags()        skipws | dec                             |
         |width()        zero                                     |
         |precision()    6                                        |
         |fill()         the space character                      |
         |getloc()       new  locale(),  which  means the default |
         |               value is the current global locale;9)    |
         |index          ???                                      |
         |iarray         a null pointer                           |
         |parray         a null pointer                           |
         +--------------------------------------------------------+

  +-------                 BEGIN BOX 9                -------+
  Note: the default locale value shall be  global  but  not  transparent
  because  the  locality  of the stream buffer will be unchanged between
  its lifetime.
  +-------                  END BOX 9                 -------+

  27.4.4  Template class basic_ios                             [lib.ios]
  namespace std {
    template<class charT, class traits = ios_traits<charT> >
    class basic_ios : public ios_base {
      typedef basic_ios<charT,traits> ios_type;
    public:
  // Added for consistency:
      typedef INT_T            streamsize;
      typedef charT            char_type;
      typedef traits::int_type int_type;
      typedef traits::pos_type pos_type;
      typedef traits::off_type off_type;
      int_type  eof()     { return traits::eof(); }
      char_type newline() { return traits::newline(); }

  _________________________
  9) Usually, classic().

      basic_ios(basic_streambuf<charT,traits>* sb);
      virtual ~basic_ios();
      basic_ostream<charT,traits>* tie() const;
      basic_ostream<charT,traits>* tie(basic_ostream<charT,traits>* tiestr);
      basic_streambuf<charT,traits>* rdbuf() const;
      basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb);
    protected:
        basic_ios();
        void init(basic_streambuf<charT,traits>* sb);
    };
  }

  +-------                BEGIN BOX 10                -------+
  Note:   template   parameter   coupling    between    basic_ios    and
  basic_streambuf:  Both  basic_ios and basic_streambuf corresponding to
  it should take the same template parameter  <charT,traits>.   We  need
  not    allow    to   make   a   couple   of   basic_ios<wchar_t>   and
  basic_streambuf<char>.
  +-------                 END BOX 10                 -------+

  27.4.4.1  basic_ios constructors               [lib.basic.ios.sb.cons]

  basic_ios(basic_streambuf<charT,traits>* sb);

  Effects:
    Constructs an object of class basic_ios, assigning initial values to
    its member objects by calling init(sb).

    basic_ios();

  Effects:
    Constructs an object of class basic_ios,

  +-------                BEGIN BOX 11                -------+
  TBS
  +-------                 END BOX 11                 -------+

  void init(basic_streambuf<charT,traits>* sb);

  +-------                BEGIN BOX 12                -------+
  TBS
  +-------                 END BOX 12                 -------+

  27.4.4.2  Member functions                     [lib.basic.ios.members]

  27.4.4.2.1  basic_ios::tie                              [lib.ios::tie]

  basic_ostream<charT,traits>* tie() const;

  Returns:
    An  output  sequence  that  is  tied to (synchronized with) an input
    sequence controlled by the stream buffer.

    basic_ostream<charT,traits>*
      tie(basic_ostream<charT,traits>* tiestr);

  Postcondition:
    tiestr  == tie().
  Returns:
    The previous value of tie().

  27.4.4.2.2  basic_ios::rdbuf                          [lib.ios::rdbuf]

  basic_streambuf<charT,traits>* rdbuf() const;

  Returns:
    The streambuf associated with the stream.

    basic_streambuf<charT,traits>*
      rdbuf(basic_streambuf<charT,traits>* sb);

  Postcondition:
    sb  == rdbuf().
  Effects:
    Calls clear().

  +-------                BEGIN BOX 13                -------+
  Note: need to modify so as to describe the occurence of imbueing  get­
  loc()::codecvt into the argument stream buffer.
  +-------                 END BOX 13                 -------+

  Returns:
    The previous value of rdbuf().

  27.4.5  ios_base manipulators                      [lib.std.ios.manip]

  27.4.5.1  fmtflags manipulators                   [lib.fmtflags.manip]

  ios_base& boolalpha(ios_base& str);

  Effects:
    Calls str.setf(ios_base::boolalpha).
  Returns:
    str.10)

    ios_base& noboolalpha(ios_base& str);

  Effects:
    Calls str.unsetf(ios_base::boolalpha).
  Returns:
    str.

    ios_base& showbase(ios_base& str);

  Effects:
    Calls str.setf(ios_base::showbase).
  Returns:
    str.

    ios_base& noshowbase(ios_base& str);

  Effects:
    Calls str.unsetf(ios_base::showbase).
  Returns:
    str.

    ios_base& showpoint(ios_base& str);

  Effects:
    Calls str.setf(ios_base::showpoint).
  Returns:
    str.

    ios_base& noshowpoint(ios_base& str);

  Effects:
    Calls str.unsetf(ios_base::showpoint).
  Returns:
    str.

    ios_base& showpos(ios_base& str);

  Effects:
    Calls str.setf(ios_base::showpos).
  Returns:
    str.

    ios_base& noshowpos(ios_base& str);

  Effects:
    Calls str.unsetf(ios_base::showpos).
  Returns:
    str.

    ios_base& skipws(ios_base& str);

  Effects:
    Calls str.setf(ios_base::skipws).
  Returns:
    str.

    ios_base& noskipws(ios_base& str);

  Effects:
    Calls str.unsetf(ios_base::skipws).
  Returns:
    str.

    ios_base& uppercase(ios_base& str);

  Effects:
    Calls str.setf(ios_base::uppercase).
  Returns:
    str.

    ios_base& nouppercase(ios_base& str);

  Effects:
    Calls str.unsetf(ios_base::uppercase).
  Returns:
    str.

  27.4.5.2  adjustfield manipulators             [lib.adjustfield.manip]

  ios_base& internal(ios_base& str);

  Effects:
    Calls str.setf(ios_base::internal,ios_base::adjustfield)
  Returns:
    str.

    ios_base& left(ios_base& str);

  Effects:
    Calls str.setf(ios_base::left,ios_base::adjustfield)
  Returns:
    str.

    ios_base& right(ios_base& str);

  Effects:
    Calls str.setf(ios_base::right,ios_base::adjustfield)
  Returns:
    str.

  27.4.5.3  basefield manipulators                 [lib.basefield.manip]

  ios_base& dec(ios_base& str);

  Effects:
    Calls str.setf(ios_base::dec,ios_base::basefield)
  Returns:
    str.
  _________________________
  10)  The  function signature dec(ios_base&) can be called by the func­

    ios_base& hex(ios_base& str);

  Effects:
    Calls str.setf(ios_base::hex,ios_base::basefield)
  Returns:
    str.

    ios_base& oct(ios_base& str);

  Effects:
    Calls str.setf(ios_base::oct,ios_base::basefield)
  Returns:
    str.

  27.4.5.4  floatfield manipulators               [lib.floatfield.manip]

  ios_base& fixed(ios_base& str);

  Effects:
    Calls str.setf(ios_base::fixed,ios_base::floatfield)
  Returns:
    str.

    ios_base& scientific(ios_base& str);

  Effects:
    Calls str.setf(ios_base::scientific,ios_base::floatfield)
  Returns:
    str.

  27.5  Stream buffers                              [lib.stream.buffers]

  Header <streambuf> synopsis

  namespace std {
    template<class charT, class traits = ios_traits<charT> >
      class basic_streambuf;
    typedef basic_streambuf<char>     streambuf;
    typedef basic_streambuf<wchar_t> wstreambuf;
  }

1 The header <streambuf> defines types that control input from and  out­
  put to character sequences.

  _________________________
  tion   signature   basic_ostream&    stream::operator<<(basic_ostream&
  (*)(basic_ostream&))  to permit expressions of the form cout << dec to
  change the format flags stored in cout.

  27.5.1  Stream buffer requirements               [lib.streambuf.reqts]

  27.5.2  Template class                                 [lib.streambuf]
       basic_streambuf<charT,traits>
  namespace std {
    template<class charT, class traits = ios_traits<charT> >
    class basic_streambuf {
    public:
      typedef charT            char_type;
      typedef traits::int_type int_type;
      typedef traits::pos_type pos_type;
      typedef traits::off_type off_type;
  // In order to simplify descriptions and as a convenience for programmers:
      typedef basic_ios<char> ios;
      int_type  eof()     { return traits::eof(); }
      char_type newline() { return traits::newline(); }
   public:
      virtual ~basic_streambuf();
      pos_type pubseekoff(off_type off,
                          basic_ios<charT,traits>::seekdir way,
                          basic_ios<charT,traits>::openmode which
                              = basic_ios<charT,traits>::in
                              | basic_ios<charT,traits>::out);
      pos_type pubseekpos(pos_type sp,
                          basic_ios<charT,traits>::openmode which
                              = basic_ios<charT,traits>::in
                              | basic_ios<charT,traits>::out);
      basic_streambuf<char_type,traits>*
               pubsetbuf(char_type* s, streamsize n);
      int      in_avail();
      int      pubsync();
      int_type sbumpc();
      int_type sgetc();
      int      sgetn(char_type* s, streamsize n);
      int_type snextc();
      int_type sputbackc(char_type c);
      int      sungetc();
      int      sputc(int c);
      int_type sputn(const char_type* s, streamsize n);

    protected:
      basic_streambuf();
      char_type* eback() const;
      char_type* gptr() const;
      char_type* egptr() const;
      void       gbump(int n);
      void       setg(char_type* gbeg,
                      char_type* gnext,
                      char_type* gend);
      char_type* pbase() const;
      char_type* pptr() const;
      char_type* epptr() const;
      void       pbump(int n);
      void       setp(char_type* pbeg,
                      char_type* pend);
      virtual int_type overflow (int_type c = eof());
      virtual int_type pbackfail(int_type c = eof());
      virtual int      showmany();
      virtual int_type underflow();
      virtual int_type uflow();
      virtual streamsize xsgetn(char_type* s, streamsize n);
      virtual streamsize xsputn(const char_type* s, streamsize n);
      virtual pos_type seekoff(off_type off,
                               basic_ios<charT,traits>::seekdir way,
                               basic_ios<charT,traits>::openmode which = in | out);
      virtual pos_type seekpos(pos_type sp,
                               basic_ios<charT,traits>::openmode which = in | out);
      virtual basic_streambuf<char_type,traits>*
                setbuf(char_type* s, streamsize n);
      virtual int sync();
    };
  }

1 The class template basic_streambuf<charT,traits> serves as an abstract
  base class for deriving various stream buffers whose objects each con­
  trol two character sequences:

  --a character input sequence;

  --a character output sequence.

2 The  class  streambuf  is  an  instantiation  of  the  template  class
  basic_streambuf specialized by the type char.

3 The  class  wstreambuf  is  an  instantiation  of  the  template class
  basic_streambuf specialized by the type wchar_t.

4 Stream buffers can impose various constraints on  the  sequences  they
  control.  Some constraints are:

  --The controlled input sequence can be not readable.

  --The controlled output sequence can be not writable.

  --The  controlled  sequences  can  be  associated with the contents of
    other representations for  character  sequences,  such  as  external
    files.

  --The  controlled  sequences can support operations directlyto or from
    associated sequences.

  --The controlled sequences can impose limitations on how  the  program
    can read characters from a sequence, write characters to a sequence,
    put characters back into an input  sequence,  or  alter  the  stream
    position.

5 Each  sequence  is characterized by three pointers which, if non-null,
  all point into the same charT array object.  The array  object  repre­
  sents, at any moment, a (sub)sequence of characters from the sequence.
  Operations performed on a sequence alter the values  stored  in  these
  pointers,  perform  reads  and  writes  directly to or from associated
  sequences, and alter ``the stream position'' and conversion  state  as
  needed  to maintain this subsequence relationship.  The three pointers
  are:

  --the beginning pointer,  or  lowest  element  address  in  the  array
    (called xbeg here);

  --the  next  pointer, or next element address that is a current candi­
    date for reading or writing (called xnext here);

  --the end pointer, or first element address  beyond  the  end  of  the
    array (called xend here).

6 The  following  semantic constraints shall always apply for any set of
  three pointers for a sequence, using the pointer names  given  immedi­
  ately above:

  --If  xnext  is  not  a null pointer, then xbeg and xend shall also be
    non-null pointers into the same charT array, as described above.

  --If xnext is not a null pointer  and  xnext  <  xend  for  an  output
    sequence,  then a write position is available.  In this case, *xnext
    shall be assignable as the next element to  write  (to  put,  or  to
    store a character value, into the sequence).

  --If  xnext  is  not  a  null  pointer  and  xbeg < xnext for an input
    sequence, then a putback  position  is  available.   In  this  case,
    xnext[-1]  shall  have  a  defined value and is the next (preceding)
    element to store a  character  that  is  put  back  into  the  input
    sequence.

  --If  xnext  is  not  a  null  pointer  and  xnext < xend for an input
    sequence, then a read position is available.  In this  case,  *xnext
    shall  have a defined value and is the next element to read (to get,
    or to obtain a character value, from the sequence).

  27.5.2.1  basic_streambuf constructors      [lib.basic.streambuf.cons]

  basic_streambuf();

  Effects:
    Constructs  an  object  of  class  basic_streambuf<charT,traits> and
    initializes:11)

  --all its pointer member objects to null pointers,

  --the getloc() member object to the return value of global().
  Notes:
    Once the getloc() member is initialized its locale-dependent  behav­
    ior does not change until the next imbueing of the locale.

  27.5.2.2  Member functions                     [lib.streambuf.members]

  27.5.2.2.1                                 [lib.streambuf::pubseekoff]
       basic_streambuf::pubseekoff

  pos_type pubseekoff(off_type off,
                      basic_ios<charT,traits>::seekdir way,
                      basic_ios<charT,traits>::openmode which
      = basic_ios<charT,traits>::in | basic_ios<charT,traits>::out);

  Returns:
    seekoff(off,way,which).

  27.5.2.2.2                                 [lib.streambuf::pubseekpos]
       basic_streambuf::pubseekpos

  pos_type pubseekpos(pos_type sp,
        basic_ios<charT,traits>::openmode which
      = basic_ios<charT,traits>::in | basic_ios<charT,traits>::out);

  Returns:
    seekpos(sp,which).

  27.5.2.2.3  basic_streambuf::pubsetbuf      [lib.streambuf::pubsetbuf]

  basic_streambuf<char_type,traits>*
  setbuf(char_type* s, streamsize n);

  Returns:
    setbuf(s,n).

  _________________________
  11) The default constructor is protected for class basic_streambuf  to
  assure  that  only  objects for classes derived from this class may be
  constructed.

  27.5.2.2.4  basic_streambuf::in_avail        [lib.streambuf::in.avail]

  int in_avail();

  Returns:
    If the input sequence read position is not available, returns  show­
    many().  Otherwise, returns egptr() - gptr().

  27.5.2.2.5  basic_streambuf::pubsync          [lib.streambuf::pubsync]

  int pubsync();

  Returns:
    sync().

  27.5.2.2.6  basic_streambuf::sbumpc            [lib.streambuf::sbumpc]

  int_type sbumpc();

  Returns:
    If  the  input  sequence  read  position  is  not available, returns
    uflow().  Otherwise, returns char_type(*gptr()) and  increments  the
    next pointer for the input sequence.

  27.5.2.2.7  basic_streambuf::sgetc              [lib.streambuf::sgetc]

  int_type sgetc();

  Returns:
    If the input sequence read position is not available, returns under­
    flow().  Otherwise, returns char_type(*gptr()).

  27.5.2.2.8  basic_streambuf::sgetn              [lib.streambuf::sgetn]

  int sgetn(char_type* s, streamsize n);

  Returns:
    xsgetn(s,n).

  27.5.2.2.9  basic_streambuf::snextc            [lib.streambuf::snextc]

  int_type snextc();

  Effects:
    Calls sbumpc() and, if that function returns eof(),  returns  eof().
    Otherwise, returns sgetc().
  Notes:
    Uses traits::eof().

  27.5.2.2.10                                 [lib.streambuf::sputbackc]
       basic_streambuf::sputbackc

  int_type sputbackc(char_type c);

  Returns:
    If the input sequence putback position is not available, or if c  !=
    gptr()[-1],  returns  pbackfail(c).   Otherwise, decrements the next
    pointer for the input sequence and returns *gptr().

  27.5.2.2.11  basic_streambuf::sungetc         [lib.streambuf::sungetc]

  int sungetc();

  Returns:
    If the input sequence putback position  is  not  available,  returns
    pbackfail().   Otherwise,  decrements the next pointer for the input
    sequence and returns *gptr().

  27.5.2.2.12  basic_streambuf::sputc             [lib.streambuf::sputc]

  int sputc(int c);

  Returns
    If the output sequence write  position  is  not  available,  returns
    overflow(c).  Otherwise, stores c at the next pointer for the output
    sequence, increments the pointer, and returns *pptr().

  27.5.2.2.13  basic_streambuf::sputn             [lib.streambuf::sputn]

  int_type sputn(const char_type* s, streamsize n);

  Returns:
    xsputn(s,n).

  27.5.2.2.14  basic_streambuf::eback             [lib.streambuf::eback]

  char_type* eback() const;

  Returns:
    The beginning pointer for the input sequence.

  27.5.2.2.15  basic_streambuf::gptr               [lib.streambuf::gptr]

  char_type* gptr() const;

  Returns:
    The next pointer for the input sequence.

  27.5.2.2.16  basic_streambuf::egptr             [lib.streambuf::egptr]

  char_type* egptr() const;

  Returns:
    The end pointer for the output sequence.

  27.5.2.2.17  basic_streambuf::gbump             [lib.streambuf::gbump]

  void gbump(int n);

  Effects:
    Advances the next pointer for the input sequence by n.

  27.5.2.2.18  basic_streambuf::setg               [lib.streambuf::setg]

  void setg(char_type* gbeg,
     char_type* gnext,
     char_type* gend);

  Postconditions:
    gbeg  == eback(), gnext  == gptr(), and gend  == egptr().

  27.5.2.2.19  basic_streambuf::pbase             [lib.streambuf::pbase]

  char_type* pbase() const;

  Returns:
    The beginning pointer for the output sequence.

  27.5.2.2.20  basic_streambuf::pptr               [lib.streambuf::pptr]

  char_type* pptr() const;

  Returns:
    The next pointer for the output sequence.

  27.5.2.2.21  basic_streambuf::epptr             [lib.streambuf::epptr]

  char_type* epptr() const;

  Returns:
    The end pointer for the output sequence.

  27.5.2.2.22  basic_streambuf::pbump             [lib.streambuf::pbump]

  void pbump(int n);

  Effects:
    Advances the next pointer for the output sequence by n.

  27.5.2.2.23  basic_streambuf::setp               [lib.streambuf::setp]

  void setp(char_type* pbeg, char_type* pend);

  Postconditions:
    pbeg  == pbase(), pbeg  == pptr(), and pend  == epptr().

  27.5.2.2.24  basic_streambuf::overflow       [lib.streambuf::overflow]

  virtual int_type overflow(int_type c = eof());

  Effects:
    Consumes some initial subsequence of the characters of  the  pending
    sequence.  The pending sequence is defined as the concatenation of

  a)if  pbase()  is  NULL  then  the  empty sequence otherwise, pptr() -
    pbase() characters beginning at pbase().

  b)if c == eof() then the empty sequence otherwise, the  sequence  con­
    sisting of c.
  Notes:
    The  member functions sputc() and sputn() call this function in case
    that no room can be found in the put buffer enough to accomodate the
    argument character sequence.

1 Every  overriding  definition  of this virtual function shall obey the
  following constraints:

  1)The effect  of  consuming  a  character  on  the  associated  output
    sequence is specified12)

  2)Let r be the number of characters in the pending sequence  not  con­
    sumed.   If  r  is  non-zero  then pbase() and pptr() must be set so
    that: pptr() - pbase() == r and the r characters starting at pbase()
    are  the  associated output stream.  In case r  is zero (all charac­
    ters of the pending sequence have been consumed) then either pbase()
    is  set to NULL, or pbase() and pptr() are both set to the same non-
    NULL value.

  3)The function may fail if either  appending  some  character  to  the
    associated  output  stream  fails  or  if  it is unable to establish
    pbase() and pptr() according to the above rules.
  Returns:
    eof() or throws an exception if the function fails.
    Otherwise,  returns  some  value  other  than  eof()   to   indicate
    success.13)
  _________________________
  12)  That  is,  for  each  class  derived  from  an  instance  of  ba­
  sic_streambuf in this clause, a specification of how consume a charac­
  ter  effects the associated output sequence is given.  There is no re­
  quirement on a program-defined class.
  13) Typically, overflow returns c to indicate success.

  Default behavior:
    Returns eof().

  27.5.2.2.25                                 [lib.streambuf::pbackfail]
       basic_streambuf::pbackfail

  virtual int_type pbackfail(int c = eof());

1 The public functions of basic_streambuf call this  virtual  only  when
  gptr()  is  null,  gptr()==eback(),  or *gptr()!=c.  Other calls shall
  also satisfy that constraint.

2 The   pending   sequence   is   defined   as   for    underflow    (in
  _lib.streambuf::underflow_) with the modifications that

  --If  c==eof()  then  the  input  sequence  is backed up one character
    before the pending sequence is determined.

  --If c!=eof() then c is prepended.   Whether  the  input  sequence  is
    backed up or modified in any other way is unspecified.

3 On return, the constraints of gptr(), eback(), and pptr() are the same
  as for underflow (in _lib.streambuf::underflow_)
  Returns:
    eof() to indicate failure.  Failure  may  occur  because  the  input
    sequence  could  not  be  backed up, or if for some other reason the
    pointers could not be set consistent with the  constraints.   pback­
    fail is called only when put back has really failed.
    Returns some value other than eof() to indicate success.
  Default behavior:
    Returns eof().

  27.5.2.2.26                                  [lib.streambuf::showmany]
       basic_streambuf::showmany14)

  virtual int showmany();

  Returns:
    a count of the guaranteed number of characters that can be read from
    the  input  sequence  before a call to uflow()or underflow() returns
    eof().  A positive return value of indicates that the next such call
    will not return eof().15)
  Default behavior:
    Returns zero.

  _________________________
  14) The morphemes of showmany are "es-how-manyS, not "show-many".
  15)  The  next such call might fail by throwing an exception.  The in­
  tention is that the next call will return ``immediately.''

  27.5.2.2.27                                 [lib.streambuf::underflow]
       basic_streambuf::underflow

  virtual int_type underflow();

1 The public members of basic_streambuf call this virtual only if gptr()
  is null or gptr() >= egptr()
  Returns:
    the first character of the pending sequence,  if  possible,  without
    moving the input sequence position past it.  If the pending sequence
    is null then the function fails.

2 The pending sequence of characters is defined as the concatenation of:

  a)If  gptr() is non- NULL, then the egptr() - gptr() characters start­
    ing at gptr(), otherwise the empty sequence.

  b)Some sequence (possibly empty) of characters  read  from  the  input
    sequence.

3 The result character is

  a)If  the  pending  sequence  is non-empty, the first character of the
    sequence.

  b)If the pending sequence empty then the next character that would  be
    read from the input sequence.

4 The backup sequence is defined as the concatenation of:

  a)If eback() is null then empty,

  b)Otherwise the gptr() - eback() characters beginning at eback().

5 The function sets up the gptr() and egptr() satisfying one of:

  a)If  the  pending  sequence  is  non-empty,  egptr()  is non-null and
    egptr() - gptr() characters starting at gptr() are the characters in
    the pending sequence

  b)If  the  pending  sequence is empty, either gptr() is null or gptr()
    and egptr() are set to the same non- NULL pointer.

6 If eback() and gptr() are non-null  then  the  function  is  not  con­
  strained  as  to their contents, but the ``usual backup condition'' is
  that either:

  a)If the backup sequence contains at least gptr()  -  eback()  charac­
    ters, then the gptr() - eback() characters starting at eback() agree
    with the last gptr() - eback() characters of the backup sequence.

  b)Or the n characters starting at gptr() - n  agree  with  the  backup

    sequence (where n is the length of the backup sequence)
  Returns:
    eof() to indicate failure.
  Default behavior:
    Returns eof().

  27.5.2.2.28  basic_streambuf::uflow             [lib.streambuf::uflow]

  virtual int_type uflow();

1 The     constraints     are     the     same    as    for    underflow
  (_lib.streambuf::underflow_)  except  that  the  result  character  is
  transfered  from  the pending sequence to the backup sequence, and the
  pending sequence may not be empty before the transfer.
  Default behavior:
    Calls underflow(eof()).  If underflow returns eof(), returns  eof().
    Otherwise, does gbump(-1) and returns *gptr().
  Returns:
    not_eof(c).

  27.5.2.2.29  basic_streambuf::xsgetn           [lib.streambuf::xsgetn]

  virtual streamsize xsgetn(char_type* s, streamsize n);

  Effects:
    Assigns up to n characters to successive elements of the array whose
    first element is designated by s.  The characters assigned are  read
    from  the  input  sequence  as  if  by  repeated  calls to sbumpc().
    Assigning stops when either n characters have  been  assigned  or  a
    call to sbumpc() would return eof().
  Returns:
    The number of characters assigned.16)

  27.5.2.2.30  basic_streambuf::xsputn           [lib.streambuf::xsputn]

  virtual streamsize xsputn(const char_type* s, streamsize n);

1 Writes  up  to  n  characters to the output sequence as if by repeated
  calls to sputc(c).  The characters written are obtained  from  succes­
  sive  elements  of  the  array whose first element is designated by s.
  Writing stops when either n characters have been written or a call  to
  sputc(c) would return eof().
  Returns:
    The number of characters written.

  _________________________
  16)  Classes  derived  from basic_streambuf can provide more efficient
  ways to implement xsgetn and xsputn by overriding these definitions in
  the base class.

  27.5.2.2.31  basic_streambuf::seekoff         [lib.streambuf::seekoff]

  virtual pos_type seekoff(off_type off,
  ic_ios<charT,traits>::seekdir way,
  ic_ios<charT,traits>::openmode which
   = basic_ios<charT,traits>::in | basic_ios<charT,traits>::out);

  Effects:
    Alters  the  stream  positions  within one or more of the controlled
    sequences in a way that is defined separately for each class derived
    from   basic_streambuf  in  this  clause  (_lib.stringbuf::seekoff_,
    _lib.filebuf::seekoff_).
  Default behavior:
    Returns an object of class pos_type that stores  an  invalid  stream
    position (_lib.iostreams.definitions_).

  27.5.2.2.32  basic_streambuf::seekpos         [lib.streambuf::seekpos]

  virtual pos_type seekpos(pos_type sp,
  ic_ios<charT,traits>::openmode which = in | out);

  Effects:
    Alters  the  stream  positions  within one or more of the controlled
    sequences in a way that is defined separately for each class derived
    from   basic_streambuf  in  this  clause  (_lib.stringbuf::seekpos_,
    _lib.filebuf::seekpos_).
  Default behavior:
    Returns an object of class pos_type that stores  an  invalid  stream
    position.

  27.5.2.2.33  basic_streambuf::setbuf           [lib.streambuf::setbuf]

  virtual basic_streambuf*
  buf(char_type* s, streamsize n);

  Effects:
    Performs  an  operation  that  is  defined separately for each class
    derived      from      basic_streambuf      in      this      clause
    (_lib.stringbuf::setbuf_, _lib.filebuf::setbuf_).
  Default behavior:
    Returns this.

  27.5.2.2.34  basic_streambuf::sync               [lib.streambuf::sync]

  virtual int sync();

  Effects:
    Synchronizes  the controlled sequences with the arrays.  That is, if
    pbase() is non-null the characters between pbase()  and  pptr()  are
    written  to  the controlled sequence, and if gptr() is non-null, the
    characters between gptr() and egptr()  are  restored  to  the  input
    sequence.  The pointers may then be reset as appropriate.

  Returns:
    -1  on  failure.   What  constitutes  failure  is determined by each
    derived class (_lib.filebuf::sync_).
  Default behavior:
    Returns zero.

  27.6  Formatting and manipulators                [lib.iostream.format]

  Header <istream> synopsis

  namespace std {
    template <class charT, class traits = ios_traits<charT> >
      class basic_istream;
    typedef basic_istream<char>     istream;
    typedef basic_istream<wchar_t> wistream;

    template<class charT, class traits>
      basic_istream<charT,traits>& ws(basic_istream<charT,traits>& is);
  }

  Header <ostream> synopsis

  namespace std {
    template <class charT, class traits = ioc_traits<charT> >
      class basic_ostream;
    typedef basic_ostream<char>     ostream;
    typedef basic_ostream<wchar_t> wostream;

    template<class charT, class traits>
      basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);
    template<class charT, class traits>
      basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);
    template<class charT, class traits>
      basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);
  }

  Header <iomanip> synopsis

  #include <istream>
  #include <ostream>

  namespace std {
      typedef ? smanip;

      smanip resetiosflags(ios_base::fmtflags mask);
      smanip setiosflags  (ios_base::fmtflags mask);
      smanip setbase(int base);
      smanip setfill(int c);
      smanip setprecision(int n);
      smanip setw(int n);
  }

1 The header  <iomanip>  defines  three  template  classes  and  several
  related  functions  that use these template classes to provide extrac­
  tors and inserters that alter information maintained by class ios_base
  and  its  derived  classes.  It also defines several instantiations of
  these template classes and functions.

  27.6.1  Input streams                              [lib.input.streams]

1 The header <istream> defines a type and a function signature that con­
  trol input from a stream buffer.

  27.6.1.1  Template class basic_istream                   [lib.istream]
  namespace std {
    template <class charT, class traits = ios_traits<charT> >
    class basic_istream : virtual public basic_ios<charT,traits> {
    public:
      typedef charT            char_type;
      typedef traits::int_type int_type;
      typedef traits::pos_type pos_type;
      typedef traits::off_type off_type;
      int_type  eof()     { return traits::eof(); }
      char_type newline() { return traits::newline(); }
    private:
  // for abbreviation:
      typedef basic_istream<char_type,traits> istream_type;
      typedef basic_ios<charT,traits> ios_type;
    public:
      basic_istream(basic_streambuf<charT,traits>* sb);
      virtual ~basic_istream();
      bool ipfx(bool noskipws = 0);
      void isfx();
      istream_type& operator>>(istream_type& (*pf)(istream_type&))
      istream_type& operator>>(ios_type& (*pf)(ios_type&))
      istream_type& operator>>(char_type* s);
      istream_type& operator>>(char_type& c);
      istream_type& operator>>(bool& n);
      istream_type& operator>>(short& n);
      istream_type& operator>>(unsigned short& n);
      istream_type& operator>>(int& n);
      istream_type& operator>>(unsigned int& n);
      istream_type& operator>>(long& n);
      istream_type& operator>>(unsigned long& n);
      istream_type& operator>>(float& f);
      istream_type& operator>>(double& f);
      istream_type& operator>>(long double& f);
      istream_type& operator>>(void*& p);
      istream_type& operator>>(basic_streambuf<char_type,traits>& sb);
      int_type get();
      istream_type& get(char_type* s, streamsize n,
                        char_type delim = newline());
      istream_type& get(char_type& c);
      istream_type& get(basic_streambuf<char_type,traits>& sb,
                        char_type delim = newline());

      istream_type& getline(char_type* s, streamsize n,
                            char_type delim = newline());
      istream_type& ignore(streamsize n = 1, int_type delim = eof());
      istream_type& read(char_type* s, streamsize n);
      int readsome(char_type* s, int n);
      int peek();
      istream_type& putback(char_type c);
      istream_type& unget();
      streamsize gcount() const;
      int sync();
    };
  }

1 The class basic_istream defines a number of member function signatures
  that assist in reading and  interpreting  input  from  sequences  con­
  trolled by a stream buffer.

2 Two  groups of member function signatures share common properties: the
  formatted input functions (or extractors) and  the  unformatted  input
  functions.   Both  groups  of input functions are described as if they
  obtain  (or  extract)  input  characters  by  calling  sb.sbumpc()  or
  sb.sgetc().   They may use other public members of istream except that
  they do not invoke any virtual members of sb except uflow().

3 If sb.sbumpc() or sb.sgetc() returns eof(), then the  input  function,
  except  as  explicitly noted otherwise, completes its actions and does
  setstate(eofbit) before returning.

4 If one of these called functions  throws  an  exception,  then  unless
  explicitly  noted  otherwise the input function calls setstate(badbit)
  and if badbit is on in sb.exception() rethrows the  exception  without
  completing its actions.

  27.6.1.2  basic_istream constructors          [lib.basic.istream.cons]

  basic_istream(basic_streambuf<charT,traits>* sb);

  Effects:
    Constructs  an object of class basic_istream, assigning initial val­
    ues to the base class by calling basic_ios::init(sb).
  Postcondition:
    gcount() == 0

    virtual ~basic_istream();

  Effects:
    Destroys an object of class basic_istream.
  Notes:
    Does not perform any operations of rdbuf().

  27.6.1.3  Member functions                       [lib.istream.members]

  27.6.1.3.1  basic_istream::ipfx                    [lib.istream::ipfx]

  bool ipfx(bool noskipws = 0);

  Effects:
    If good() is true, prepares  for  formatted  or  unformatted  input.
    First,   if  tie()  is  not  a  null  pointer,  the  function  calls
    tie()->flush() to synchronize the output sequence with  any  associ­
    ated external C stream.17) If noskipws is zero and flags() &  skipws
    is  nonzero,  the  function  extracts and discards each character as
    long as the next available input character c is a whitespace charac­
    ter.
  Notes:
    The  function  basic_istream<charT,traits>::ipfx() uses the function
    bool  traits::is_whitespace(charT,  const  locale*)  in  the  traits
    structure  to  determine whether the next input character is whites­
    pace or not.

1 To decide if the character c is a whitespace character,  the  function
  performs as if it executes the following code fragment:
    ctype<charT> ctype = getloc().use<ctype<charT> >();
    if (traits::is_whitespace (c, ctype)!=0)
   // c is a whitespace character.
  Returns:
    If,  after  any  preparation  is  completed, good() is true, returns
    true.  Otherwise, it calls setstate(failbit) and returns false.18)

2 A typical implementation of the ipfx() function may be as follows:
  template <class charT, class traits = ios_traits<charT> >
  int basic_istream<charT,traits>::ipfx() {
      ...
  // skipping whitespace according to a constraint function,
  // is_whitespace
      intT c;
      typedef ctype<charT> ctype_type;
      ctype_type& ctype = getloc().use<ctype_type>();
      while ((c = rdbuf()->snextc()) != eof()) {
        if (!traits::is_whitespace (c,ctype)==0) {
          rdbuf()->sputbackc (c);
          break;
        }
      }
      ...
   }

  _________________________
  17) The call tie()->flush() does not necessarily occur if the function
  can determine that no synchronization is necessary.
  18) The functions ipfx(int) and isfx() can also perform additional im­
  plementation-dependent operations.

3 In  case  we use ios_traits<char> or ios_traits<wchar_t>, the behavior
  of  the  constraint  function  traits::is_whitespace()  is  as  if  it
  invokes:
     ctype<charT>& ctype = getloc().use<ctype<charT> >();
     ctype.is(ctype<charT>::SPACE, c);
  otherwise,  the  behavior  of  the function traits::is_whitespace() is
  unspecified.

4 Those who want to  use  locale-independent  whitespace  predicate  can
  specify  their  definition of is_whitespace in their new ios_traits as
  follows:
  struct my_traits : public ios_traits<char> {
      typedef my_char_traits char_traits;
  };
  struct my_char_traits : public ios_traits<char> {
      static bool is_whitespace (char c, const ctype<charT>& ctype) {
      ....(my own implementation)...
      }
  };

  27.6.1.3.2  basic_istream::isfx                    [lib.istream::isfx]

  void isfx();

  Effects:

  +-------                BEGIN BOX 14                -------+
  TBS
  +-------                 END BOX 14                 -------+

  27.6.1.3.3  basic_istream::sync                    [lib.istream::sync]

  int sync();

  Effects:
    If rdbuf() is a  null  pointer,  returns  eof().   Otherwise,  calls
    rdbuf()->pubsync()  and,  if that function returns eof(), calls set­
    state(badbit) and returns eof().  Otherwise, returns zero.

  27.6.1.4  Formatted input functions            [lib.istream.formatted]

  27.6.1.4.1  Common requirements         [lib.istream.formatted.reqmts]

1 Each formatted input function begins execution by calling ipfx().   If
  that  function  returns  true,  the  function  endeavors to obtain the
  requested input.  In any case, the formatted input  function  ends  by
  calling isfx(), then returns *this

2 Some  formatted input functions endeavor to obtain the requested input
  by parsing characters extracted from the  input  sequence,  converting
  the  result  to a value of some scalar data type, and storing the con­
  verted value in an object of that scalar data type.

3 The numeric conversion  behaviors  of  the  following  extractors  are
  locale-dependent.

  operator>>(short& val);
  operator>>(unsigned short& val);
  operator>>(int& val);
  operator>>(unsigned int& val);
  operator>>(long& val);
  operator>>(unsigned long& val);
  operator>>(float& val);
  operator>>(double& val);
  operator>>(long double& val);

  As  in  the  case  of  the  inserters,  these extractors depend on the
  locale's num_get<> (_lib.locale.num.get_) object  to  perform  parsing
  the  input  stream data.  The conversion occurs as if it performed the
  following code fragment:
    HOLDTYPE tmp;
    num_get<charT>& fmt = loc.use< num_get<charT> >();
    fmt.get (iter, *this, loc, tmp);
    if ((val = (TYPE)tmp) != tmp)
    // set fail bit...
  In the above fragment, loc  stands  for  the  private  member  of  the
  basic_ios  class,  TYPE  stands  for  the  type of the argument of the
  extractor, and HOLDTYPE is as follows;

  --for short, int and long, HOLDTYPE is long;

  --for unsigned short, unsigned int  and  unsigned  long,  HOLDTYPE  is
    unsigned long.

  --for float, double, HOLDTYPE is double.

  --for long double, HOLDTYPE is long double.

4 The  first  argument  provides an object of the istream_iterator class
  which is an iterator pointed to an input stream.  It bypasses istreams
  and uses streambufs directly.  Class locale relies on this type as its
  interface to istream, since the flexibility  it  has  been  abstracted
  away from direct dependence on istream.

5 In  case the converting result is a value of either an integral type (
  short, unsigned short, int, unsigned int, long, unsigned  long)  or  a
  float type ( float, double, long double), performing to parse and con­
  vert the result depend on the imbued locale object.  So  the  behavior
  of  the above type extractors are locale-dependent.  The imbued locale
  object uses an  istreambuf_iterator  to  access  the  input  character
  sequence.

6 The behavior of such functions is described in terms of the conversion
  specification  for  an  equivalent  call  to  the function fscanf()19)
  _________________________
  19) The signature fscanf(FILE*, const  char*,  ...)   is  declared  in

  operating with the global locale set to getloc(), with  the  following
  alterations:

  --The  formatted  input  function  extracts  characters  from a stream
    buffer, rather than reading them from an input file.20)

  --If  flags() & skipws is zero, the function does not skip any leading
    white space.  In that case, if the next  input  character  is  white
    space, the scan fails.

  --If  the converted data value cannot be represented as a value of the
    specified scalar data type, a scan failure occurs.

  +-------                BEGIN BOX 15                -------+
  Can the current num_put/num_get facet handle basefield  specification?
  Needs more discussion.
  +-------                 END BOX 15                 -------+

7 If  the  scan fails for any reason, the formatted input function calls
  setstate(failbit).

8 For conversion to an integral type other than a  character  type,  the
  function  determines the integral conversion specifier as indicated in
  Table 9:

                       Table 9--Integer conversions

            +------------------------------------------------+
            |           State               stdio equivalent |
            +------------------------------------------------+
            |(flags() & basefield) == oct          %o        |
            +------------------------------------------------+
            |(flags() & basefield) == hex          %x        |
            |(flags() & uppercase) != 0            %X        |
            +------------------------------------------------+
            |(flags() & basefield) == 0            %i        |
            +------------------------------------------------+
            |Otherwise,                                      |
            +------------------------------------------------+
            |signed integral type                  %d        |
            +------------------------------------------------+
            |unsigned integral type                %u        |
            +------------------------------------------------+

  +-------                BEGIN BOX 16                -------+
  _________________________
  <cstdio> (_lib.c.files_)
  20) The stream buffer can, of course,  be  associated  with  an  input
  file, but it need not be.

  Is this table clear with regards to %x vs.  %X?
  +-------                 END BOX 16                 -------+

  27.6.1.4.2  basic_istream::operator>>        [lib.istream::extractors]

  istream_type& operator>>(istream_type& (*pf)(istream_type&))

  Returns:
    pf(*this).21)

    istream_type& operator>>(ios_type& (*pf)(ios_type&))

  Effects:
    Calls pf(*this), then returns *this.22)

    istream_type& operator>>(char_type* s);

  Effects:
    Extracts characters and stores them into successive locations of  an
    array whose first element is  designated  by  s.23)  If  width()  is
    greater  than  zero,  the  maximum  number of characters stored n is
    width(); otherwise it is numeric_limits<int>::max()  (_lib.limits_).

1 Characters are extracted and stored until any of the following occurs:

  --n  - 1 characters are stored;

  --end-of-file occurs on the input sequence;

  --traits::is_whitespace(c,ctype) is nonzero  for  the  next  available
    input  character  c.  In the above code fragment, the argument ctype
    is acquired by getloc().use<ctype<charT> >().

2 If the function stores no characters, it calls setstate(failbit).   In
  any  case,  it  then  stores a null character into the next successive
  location of the array and calls width(0).
  Returns:
    *this.

    istream_type& operator>>(char_type& c);

  Effects:
    Extracts a character, if one is available, and stores it in c.  Oth­
    erwise, the function calls setstate(failbit).
  _________________________
  21)  See,  for  example,  the  function  signature  ws(basic_istream&)
  (_lib.basic.istream.manip_).
  22)      See,      for     example,     the     function     signature
  dec(basic_ios<charT,traits>&) (_lib.basefiled.manip_).
  23) Note that this function is not overloaded on types signed char and
  unsigned char.

  Returns:
    *this.

    istream_type& operator>>(bool& n);

  Effects:
    Converts  a signed short integer, if one is available, and stores it
    in x.
  Returns:
    *this.
  Notes:
    Behaves as if:
        if (flags() & ios::boolalpha) {
          getloc().extract(*this, n);
        } else {
          int x;
          *this >> x;
          if (x == 0)
            n = false;
          else if (x == 1)
            n = true;
          else
            ; // indicate failure
        }
        return *this;

3 Locale extraction ( getloc().extract()) of  the  string  is  something
  like:
    istream i;
    string bool_false = ...; // locale dependent
    string bool_true  = ...;
    string s;
    i >> s;
    if (s == bool_false)
      n = false;
    else if (s == bool_true)
      n = true;
    else
      ; // indicate failure

4 The strings for the default locale are false and true.

  istream_type& operator>>(short& n);

  Effects:
    Converts  a signed short integer, if one is available, and stores it
    in n.
  Returns:
    *this.

    istream_type& operator>>(unsigned short& n);

  Effects:
    Converts an unsigned short integer, if one is available, and  stores
    it in n.
  Returns:
    *this.

    istream_type& operator>>(int& n);

  Effects:
    Converts  a signed integer, if one is available, and stores it in n.
  Returns:
    *this.

    istream_type& operator>>(unsigned int& n);

  Effects:
    Converts an unsigned integer, if one is available, and stores it  in
    n.
  Returns:
    *this.

    istream_type& operator>>(long& n);

  Effects:
    Converts  a  signed long integer, if one is available, and stores it
    in n.
  Returns:
    *this.

    istream_type& operator>>(unsigned long& n);

  Effects:
    Converts an unsigned long integer, if one is available,  and  stores
    it in n.
  Returns:
    *this.

    istream_type& operator>>(float& f);

  Effects:
    Converts a float, if one is available, and stores it in f.
  Returns:
    *this.

    istream_type& operator>>(double& f);

  Effects:
    Converts a double, if one is available, and stores it in f.
  Returns:
    *this.

    istream_type& operator>>(long double& f);

  Effects:
    Converts a long double, if one is available, and stores it in f.
  Returns:
    *this.

    istream_type& operator>>(void*& p);

  Effects:
    Converts a pointer to void, if one is available, and stores it in p.
  Returns:
    *this.

    istream_type& operator>>(basic_streambuf<charT,traits>& sb);

  Effects:
    Extracts characters from  *this  and  inserts  them  in  the  output
    sequence  controlled  by  rdbuf().   Characters  are  extracted  and
    inserted until any of the following occurs:

  --end-of-file occurs on the input sequence;

  --inserting in the output sequence fails (in which case the  character
    to be inserted is not extracted);

  --an  exception  occurs (in which case the exception is caught).  set­
    state(badbit) is not called

5 If the function inserts no characters, it calls setstate(failbit).  If
  failure was due to catching an exception thrown while extracting char­
  acters   from   rdbuf()   and   failbit   is   on   in    exceptions()
  (_lib.ios::exceptions_), then the caught exception is rethrown.
  Returns:
    *this.

  27.6.1.5  Unformatted input functions        [lib.istream.unformatted]

1 Each  unformatted  input function begins execution by calling ipfx(1).
  If that function returns nonzero, the function  endeavors  to  extract
  the  requested  input.   It  also  counts  the  number  of  characters
  extracted.  In any case, the unformatted input function ends by  stor­
  ing  the  count  in a member object and calling isfx(), then returning
  the value specified for the unformatted input function.

  27.6.1.5.1  basic_istream::get                      [lib.istream::get]

  int get();

  Effects:
    Extracts a character c, if one  is  available.   The  function  then
    returns  (unsigned  char)c.   Otherwise,  the  function  calls  set­
    state(failbit) and then returns eof().

    istream_type& get(char_type*  s, streamsize n,
                      char_type delim = newline());

  Effects:
    Extracts characters and stores them into successive locations of  an
    array whose first element is  designated  by  s.24)  Characters  are
    extracted and stored until any of the following occurs:

  --n - 1 characters are stored;

  --end-of-file occurs on the input sequence (in which case the function
    calls setstate(eofbit));

  --c == delim for the next available input character c (in which case c
    is not extracted).

1 If  the function stores no characters, it calls setstate(failbit).  In
  any case, it then stores a null character  into  the  next  successive
  location of the array.
  Returns:
    *this.

    istream_type& get(char_type& c);

  Effects:
    Extracts a character, if one is available, and assigns it  to  c.25)
    Otherwise, the function calls setstate(failbit).
  Returns:
    *this.

    istream_type& get(basic_streambuf<char_type,traits>& sb,
                      char_type delim = newline());

  Effects:
    Extracts  characters  and  inserts  them in the output sequence con­
    trolled by rdbuf().  Characters are extracted and inserted until any
    of the following occurs:

  --end-of-file occurs on the input sequence;

  --inserting  in the output sequence fails (in which case the character
    to be inserted is not extracted);

  --c == delim for the next available input character c (in which case c
    is not extracted);

  --an  exception occurs (in which case, the exception is caught but not
  _________________________
  24) Note that this function is not overloaded on types signed char and
  unsigned char.
  25)  Note that this function is not overloaded on types signed charand
  unsigned char.

    rethrown).

2 If the function inserts no characters, it calls setstate(failbit).
  Returns:
    *this.

  27.6.1.5.2  basic_istream::getline              [lib.istream::getline]

  istream_type& getline(char_type* s, streamsize n,
                        char_type delim = newline());

  Effects:
    Extracts characters and stores them into successive locations of  an
    array whose first element is  designated  by  s.26)  Characters  are
    extracted and stored until one of the following occurs:

  1)end-of-file occurs on the input sequence (in which case the function
    calls setstate(eofbit));

  2)c == delim for the next available input character c (in  which  case
    the input character is extracted but not stored);27)

  3)n - 1 characters are stored (in which case the function  calls  set­
    state(failbit)).

1 These conditions are tested in the order shown.28)

2 If the function extracts no characters, it calls setstate(failbit).29)

3 In  any case, it then stores a null character into the next successive
  location of the array.
  Returns:
    *this.

4 Example:

  _________________________
  26) Note that this function is not overloaded on types signed char and
  unsigned char.
  27) Since the final input character is ``extracted,'' it is counted in
  the gcount(), even though it is not stored.
  28)  This allows an input line which exactly fills the buffer, without
  setting failbit.  This is different behavior than the historical  AT&T
  implementation.
  29) This implies an empty input line will not cause failbit to be set.

    #include <iostream>
    using namespace std;
    const int line_buffer_size = 100;
    int main()
    {
      char buffer[line_buffer_size];
      int line_number = 0;
      while (cin.getline(buffer, line_buffer_size) || cin.gcount()) {
        int count = cin.gcount();
        if (cin.eof())
          cout << "Partial final line";   // cin.fail() is false
        else if (cin.fail()) {
          cout << "Partial long line";
          cin.clear(cin.rdstate() & ~ios::failbit);
        } else {
          count--;        // Don't include '\n' in count
          cout << "Line " << ++line_number;
        }
        cout << " (" << count << " chars): " << buffer << endl;
      }
    }

  27.6.1.5.3  basic_istream::ignore                [lib.istream::ignore]

  istream_type& ignore(int n = 1, int_type delim = eof());

  Effects:
    Extracts characters and discards  them.   Characters  are  extracted
    until any of the following occurs:

  --if n  != numeric_limits<int>::max() (_lib.limits_), n characters are
    extracted

  --end-of-file occurs on the input sequence (in which case the function
    calls setstate(eofbit));

  --c == delim for the next available input character c (in which case c
    is extracted).

1 The last condition will never occur if delim  == eof().
  Returns:
    *this.

  27.6.1.5.4  basic_istream::read                    [lib.istream::read]

  istream_type& read(char_type* s, streamsize n);

  Effects:
    Extracts characters and stores them into successive locations of  an
    array whose first element is  designated  by  s.30)  Characters  are
  _________________________
  30) Note that this function is not overloaded on types signed char and
  unsigned char.

    extracted and stored until either of the following occurs:

  --n characters are stored;

  --end-of-file occurs on the input sequence (in which case the function
    calls setstate(failbit)).
  Returns:
    *this.

  27.6.1.5.5  basic_istream::readsome            [lib.istream::readsome]

  int readsome(char_type* s, int n);

  Effects:
    Extracts characters and stores them into successive locations of  an
    array  whose  first  element is designated by s.  The function first
    determines navail, the value returned  by  calling  in_avail().   If
    navail is 1, the function calls setstate(eofbit) and returns zero.

1 Otherwise, the function determines the number of characters to extract
  m as the smaller of n and navail, and returns read(s, m).

  27.6.1.5.6  basic_istream::peek                    [lib.istream::peek]

  int peek();

  Returns:
    eof() if good() is false.  Otherwise, returns rdbuf()->sgetc().

  27.6.1.5.7  basic_istream::putback              [lib.istream::putback]

  istream_type& putback(char_type c);

  Effects:
    Calls rdbuf->sputbackc(c).  If that function  returns  eof(),  calls
    setstate(badbit).
  Returns:
    *this.

  27.6.1.5.8  basic_istream::unget                  [lib.istream::unget]

  istream_type& unget();

  Effects:
    Calls  rdbuf->sungetc().  If that function returns eof(), calls set­
    state(badbit).
  Returns:
    *this.

  27.6.1.5.9  basic_istream::gcount                [lib.istream::gcount]

  streamsize gcount() const;

  Returns:
    The number of characters extracted by  the  last  unformatted  input
    member function called for the object.

  27.6.1.6  Standard basic_istream             [lib.basic.istream.manip]
       manipulators

  namespace std {
    template<class charT, class traits>
      basic_istream<charT,traits>& ws(basic_istream<charT,traits>& is);
  }

  Effects:
    Saves a copy of is.fmtflags, then clears is .skipws in is  .flags().
    Then  calls  is  .ipfx() and is .isfx(), and restores is .flags() to
    its saved value.31)
  Returns:
    is.

  27.6.2  Output streams                            [lib.output.streams]

1 The  header  <ostream>  defines a type and several function signatures
  that control output to a stream buffer.

  27.6.2.1  Template class basic_ostream                   [lib.ostream]
  namespace std {
    template <class charT, class traits = ioc_traits<charT> >
    class basic_ostream : virtual public basic_ios<charT,traits> {
    public:
      typedef charT            char_type;
      typedef traits::int_type int_type;
      typedef traits::pos_type pos_type;
      typedef traits::off_type off_type;
      int_type  eof()     { return traits::eof(); }
      char_type newline() { return traits::newline(); }
    private:
      typedef basic_ostream<charT,traits> ostream_type;
    public:
      basic_ostream(basic_streambuf<char_type,traits>* sb);
      virtual ~basic_ostream();
      bool opfx();
      void osfx();

  _________________________
  31) The effect of cin >> ws is to skip any white space  in  the  input
  sequence controlled by cin.

      ostream_type& operator<<(ostream_type& (*pf)(ostream_type&));
      ostream_type& operator<<(ios_type& (*pf)(ios_type&));
      ostream_type& operator<<(const char_type* s);
      ostream_type& operator<<(char_type c);
      ostream_type& operator<<(bool n);
      ostream_type& operator<<(short n);
      ostream_type& operator<<(unsigned short n);
      ostream_type& operator<<(int n);
      ostream_type& operator<<(unsigned int n);
      ostream_type& operator<<(long n);
      ostream_type& operator<<(unsigned long n);
      ostream_type& operator<<(float f);
      ostream_type& operator<<(double f);
      ostream_type& operator<<(long double f);
      ostream_type& operator<<(void* p);
      ostream_type& operator<<(basic_streambuf<char_type,traits>& sb);
      int put(char_type c);
      ostream_type& write(const char_type* s, streamsize n);
      ostream_type& flush();
    };
  }

1 The class basic_ostream defines a number of member function signatures
  that  assist in formatting and writing output to output sequences con­
  trolled by a stream buffer.

2 Two groups of member function signatures share common properties:  the
  formatted  output  functions (or inserters) and the unformatted output
  functions.  Both groups of output functions generate (or insert)  out­
  put  characters  by  actions equivalent to calling rdbuf().sputc(int).
  They may use other public members of basic_ostream except that they do
  not  invoke  any  tuals  members  of  rdbuf() except overflow.  If the
  called function throws an exception, the output  function  calls  set­
  state(badbit)  and if badbit is on in exceptions() rethrows the excep­
  tion.

  27.6.2.2  basic_ostream constructors       [lib.basic.ostream.sb.cons]

  basic_ostream(basic_streambuf<charT,traits>* sb);

  Effects:
    Constructs an object of class basic_ostream, assigning initial  val­
    ues  to the base class by calling basic_ios<charT,traits>::init(sb).

    virtual ~basic_ostream();

  Effects:
    Destroys an object of class basic_ostream.
  Notes:
    Does not perform any operations on rdbuf().

  27.6.2.3  Member functions                 [lib.basic.ostream.members]

  27.6.2.3.1  basic_ostream::opfx                    [lib.ostream::opfx]

  bool opfx();

1 If good() is nonzero, prepares for formatted  or  unformatted  output.
  If tie() is not a null pointer, calls tie()->flush().32)

  +-------                BEGIN BOX 17                -------+
  Note: Need to append the locale dependency on appropriate  extractors.
  +-------                 END BOX 17                 -------+

  Returns:
    good().33)

  27.6.2.3.2  basic_ostream::osfx                    [lib.ostream::osfx]

  void osfx();

1 If flags() & unitbuf is nonzero, calls flush().

  27.6.2.3.3  basic_ostream::flush                  [lib.ostream::flush]

  basic_ostream& flush();

1 If rdbuf() is not a null pointer, calls rdbuf()->pubsync().   If  that
  function returns eof(), calls setstate(badbit).
  Returns:
    *this.

  27.6.2.4  Formatted output functions           [lib.ostream.formatted]

  27.6.2.4.1  Common requirements         [lib.ostream.formatted.reqmts]

1 Each formatted output function begins execution by calling opfx().  If
  that function returns nonzero, the function endeavors to generate  the
  requested  output.  In any case, the formatted output function ends by
  calling osfx(), then returning the value specified for  the  formatted
  output function.

2 The  numeric  conversion  behaviors  of  the  following  inserters are
  locale-dependent:

  _________________________
  32) The call tie()->flush() does not necessarily occur if the function
  can determine that no synchronization is necessary.
  33)  The  function signatures opfx() and osfx() can also perform addi­
  tional implementation-dependent operations.

    operator<<(short val);
    operator<<(unsigned short val);
    operator<<(int val);
    operator<<(unsigned int val);
    operator<<(long val);
    operator<<(unsigned long val);
    operator<<(float val);
    operator<<(double val);
    operator<<(long double val);

3 The classes num_get<> and num_put<>  handle  locale-dependent  numeric
  formatting  and  parsing.   The  above  inserter  functions refers the
  imbued locale value to utilize these numeric formatting functionality.
  The formatting conversion occurs as if it performed the following code
  fragment:
    num_put<charT>& fmt = loc.use< num_put<charT> >();
    fmt.put (ostreambuf_iterator(*this), *this, loc, val);
  In the above fragment, loc  stands  for  the  private  member  of  the
  basic_ios  class  which  maintains the imbued localeobject.  The first
  argument provides an object of the ostreambuf_iterator class which  is
  an  iterator for ostream class.  It bypasses ostreams and uses stream­
  bufs directly.  Class locale relies on these types as its interface to
  iostreams,  since  for  flexibility  it  has been abstracted away from
  direct dependence on ostream.
  +-------                 END BOX 17                 -------+

4 Some formatted output functions endeavor  to  generate  the  requested
  output  by  converting  a  value from some scalar or NTBS type to text
  form and inserting the converted text in the output sequence.

  +-------                BEGIN BOX 18                -------+
  Needs work:  NTBS.
  +-------                 END BOX 18                 -------+

  The behavior of such functions is described in terms of the conversion
  specification for an equivalent call to the function fprintf,34) oper­
  ating  with  the  global  locale  set  to getloc(), with the following
  alterations:

  --The formatted output function inserts characters in a stream buffer,
    rather than writing them to an output file.35)

  --The formatted output function uses the fill  character  returned  by
    fill() as the padding character (rather than the space character for
    left or right padding, or 0 for internal padding).

  _________________________
  34)  The  signature fprintf(FILE*, const char_type*, ...)  is declared
  in <cstdio> (_lib.c.files_).
  35)  The  stream  buffer  can, of course, be associated with an output
  file, but it need not be.

5 If the operation fails for any reason, the formatted  output  function
  calls setstate(badbit).

6 For  conversion from an integral type other than a character type, the
  function determines the integral conversion specifier as indicated  in
  Table 10:

                      Table 10--Integer conversions

            +------------------------------------------------+
            |           State               stdio equivalent |
            +------------------------------------------------+
            |(flags() & basefield) == oct          %o        |
            +------------------------------------------------+
            |(flags() & basefield) == hex          %x        |
            |(flags() & uppercase) != 0            %X        |
            +------------------------------------------------+
            |Otherwise,                                      |
            +------------------------------------------------+
            |signed integral type                  %d        |
            +------------------------------------------------+
            |unsigned integral type                %u        |
            +------------------------------------------------+

  +-------                BEGIN BOX 19                -------+
  Is this table clear with regards to %x vs.  %X?
  +-------                 END BOX 19                 -------+

7 For conversion from a floating-point type, the function determines the
  floating-point conversion specifier as indicated in Table 11:

  +-------                BEGIN BOX 20                -------+
  Can the current num_put/num_get facet handle basefield  specification?
  Needs more discussion.
  +-------                 END BOX 20                 -------+

                   Table 11--Floating-point conversions

        +--------------------------------------------------------+
        |               State                   stdio equivalent |
        +--------------------------------------------------------+
        |(flags() & floatfield) == fixed               %f        |
        +--------------------------------------------------------+
        |(flags() & floatfield) == scientific          %e        |
        |(flags() & uppercase) != 0                    %E        |
        +--------------------------------------------------------+
        |Otherwise,                                              |
        +--------------------------------------------------------+
        |                                              %g        |
        |(flags() & uppercase) != 0                    %G        |
        +--------------------------------------------------------+

  +-------                BEGIN BOX 21                -------+
  Is this table clear with regards to %e vs.  %E?
  +-------                 END BOX 21                 -------+

8 The  conversion  specifier  has  the  following  additional qualifiers
  prepended as indicated in Table 12:

                   Table 12--Floating-point conversions

  +----------------------------------------------------------------------+
  |       Type(s)                    State              stdio equivalent |
  +----------------------------------------------------------------------+
  |an integral type oth­   (flags() & showpos)   != 0          +         |
  |er than a character     (flags() & showbase)  != 0          #         |
  |type                                                                  |
  +----------------------------------------------------------------------+
  |a floating-point type   (flags() & showpos)   != 0          +         |
  |                        (flags() & showpoint) != 0          #         |
  +----------------------------------------------------------------------+

  --For any conversion, if width() is nonzero, then  a  field  width  is
    specified in the conversion specification.  The value is width().

  --For  conversion  from  a  floating-point type, if flags() & fixed is
    nonzero or if precision() is greater than zero, then a precision  is
    specified  in  the  conversion  specification.   The value is preci­
    sion().

9 Moreover, for any conversion, padding with the fill character returned
  by fill() behaves as follows:

  --If  (flags()  &  adjustfield)  == right, no flag is prepended to the
    conversion  specification,  indicating  right   justification   (any
    padding  occurs before the converted text).  A fill character occurs
    wherever fprintf generates a space character as padding.

  --If (flags() & adjustfield) == internal, the flag 0 is  prepended  to
    the conversion specification, indicating internal justification (any
    padding occurs within the converted text).  A fill character  occurs
    wherever fprintf generates a 0 as padding.36)

10Otherwise, the flag - is prepended to  the  conversion  specification,
  indicating  left justification (any padding occurs after the converted
  text).  A fill character occurs wherever fprintf()  would  generate  a
  space character as padding.

11Unless  explicitly  stated  otherwise  for a particular inserter, each
  formatted output function calls width(0) after determining  the  field
  width.

  27.6.2.4.2  basic_ostream::operator<<          [lib.ostream.inserters]

  ostream_type& operator<<(ostream_type& (*pf)(ostream_type&))

  Returns:
    pf(*this).37)

    ostream_type& operator<<(ios_type& (*pf)(ios_type&))

  Effects:
    Calls (*(basic_ios<charT,traits>*)pf)(*this).
  Returns:
    *this.38)

    ostream_type& operator<<(const char_type* s);

  Effects:
    Converts the NTBS s with the conversion specifier s.
  Returns:
    *this.

    ostream_type& operator<<(char_type c);

  Effects:
    Converts the char_type c with the conversion specifier c and a field
    width     of     zero.39)     The     stored     field    width    (
  _________________________
  36) The conversion specification #o generates a leading 0 which is not
  a padding character.
  37)  See,  for  example,  the  function signature endl(basic_ostream&)
  (_lib.basic.ostream.manip_) .
  38)  See,  for  example,   the   function   signature   dec(ios_base&)
  (_lib.basefield.manip_).
  39) Note that this function is not overloaded on types signed char and

    basic_ios<charT,traits>::width()) is not set to zero.
  Returns:
    *this.

    ostream_type& operator<<(bool n);

1 Behaves as if:
    {
      if (flags() & ios::boolalpha) {
        getloc().insert(*this, n);
      } else {
        *this << int(n);
      }
    }
  Returns:
    *this.

    ostream_type& operator<<(short n);

  Effects:
    Converts the signed short integer n  with  the  integral  conversion
    specifier preceded by h.
  Returns:
    *this.

    ostream_type& operator<<(unsigned short n);

  Effects:
    Converts  the  unsigned short integer n with the integral conversion
    specifier preceded by h.
  Returns:
    *this.

    ostream_type& operator<<(int n);

  Effects:
    Converts the signed integer n with the  integral  conversion  speci­
    fier.
  Returns:
    *this.

    ostream_type& operator<<(unsigned int n);

  Effects:
    Converts  the unsigned integer n with the integral conversion speci­
    fier.
  Returns:
    *this.

  _________________________
  unsigned char.

    ostream_type& operator<<(long n);

  Effects:
    Converts the signed long integer  n  with  the  integral  conversion
    specifier preceded by l.
  Returns:
    *this.

    ostream_type& operator<<(unsigned long n);

  Effects:
    Converts  the  unsigned  long integer n with the integral conversion
    specifier preceded by l.
  Returns:
    *this.

    ostream_type& operator<<(float f);

  Effects:
    Converts the float f with the floating-point conversion specifier.
  Returns:
    *this.

    ostream_type& operator<<(double f);

  Effects:
    Converts the double f with the floating-point conversion  specifier.
  Returns:
    *this.

    ostream_type& operator<<(long double f);

  Effects:
    Converts the long double f with the floating-point conversion speci­
    fier preceded by L.
  Returns:
    *this.

    ostream_type& operator<<(void* p);

  Effects:
    Converts the pointer to void p with the conversion specifier p.
  Returns:
    *this.

    ostream_type& operator<<(basic_streambuf<charT,traits>& sb);

2 Gets characters from rdbuf() and inserts them  in  *this.   Characters
  are read from rdbuf() and inserted until any of the following occurs:

  --end-of-file occurs on the input sequence;

  --inserting  in the output sequence fails (in which case the character
    to be inserted is not extracted); LI an exception occurs while  get­
    ting  a  character  from  rdbuf()  (in  which case, the exception is
    rethrown).

3 If the function inserts no characters or  if  it  stopped  because  an
  exception  was  thrown  while  extracting  a  character, it calls set­
  state(failbit).  If an exception was thrown while extracting a charac­
  ter  and  failbit  is  on  in  exceptions()  the  caught  exception is
  rethrown.
  Returns:
    *this.

  27.6.2.5  Unformatted output functions       [lib.ostream.unformatted]

1 Each unformatted output function begins execution by  calling  opfx().
  If  that  function returns nonzero, the function endeavors to generate
  the requested output.  In any case, the  unformatted  output  function
  ends  by  calling  osfx(),  then returning the value specified for the
  unformatted output function.

  27.6.2.5.1  basic_ostream::put                      [lib.ostream::put]

  int put(char_type c);

  Effects:
    Inserts  the  character  c,  if  possible.40) Then returns (unsigned
    char)c.

1 Otherwise, calls setstate(badbit) and returns eof().

  27.6.2.5.2  basic_ostream::write                  [lib.ostream::write]

  basic_ostream& write(const char_type* s, streamsize n);

  Effects:
    Obtains characters to insert from successive locations of  an  array
    whose first element is designated by s.41) Characters  are  inserted
    until either of the following occurs:

  --n characters are inserted;

  --inserting  in  the output sequence fails (in which case the function
    calls setstate(badbit)).
  Returns:
    *this.

  _________________________
  40) Note that this function is not overloaded on types signed char and
  unsigned char.
  41) Note that this function is not overloaded on types signed char and
  unsigned char.

  27.6.2.6  Standard basic_ostream             [lib.basic.ostream.manip]
       manipulators

  27.6.2.6.1  endl                                            [lib.endl]

  namespace std {
    template<class charT, class traits>
      basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);
  }

  Effects:
    Calls os .put(traits::newline()), then os .flush().
  Returns:
    os.42)

  27.6.2.6.2  ends                                            [lib.ends]

  namespce std {
    template<class charT, class traits>
      basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);
  }

  Effects:
    Calls os .put(traits::eos()).
  Returns:
    os.43)

  27.6.2.6.3  flush                                          [lib.flush]

  namespace std {
    template<class charT, class traits>
      basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);
  }

  Effects:
    Calls os .flush().
  Returns:
    os.

  27.6.3  Standard manipulators                          [lib.std.manip]

  _________________________
  42)  The effect of executing cout << endl is to insert a newline char­
  acter in the output sequence controlled by cout, then  synchronize  it
  with any external file with which it might be associated.
  43)  The effect of executing ostr  << ends is to insert a null charac­
  ter in the output sequence controlled by ostr.  If ostr is  an  object
  of  class basic_strstreambuf, the null character can terminate an NTBS
  constructed in an array object.

  27.6.3.1  Type smanip                                     [lib.smanip]

1 The type smanip is an implementation-defined function type (_dcl.fct_)
  returned by the standard manipulators.

  27.6.3.2  resetiosflags                            [lib.resetiosflags]

  smanip resetiosflags(ios_base::fmtflags mask);

  Returns:
    smanip(f, mask), where f can be defined as:44)
        template<class charT, class traits>
          ios_base& f(ios_base& str,
                            ios_base::fmtflags mask)
          { // reset specified flags
            str.setf(ios_base::fmtflags(0), mask);
            return str;
          }

  27.6.3.3  setiosflags                                [lib.setiosflags]

  smanip setiosflags(ios_base::fmtflags mask);

  Returns:
    smanip(f,mask), where f can be defined as:
          ios_base& f(ios_base& str,
                            ios_base::fmtflags mask)
          { // set specified flags
            str.setf(mask);
            return str;
          }

  27.6.3.4  setbase                                        [lib.setbase]

  smanip setbase(int base);

  Returns:
    smanip(f, base), where f can be defined as:

  _________________________
  44)  The  expression  cin  >>  resetiosflags(ios_base::skipws)  clears
  ios_base::skipws in the format flags stored in the istream object  cin
  (the  same  as  cin >> noskipws), and the expression cout << resetios­
  flags(ios_base::showbase)  clears  ios_base::showbase  in  the  format
  flags  stored  in the ostream object cout (the same as cout << noshow­
  base).

          ios_base& f(ios_base& str, int base)
          { // set basefield
            str.setf(n ==  8 ? ios_base::oct :
                                     n == 10 ? ios_base::dec :
                                     n == 16 ? ios_base::hex :
                                     ios_base::fmtflags(0),
                                     ios_base::basefield);
            return str;
          }

  27.6.3.5  setfill                                        [lib.setfill]

  smanip setfill(int c);

  Returns:
    smanip(f, c), where f can be defined as:
          ios_base& f(ios_base& str, int c)
          { // set fill character
            str.fill(c);
            return str;
          }

  27.6.3.6  setprecision                              [lib.setprecision]

  smanip setprecision(int n);

  Returns:
    smanip(f, n), where f can be defined as:
          ios_base& f(ios_base& str, int n)
          { // set precision
            str.precision(n);
            return str;
          }

  27.6.3.7  setw                                              [lib.setw]

  smanip setw(int n);

  Returns:
    smanip(f, n), where f can be defined as:
          ios_base& f(ios_base& str, int n)
          { // set width
            str.width(n);
            return str;
          }

  27.7  String-based streams                        [lib.string.streams]

  Header <sstream> synopsis

  #include <streambuf>
  #include <istream>
  #include <ostream>

  namespace std {
    template <class charT, class traits = int_charT_traits<charT> >
      class basic_stringbuf;
    typedef basic_stringbuf<char>     stringbuf;
    typedef basic_stringbuf<wchar_t> wstringbuf;

    template <class charT, class traits = ios_traits<charT> >
      class basic_istringstream;
    typedef basic_istringstream<char>     istringstream;
    typedef basic_istringstream<wchar_t> wistringstream;

    template <class charT, class traits = ios_traits<charT> >
      class basic_ostringstream;
    typedef basic_ostringstream<char>     ostringstream;
    typedef basic_ostringstream<wchar_t> wostringstream;
  }

                   Table 12--Header <cstdlib> synopsis

                          +---------------------+
                          |Type      Name(s)    |
                          +---------------------+
                          |Functions:           |
                          |       atoi   strtod |
                          |       atol   strtol |
                          +---------------------+

1
  SEE ALSO: ISO C subclause 7.10.1.

2 The header <sstream> defines three types that associate stream buffers
  with objects of class string, as described in clause _lib.string_.

  27.7.1  Template class basic_stringbuf                 [lib.stringbuf]
  namespace std {
    template <class charT, class traits = int_charT_traits<charT> >
    class basic_stringbuf : public basic_streambuf<charT,traits> {
    public:
      typedef charT            char_type;
      typedef traits::int_type int_type;
      typedef traits::pos_type pos_type;
      typedef traits::off_type off_type;
      int_type  eof()     { return traits::eof(); }
      char_type newline() { return traits::newline(); }

    public:
      basic_stringbuf(ios_base::openmode which
                          = ios_base::in
                          | ios_base::out);
      basic_stringbuf(const basic_string<char_type>& str,
                      ios_base::openmode which
                          = ios_base::in
                          | ios_base::out);
      virtual ~basic_stringbuf();
      basic_string<char_type> str() const;
      void str(const basic_string<char_type>& s);
    protected:
  //  virtual int_type   overflow (int_type c = eof());   inherited
  //  virtual int_type   pbackfail(int_type c = eof());   inherited
  //  virtual int        showmany();      inherited
  //  virtual int_type   underflow();     inherited
  //  virtual int_type   uflow();         inherited
  //  virtual streamsize xsgetn(char_type* s, streamsize n);      inherited
  //  virtual streamsize xsputn(const char_type* s, streamsize n);        inherited
  //  virtual pos_type   seekoff(off_type off,
  //                             ios_base::seekdir way,
  //                             ios_base::openmode which
  //                               = ios_base::in
  //                               | ios_base::out);      inherited
  //  virtual pos_type   seekpos(pos_type sp,
  //                             ios_base::openmode which
  //                               = ios_base::in
  //                               | ios_base::out);      inherited
  //  virtual basic_streambuf<char_type,traits>*
  //                     setbuf(char_type* s, streamsize n);      inherited
  //  virtual int sync();         inherited
    private:
  //  ios_base::openmode mode;    exposition only
    };
  }

  +-------                BEGIN BOX 22                -------+
  Note: same charT type string can be fed.
  +-------                 END BOX 22                 -------+

1 The class basic_stringbuf is derived from basic_streambuf to associate
  possibly the input sequence and possibly the output  sequence  with  a
  sequence  of  arbitrary  characters.   The sequence can be initialized
  from, or made available as, an object of class basic_string.

  +-------                BEGIN BOX 23                -------+
  For the sake of exposition, the maintained data is presented here as:

  --ios_base::openmode mode, has in set if the  input  sequence  can  be
    read, and out set if the output sequence can be written.

2 For the sake of exposition, the stored character sequence is described
  here as an array object.
  +-------                 END BOX 23                 -------+

  +-------                BEGIN BOX 24                -------+
  The descriptions of the virtuals in this class need to be brought into
  agreement with the new descriptions of the generic protocols.  As part
  of that we have

  //
  //  string             data ; exposition only

  +-------                 END BOX 24                 -------+

  27.7.1.1  basic_stringbuf                   [lib.basic.stringbuf.cons]
       constructors

  basic_stringbuf(ios_base::openmode which = ios_base::in
                  ios_base::out);

  Effects:
    Constructs an object of class basic_stringbuf, initializing the base
    class with basic_streambuf(), and initializing mode with which.  The
    function allocates no array object.

    basic_stringbuf(const basic_string<char_type>& str,
                    ios_base::openmode which = ios_base::in
                    ios_base::out);

  Effects:
    Constructs an object of class basic_stringbuf, initializing the base
    class with basic_streambuf(), and initializing mode with which.
  Notes:
    If str .length() is nonzero, the function allocates an array  object
    x  whose  length n is str .length() and whose elements x[I] are ini­
    tialized to str[I].  If which  & basic_ios::in is nonzero, the func­
    tion executes: setg(x,x,x+n);
    If  which    &  basic_ios::out  is  nonzero,  the function executes:
    setp(x,x+n);

  27.7.1.2  Member functions                     [lib.stringbuf.members]

  27.7.1.2.1  basic_stringbuf::str                  [lib.stringbuf::str]

  basic_string<char_type> str() const;

  Returns:
    The return value of this function are indicated in Table 13:

                        Table 13--str return values

  +------------------------------------------------------------------------+
  |      Condition                          Return Value                   |
  +------------------------------------------------------------------------+
  (mode & basic_ios::in) basic_string<char_type>(eback(),egptr() - eback())|
  != 0 and (gptr() != 0)                                                   |
  +------------------------------------------------------------------------+
  (mode & basic_ios::out)basic_string<char_type>(pbase(),pptr - pbase())   |
  != 0 and (pptr() != 0                                                    |
  +------------------------------------------------------------------------+
  |Otherwise              basic_string<char_type>()                         |
  +------------------------------------------------------------------------+

    void str(const basic_string<char_type>& s);

  Effects:
    If s.length() is zero, executes:
        setg(0, 0, 0);
        setp(0, 0);
    and frees storage for any associated array object.   Otherwise,  the
    function  allocates an array object x whose length n is str.length()
    and whose elements x[I] are  initialized  to  str[I].   If  which  &
    ios_base::in != 0, the function executes: setg(x,x,x+n);

        setg(0, 0, 0);     setp(0, 0);

    If which & ios_base::out != 0, the function executes: setp(x,x+n);

  27.7.1.2.2  basic_stringbuf::overflow        [lib.stringbuf::overflow]

  //  virtual int_type overflow(int_type c = eof());    inherited

  Effects:
    Appends  the  character  designated  by c to the output sequence, if
    possible, in one of two ways:

  --If c != eof() and if either the output sequence has a write position
    available  or  the  function  makes  a  write position available (as
    described below), the function calls sputc(c).
    Signals success by returning c.

  --If c == eof(), there is no character to append.
    Signals success by returning a value other than eof().
  Notes:
    The function can alter the number of write positions available as  a
    result of any call.
  Returns:
    eof() to indicate failure.

1 The  function  can  make  a  write  position available only if (mode &
  ios_base::out) != 0.  To make a write position available, the function
  reallocates (or initially allocates) an array object with a sufficient
  number of elements to hold the current array object (if any), plus one
  additional  write  position.  If (mode & ios_base::in) != 0, the func­
  tion alters the read end pointer egptr() to point just  past  the  new
  write position (as does the write end pointer epptr()).

  27.7.1.2.3  basic_stringbuf::pbackfail      [lib.stringbuf::pbackfail]

  //  virtual int_type pbackfail(int_type c = eof());    inherited

  +-------                BEGIN BOX 25                -------+
  Check vs. _lib.streambuf::pbackfail_ and _lib.filebuf::pbackfail_
  +-------                 END BOX 25                 -------+

  Effects:
    Puts back the character designated by c to the  input  sequence,  if
    possible, in one of three ways:

  --If  c  != eof(), if the input sequence has a putback position avail­
    able, and if char_type(c) == char_type(gptr()[-1]), assigns gptr() -
    1 to gptr().
    Returns: c.

  --If  c  != eof(), if the input sequence has a putback position avail­
    able,  and  if  mode  &  ios_base::out  is  nonzero,  assigns  c  to
    *--gptr().
    Returns: char_type(c).

  --If  c  ==  eof()  and  if  the input sequence has a putback position
    available, assigns gptr() - 1 to gptr().
    Returns: char_type(c).
  Returns:
    eof() to indicate failure.
  Notes:
    If the function can succeed in more than one of these  ways,  it  is
    unspecified which way is chosen.

  27.7.1.2.4  basic_stringbuf::underflow      [lib.stringbuf::underflow]

  //  virtual int_type underflow();    inherited

  Returns:
    If the  input  sequence  has  a  read  position  available,  returns
    char_type(*gptr()).
    Otherwise, returns eof().

  27.7.1.2.5  basic_stringbuf::seekoff          [lib.stringbuf::seekoff]

  //  virtual pos_type seekoff(off_type off, ios_base::seekdir way,
  //                           ios_base::openmode which
  //                               = ios_base::in | ios_base::out);    inherited

  +-------                BEGIN BOX 26                -------+
  Check vs. _lib.filebuf::seekpos_
  +-------                 END BOX 26                 -------+

  Effects:
    Alters  the  stream position within one of the controlled sequences,
    if possible, as indicated in Table 14:

                       Table 14--seekoff positioning

  +----------------------------------------------------------------------------+
  |        Conditions                              Result                      |
  +----------------------------------------------------------------------------+
  (which & basic_ios::in) != 0positions the input sequence                     |
  +----------------------------------------------------------------------------+
  (which& basic_ios::out) != 0positions the output sequence                    |
  +----------------------------------------------------------------------------+
  |Otherwise,                                                                   |
  (which & (basic_ios::in |   positions both the input and the output sequences|
  basic_ios::out)) == (ba­                                                     |
  sic_ios::in | ba­                                                            |
  sic_ios::out))                                                               |
  |and way == either ba­                                                        |
  sic_ios::beg or ba­                                                          |
  sic_ios::end                                                                 |
  +----------------------------------------------------------------------------+
  Otherwise,                  the positioning operation fails.                 |
  +----------------------------------------------------------------------------+

1 For  a  sequence  to  be  positioned,  if  its  next pointer is a null
  pointer, the positioning operation  fails.   Otherwise,  the  function
  determines newoff as indicated in Table 15:

                         Table 15--newoff values

        +---------------------------------------------------------+
        |      Condition                   newoff Value           |
        +---------------------------------------------------------+
        |way == basic_ios::beg    0                               |
        +---------------------------------------------------------+
        |way == basic_ios::cur    the next pointer minus the be­  |
        |                         ginning pointer (xnext - xbeg). |
        +---------------------------------------------------------+
        |way == basic_ios::end    the end pointer minus the be­   |
        |                         ginning pointer (xend - xbeg)   |
        +---------------------------------------------------------+
        |If (newoff + off) < 0,   the positioning operation fails |
        |or (xend - xbeg) <                                       |
        |(newoff + off)                                           |
        +---------------------------------------------------------+

2 Otherwise,  the  function  assigns  xbeg  +  newoff  + off to the next
  pointer xnext.
  Returns:
    pos_type(newoff), constructed from the resultant offset  newoff  (of
    type off_type), that stores the resultant stream position, if possi­
    ble.  If the positioning operation  fails,  or  if  the  constructed
    object  cannot  represent  the resultant stream position, the object
    stores an invalid stream position.

  27.7.1.2.6  basic_stringbuf::seekpos          [lib.stringbuf::seekpos]

  //  virtual pos_type seekpos(pos_type sp,
  //                           ios_base::openmode which
  //                             = ios_base::in
  //                             | ios_base::out);    inherited

  +-------                BEGIN BOX 27                -------+
  Check vs. _lib.filebuf::seekpos_
  +-------                 END BOX 27                 -------+

  Effects:
    Alters the stream position within one of the  controlled  sequences,
    if  possible,  to correspond to the stream position stored in sp (as
    described below).

  --If (which & basic_ios::in)  != 0, positions the input sequence.

  --If (which & basic_ios::out) != 0, positions the output sequence.

  --If the function positions neither sequence, the  positioning  opera­
    tion fails.

1 For  a  sequence  to  be  positioned,  if  its  next pointer is a null
  pointer, the positioning operation  fails.   Otherwise,  the  function
  determines newoff from sp.offset():

  --If  newoff  is  an invalid stream position, has a negative value, or
    has a value greater than (xend - xbeg),  the  positioning  operation
    fails.

  --Otherwise,  the  function  adds newoff to the beginning pointer xbeg
    and stores the result in the next pointer xnext.
  Returns:
    pos_type(newoff), constructed from the resultant offset  newoff  (of
    type off_type), that stores the resultant stream position, if possi­
    ble.  If the positioning operation  fails,  or  if  the  constructed
    object  cannot  represent  the resultant stream position, the object
    stores an invalid stream position.

  27.7.1.2.7  basic_stringbuf::setbuf            [lib.stringbuf::setbuf]

  //  virtual basic_streambuf<charT,traits>*
  //      setbuf(char_type* s, streamsize n);    inherited

  Effects:
    Performs an operation that is  defined  separately  for  each  class
    derived from basic_stringbuf<charT,traits>.
  Default behavior:
    The     same    as    for    basic_streambuf<charT,traits>::    set­
    buf(char_type*,streamsize).

  27.7.2  Template class basic_istringstream         [lib.istringstream]
  namespace std {
    template <class charT, class traits = ios_traits<charT> >
    class basic_istringstream : public basic_istream<charT,traits> {
    public:
      typedef charT            char_type;
      typedef traits::int_type int_type;
      typedef traits::pos_type pos_type;
      typedef traits::off_type off_type;
      int_type  eof()     { return traits::eof(); }
      char_type newline() { return traits::newline(); }
    public:
      basic_istringstream(ios_base::openmode which
                              = ios_base::in);
      basic_istringstream(const basic_string<charT>& str,
                          ios_base::openmode which
                              = ios_base::in);
      virtual ~basic_istringstream();
      basic_stringbuf<charT,traits>* rdbuf() const;
      basic_string<charT> str() const;
      void str(const basic_string<charT>& s);
    };
  }

1 The  class  basic_istringstream<charT,traits>  is  a   derivative   of
  basic_istream<charT,traits>  that assists in the reading of objects of
  class basic_stringbuf<charT,traits>.  It  supplies  a  basic_stringbuf
  object to control the associated array object.

  27.7.2.1  basic_istringstream         [lib.basic.istringstream.m.cons]
       constructors

  basic_istringstream(ios_base::openmode which
     = ios_base::in);

  Effects:
    Constructs an  object  of  class  basic_istringstream<charT,traits>,
    initializing the base class with basic_istream<charT,traits>(&sb).

    basic_istringstream(const basic_string<charT>& str,
                        ios_base::openmode which = ios_base::in);

  Effects:
    Constructs  an  object  of  class basic_istringstream<charT,traits>,
    initializing the base class with basic_istream<charT,traits>(&sb).

  27.7.2.2  Member functions                 [lib.istringstream.members]

  27.7.2.2.1  basic_istringstream::rdbuf      [lib.istringstream::rdbuf]

  basic_stringbuf<charT,traits>* rdbuf() const;

  Returns:
    dynamic_cast<basic_stringbuf<charT,traits>*>
    (basic_istream<harT,traits>::rdbuf()).

  27.7.2.2.2  basic_istringstream::str          [lib.istringstream::str]

  basic_string<charT> str() const;

  Returns:
    rdbuf().str().

    void str(const basic_string<charT>& s);

  Effects:
    Calls rdbuf().str(s).

  27.7.2.3  Class basic_ostringstream                [lib.ostringstream]

  namespace std {
    template <class charT, class traits = ios_traits<charT> >
    class basic_ostringstream : public basic_ostream<charT,traits> {
    public:
      typedef charT            char_type;
      typedef traits::int_type int_type;
      typedef traits::pos_type pos_type;
      typedef traits::off_type off_type;
      int_type  eof()     { return traits::eof(); }
      char_type newline() { return traits::newline(); }
    public:
      basic_ostringstream(ios_base::openmode which
                              = ios_base::out);
      basic_ostringstream(const basic_string<charT>& str,
                          ios_base::openmode which
                              = ios_base::out);
      virtual ~basic_ostringstream();
      basic_stringbuf<charT,traits>* rdbuf() const;
      basic_string<charT> str() const;
      void str(const basic_string<charT>& s);
    };
  }

1 The  class  basic_ostringstream<charT,traits>  is  a   derivative   of
  basic_ostream<charT,traits>  that assists in the writing of objects of
  class basic_stringbuf<charT,traits>.  It  supplies  a  basic_stringbuf
  object to control the associated array object.

  27.7.2.4  basic_ostringstream           [lib.basic.ostringstream.cons]
       constructors

  basic_ostringstream(ios_base::openmode which
     = ios_base::out);

  Effects:
    Constructs an object of class basic_ostringstream, initializing  the
    base class with basic_ostream(&sb).

    basic_ostringstream(const basic_string<charT>& str,
                        ios_base::openmode which = ios_base::out);

  Effects:
    Constructs  an  object  of  class basic_ostringstream<charT,traits>,
    initializing the base class with basic_ostream<charT,traits>(&sb).

  27.7.2.5  Member functions                 [lib.ostringstream.members]

  27.7.2.5.1  basic_ostringstream::rdbuf      [lib.ostringstream::rdbuf]

  basic_stringbuf<charT,traits>* rdbuf() const;

  Returns:
    dynamic_cast<basic_stringbuf<charT,tratis>*>

    (basic_ostream<charT,traits>::rdbuf()).

  27.7.2.5.2  basic_ostringstream::str          [lib.ostringstream::str]

  basic_string<charT> str() const;

  Returns:
    rdbuf().str().

    void str(const basic_string<charT>& s);

  Effects:
    Calls rdbuf().str(s).

  27.8  File-based streams                            [lib.file.streams]

1 Headers: <cstream> and <fstream> (Table 16):

  +-------                BEGIN BOX 28                -------+
  ISSUE: Disposition of <cstream> and convbuf (next 10.5 pages) TBD.
  +-------                 END BOX 28                 -------+

                   Table 16--Header <cstream> synopsis

  +-----------------------------------------------------------------------+
  |      Type                               Name(s)                       |
  +-----------------------------------------------------------------------+
  |Template class:     basic_convbuf                                      |
  +-----------------------------------------------------------------------+
  |Template structs:   conv_traits            ios_conv_traits             |
  +-----------------------------------------------------------------------+
  |Structs:            conv_traits<wchar_t>   ios_conv_traits<wstreampos> |
  +-----------------------------------------------------------------------+

  27.8.1  Multi-byte conversions                     [lib.conv.fstreams]

1 The header <cstream> defines one type, basic_convbuf  that  associates
  its  internal stream buffers holding a sequence of characters with the
  external source/sink stream representing a sequence of another type of
  characters.

  --Conversion  There is a bidirectional conversion between the external
    source/sink stream and character sequences held in the basic_convbuf
    class object.

  --uchar_type:   underlaid   character   container  type  The  external
    source/sink stream can be regarded as a sequence of a character con­
    tainer  type,  which  may be different to charT.  The character con­
    tainer type on the external source/sink stream is called the  under­
    laid character container type, or uchar_type.

  --Encoding  rule Performing the conversion from a uchar_type character
    sequences to the corresponding character sequence, the basic_convbuf
    may parse the uchar_type sequence to extract the corresponding char­
    acter represented on the uchar_type sequence.  The rule how  a  cer­
    tain  character  is  to  be  represented on a sequence of uchar_type
    characters is called the encoding rule.  The  basic_convbuf  can  be
    regarded  as  having  a (virtual) conversion machine which obeys the
    encoding rule to parse uchar_type sequences.

  --Conversion state The conversion machine has its internal state  cor­
    responding to a certain position of the external source/sink stream.
    If the basic_convbuf stops the conversion to resume later, it has to
    save its internal state, so a class or a type is prepared for saving
    the state onto it so that an user of the basic_convbuf class  object
    can  handle  it.   The  class (or the type) is called the conversion
    state.

  --

  +-------                BEGIN BOX 29                -------+
  Multibyte character I/O support The basic_convbuf can  support  multi­
  byte character file I/O operations.  Provided that the code conversion
  functions between multibyte characters and wide  characters  are  pre­
  pared,  we  may specify the conversion state, and the conversion func­
  tions in the ios_conv_traits so that the basic_convbuf can handle this
  multibyte characters.
  +-------                 END BOX 29                 -------+

  27.8.1.1  Template class conv_traits                 [lib.conv.traits]

  template <class charT> struct conv_traits {}

  struct conv_traits<wchar_t> {
      typedef ios_traits<wchar_t>   char_traits;
      typedef ios_traits<wstreampos> pos_traits;
      typedef ios_conv_traits<state_t>   conv_traits;
  };

1 The  template  struct  conv_traits<charT> is a traits classwhich main­
  tains the definitions of the types and functions necessary  to  imple­
  ment  the  template class basic_convbuf.  The template parameter charT
  reprsents the character container type and each specialized version of
  conv_traits provides the default definitions corresponding to the spe­
  cialized character container type.

2 The conv_traits<charT>  declaration  has  three  members,  ios_traits,
  ios_traits, and ios_conv_traits.

3 Although  the former two of them are same as in the ios_traits<charT>,
  the last traits, ios_conv_traits<charT> provides all  the  definitions

  about types and functions necessary to perform conversion.

  27.8.1.2  Template class ios_conv_traits         [lib.ios.conv.traits]

  template <class stateT> struct ios_conv_traits {};

1 As is the other traits structs, there is no definition in the declara­
  tion of the template struct, ios_conv_traits.  All of the  definitions
  related  to  the  conversion  and necessary to implement basic_convbuf
  class    shall    be    provided    in     a     template     version,
  ios_conv_traits<STATE_T> specialized for a conversion state STATE_T.

  27.8.1.2.1  Struct                       [lib.ios.conv.traits.state.t]
       ios_conv_traits<STATE_T>
  struct ios_conv_traits<STATE_T> {
      typedef CHAR_T  char_type;
      typedef STATE_T conv_state;
      typedef UPOS_T  conv_upos;
      typedef UCHAR_T uchar_type;
      typedef POS_T   pos_type;
      typedef OFF_T   off_type;
      typedef codecnv<uchar_type,char_type,conv_state> codecvt_in;
      typedef codecnv<char_type,uchar_type,conv_state> codecvt_out;
      result convin(codecvt_in*, conv_state&,
              const uchar_type*, const uchar_type*, const uchar_type*&,
              char_type*, char_typeT*, char_type*&);
      result convout(codecvt_out*, conv_state&,
              const char_type*, const char_type*, const char_type*&,
              uchar_type*, uchar_type*, uchar_type*&);
      pos_type   get_pos(conv_state&, conv_upos&);
      off_type   get_off(conv_state&, conv_upos&);
      conv_state get_posstate pos_type&);
      conv_state get_offstate(off_type&);
      conv_upos  get_posupos (pos_type&);
      conv_upos  get_offupos (off_type&);
  };

1 A specialized version of the struct ios_conv_traits<STATE_T>is  neces­
  sary  to use the basic_convbufclass.  In order to construct a special­
  ized version of the struct, the following set of types  and  functions
  shall be provided.

  --CHAR_T  : is the character container type which shall be same as the
    template parameter of the class, conv_traits.

  --STATE_T : is the conversion  state  type  which  also  the  template
    parameter  type  of  this  traits.   It is the parsing/tracing state
    which the function, convin and convout are taken.

  --Every type of conversion states have a state, called initial  state,
    which  corresponds  to  the state beginning to parse a new sequence.
    The   constructor,   STATE_T::STATE_T()    or    STATE_T::STATE_T(0)

    constructs the initial state.

  --UCHAR_T : is the underlaid character container type for the external
    source/sink stream handled by the basic_convbuf.

  --UPOS_T : is the  repositional  information  type  for  the  external
    source/sink  stream.   It  is  used to implement the seekpos/seekoff
    member functions in the basic_convbuf.

  --POS_T : is the repositional information which the basic_convbuf sup­
    ports  for  the  client  of the object.  It shall be the same as the
    template parameter  type  of  the  struct  ios_traits  in  the  same
    conv_traits.

  --OFF_T : is an integral type which is used as the repositional infor­
    mation which the basic_convbufsupports.

  27.8.1.2.1.1  convin             [lib.ios.conv.traits.state.t::convin]

  result
  vin(codecvt_in* ccvt, conv_state& stat,
      const uchar_type* from, const uchar_type* from_end,
      const uchar_type*& from_next,
      char_type* to, char_typeT* to_limit, char_type*& to_next);

1 The conversion state designated by stat represents the  parsing  state
  on  the  underlaid source sequence.  According to the conversion state
  designated by stat, it begins to parse the source  character  sequence
  whose  begining  and  end  position designated by from and from_end to
  convert them.  It stores the result sequence (if any) into the succes­
  sive  location of an array pointed to by to and to_limit.  The conver­
  sion stops when either of the following occurs:

  1)parses all of the underlaid character sequences and stores the  last
    character into the destination array.

  2)fills all of the destination array and no more room to store.

  3)encounters an invalid underlaid character in the source sequence.

2 In case (1), it returns ok.  In case (2), it returns partial.  In case
  (3), it returns error.

3 In all cases it leaves the from_next and to_next pointers pointing one
  beyond  the  last character successfully converted and leaves the con­
  version state onto the stat for the next time conversion.  If case (3)
  occurs,  the conversion state on the stat becomes undefined value.  No
  more conversion with the value is available.

4 If the locale-dependent conversion functions are needed, the  nconver­
  sion  function which the codecvt facet object, ccnv provides is avail­
  able as the following invokation:

  ccnv.convert(stat, from, from_end, from_next, to, to_limit, to_next);

5 The default conversion function depends on the locale_codecvt  facets.
  Users  can  customize the encoding scheme by specifying their own con­
  version functions in a new conv_traits class.

  27.8.1.2.1.2  convout           [lib.ios.conv.traits.state.t::convout]

  result convout(codecvt_out* ccvt, conv_state&,
              const char_type from*, const char_type* from_end,
              const char_type*& from_next.,
              uchar_type*, uchar_type*, uchar_type*&);

1 The conversion state designated by stat represents the  parsing  state
  on  the  underlaid  destination  sequence.   It  begins to convert the
  source character sequence whose begining and end  position  designated
  by from and from_end.  According to the conversion state designated by
  stat, it stores the result destination underlaid chracter sequence (if
  any)  into  the  successive  location of an array pointed to by to and
  to_limit.  The conversion stops when either of the following occurs:

  1)consumes all of the source character sequences and stores  the  last
    underlaid character into the destination array.

  2)fills all of the destination array and no more room to store.

  3)encounters an invalid character in the source sequence.

2 In case (1), it returns ok.  In case (2), it returns partial.  In case
  (3), it returns error.

3 In all cases it leaves the from_next and to_next pointers pointing one
  beyond  the  last character successfully converted and leaves the con­
  version state onto the stat for the next time conversion.  If case (3)
  occurs,  the conversion state on the stat becomes undefined value.  No
  more conversion with the value is available.

4 If the locale-dependent conversion functions are needed,  the  conver­
  sion  function which the codecvt facet object, ccnv provides is avail­
  able as the following invocation;

  ccnv.convert(stat, from, from_end, from_next, to, to_limit, to_next);

5 The default conversion  function  is  depends  on  the  locale_codecvt
  facets.   Users  can customize the encoding scheme by specifying their
  own conversion functions in a new conv_traits class.

  27.8.1.2.1.3  get_pos and       [lib.ios.conv.traits.state.t::get.pos]
       get_off

  pos_type get_pos(conv_state& stat, conv_upos& upos);
  off_type get_off(conv_state&, conv_upos&);

  Effects:
    Constructs  the  pos_type object or off_type object from the conver­
    sion state, stat and the repositional information for the  underlaid
    stream,  upos  and  returns  it.   These are used to make the return
    value of the basic_convbuf::seekpos/seekoff protected  member  func­
    tion.

  27.8.1.2.1.4              [lib.ios.conv.traits.state.t::get.pos.state]
       get_posstate
       and
       get_offstate

  conv_state get_posstate(pos_type& pos);
  conv_state get_offstate(off_type& off);

1 Extract the conversion state held by the repositional information, pos
  or  off.   These  are used to reset the conversion state maintained in
  the basic_convbuf class object when the basic_convbuf::seetpos/seekoff
  functions are performed.

  27.8.1.2.1.5               [lib.ios.conv.traits.state.t::get.pos.upos]
       ios_conv_traits<STATE_T>::get_posupos
       and get_offupos

  conv_upos  get_posupos(pos_type&);
  conv_upos  get_offupos(off_type&);

1 Extract  the  repositioning  information for the underlaid stream from
  the repositioning information on the basic_convbuf stream.  These  are
  used  in the basic_convbuf::seekpos/seekoff protected member functions
  to reposition the external source/sink stream.

  27.8.1.2.2  Struct                    [lib.ios.conv.traits.wstreampos]
       ios_conv_traits<wstreampos>
  struct ios_conv_traits<wstreampos> {
      typedef wchar_t char_type;
      typedef STATE_T conv_state;
      typedef UPOS_T  conv_upos;
      typedef char    uchar_type;
      typedef wstreampos pos_type;
      typedef wstreamoff off_type;
      typedef codecnv<char,wchar_t,STATE_T> codecnv_in;
      typedef codecnv<wchar_t,char,STATE_T> codecnv_out;

      result convin(codecvt_in* ccvt, conv_state& stat,
             const char *from, const char* from_end, const char*& from_next,
             wchar_t* to, wchar_t* to_limit, wchar_t*& to_next) {
              return ccvt->convert (stat, from, from_end, from_next,
                   to, to_limit, to_next);
          }
      result convout(codecvt_out* ccvt, conv_state& stat,
             const wchar_t* from, const wchar_t* from_end, const wchar_t*& from_next,
             char* to, char* to_limit, char* to_next) {
              return ccvt->convert (stat, from, from_end, from_next,
                   to, to_limit, to_next);
          }
      pos_type   get_pos(conv_state&, conv_upos&);
      off_type   get_off(conv_state&, conv_upos&);
      conv_state get_posstate(pos_type&);
      conv_state get_offstate(off_type&);
      conv_upos  get_posupos (pos_type&);
      conv_upos  get_offupos (off_type&);
  };

1 The specialized version  of  the  struct,  ios_conv_traits<wstreampos>
  supports  the  wide-oriented  basic_convbuf  class  and the conversion
  between wide characters and  multibyte  characters  as  the  underlaid
  character sequence.  The types, STATE_T and UPOS_T are implementation-
  defined types.  The behavior of the  conversion  functions  depend  on
  those of the locale object.

2 The  encoding  rule  of  the  multibyte  characters is implementation-
  defined.

  27.8.1.3  Template class basic_convbuf             [lib.basic.convbuf]
  template <class charT, class traits = conv_traits<charT> >
  class basic_convbuf : public basic_streambuf<charT,traits> {
  public:
      typedef charT            char_type;
      typedef traits::int_type int_type;
      typedef traits::pos_type pos_type;
      typedef traits::off_type off_type;
      int_type  eof()     { return traits::eof(); }
      char_type newline() { return traits::newline(); }
  private:
      typedef traits::conv_traits::conv_state state_type;
      typedef traits::conv_traits::conv_upos upos_type ;
  public:
      basic_convbuf();
      virtual ~basic_convbuf();

  protected:
  //  virtual int_type overflow (int_type c = eof());     inherited
  //  virtual int_type pbackfail(int_type c = eof());     inherited
  //  virtual int_type underflow();                                       inherited
  //  virtual int_type uflow();                                           inherited
  //  virtual streamsize xsgetn(charT* s, streamsize n);          inherited
  //  virtual streamsize xsputn(const charT* s, streamsize n);    inherited
  //  virtual pos_type seekoff(off_type, ios_base::seekdir way,
  //                           ios_base::openmode which
  //                             = ios_base::in
  //                             | ios_base::out);        inherited
  //  virtual pos_type seekpos(pos_type  sp, ios_base::openmode which
  //                             = ios_base::in
  //                             | ios_base::out);        inherited
  //  virtual basic_streambuf<charT,traits>*
  //                   setbuf(charT* s, streamsize n);    inherited
  //  virtual int sync();         inherited
  private:
  //  state_type state;   exposition only
  };

1 The  template  class  basic_convbuf<charT,traits>  is   derived   from
  basic_streambuf<charT,traits> to associate the character sequences and
  the underlaid character sequences.  It performs the conversion between
  these two types of chracter sequences.

2 For the sake of exposition, the basic_convbuf maintains the conversion
  state to restart the conversion to read/write the  character  sequence
  from/to the underlaid stream.

  27.8.1.3.1  basic_convbuf  constructor        [lib.basic.convbuf.cons]

  basic_convbuf();

  Effects:
    Constructs  an object of template class basic_convbuf<charT,traits>,
    initializing the base  class  with  basic_streambuf<charT,traits>(),
    and initializing;

  --state with state_type(0) as to specify initial state.

  27.8.1.3.2  basic_convbuf  destructor          [lib.basic.convbuf.des]

  virtual ~basic_convbuf();

  Effects:
    Destroys an object of class basic_convbuf<charT,traits>.

  27.8.1.3.3  basic_convbuf::overflow       [lib.basic.convbuf.overflow]

  virtual int_type overflow(int_type c = eof());

  Effects:
    Behaves   the  same  as  basic_streambuf<charT,traits>::overflow(c),
    except that the behavior of ``consuming a character'' is as follows:

  --(1)  Converting  the  characters  to  be consumed into the underlaid
    character sequence with the function traits::conv_traits::convout().

  --(2) The result underlaid character sequence is appended to the asso­
    ciated output stream.

  27.8.1.3.4                              [lib.basic.convbuf::pbackfail]
       basic_convbuf::pbackfail

  virtual int_type pbackfail(int_type c);

  Effects:
    Puts  back  the  character designated by c to the input sequence, if
    possible, in one of three ways:

  +-------                BEGIN BOX 30                -------+
  Because the parsing on the underlaid character sequence generally  can
  only  go  advance  or most of parsing machined cannot go back, some of
  the  basic_convbuf  implementations  cannot  ``put   back   characters
  directly to the associated input sequence.''  So the behaviors related
  to putting back the associated input stream are removed.
  +-------                 END BOX 30                 -------+

  --If c != eof(), if either the input sequence has a  putback  position
    available or the function makes a putback position available, and if
    (charT)c  ==  (charT)gptr()[-1],  assigns  gptr()  -  1  to  gptr().
    Returns (charT)c.

  --If  c  != eof(), if either the input sequence has a putback position
    available or the function makes a putback position available, and if
    the function is permitted to assign to the putback position, assigns
    c to *--gptr().  Returns (charT)c.

  --If c == eof() and if either the input sequence has a  putback  posi­
    tion  available  or the function makes a putback posotion available,
    assigns gptr() - 1 to gptr().  Returns (charT)c.
  Returns:
    eof() to signal the failure.
  Notes:

1 The function does not put back  a  character  directly  to  the  input
  sequence.

2 If  the  function  can  succeed  in more than one of these ways, it is
  unspecified which way is chosen.  The function can alter the number of
  putback positions available as a result of any call.

3 Default behavior:  returns traits::eof().

  27.8.1.3.5                              [lib.basic.convbuf::underflow]
       basic_convbuf::underflow

  //  virtual int_type underflow();    inherited

  Returns:
    the first character of the pending sequence,  if  possible,  without
    moving the stream position past it.  If the pending sequence is null
    then the function fails.

1 The pending sequence of characters is defined as the concatenation of:

  a)If  gptr() is non- NULL, then the egptr() - gptr() characters start­
    ing at gptr(), otherwise the empty sequence.

  b)Some sequence (possibly empty) of characters  read  from  the  input
    stream.

  --These  underlaid  character sequence shall be converted by the func­
    tion traits::conv_traits::convin() before concatinating to construct
    the  pending  sequence.   In  case that there remains some underlaid
    characters which cannot be converted  to  any  more  characters,  we
    treat it empty as the subsequence (b).

2 The  result  character is the first character of the pending sequence,
  if any.  The backup sequence is defined as the concatenation of:

  a)If eback() is non- NULL then empty, otherwise the gptr()  -  eback()
    characters beginning at eback().

  b)the result character.

3 The function sets up gptr() and egptr() satisfying:

  a)In case the pending sequence has more than one character the egptr()
    - gptr() characters starting at gptr() are  the  characters  in  the
    pending sequence after the result character.

  b)If  the  pending sequence has exactly one character, then gptr() and
    egptr() may be NULL or may  both  be  set  to  the  same  non-  NULL
    pointer.

4 If  eback()  and  gptr()  are  non- NULL then the function is not con­
  strained as to their contents, but the ``unusual backup condition'' is
  that either:

  a)If  the  backup  sequence contains at least gptr() - eback() charac­
    ters, then the gptr() - eback() characters starting at eback() agree
    with the last gptr() - eback() characters of the backup sequence.

  b)Or  the  n  characters  starting  a gptr() - n agree with the backup

    sequence (where n is the length of the backup sequence)
  Returns:
    eof() to indicate failure.

5 Default behavior:  returns traits::eof().

  27.8.1.3.6  basic_convbuf::seekoff              [lib.convbuf::seekoff]

  //  virtual pos_type seekoff(off_type off, ios_base::seekdir way,
  //      ios_base::openmode which
  //        = ios_base::in | ios_base::out);    inherited

  Effects:
    Behaves                 the                 same                  as
    basic_streambuf<charT,traits>::seekoff(off,way,which),  except  that
    the behavior ``alters the stream position'' means that:

  --(a) altering the underlaid character stream position which they  get
    with         the         return         value         of         the
    traits::conv_traits::get_posupos(off_type&); and,

  --(b) restoring the current conversion state by resetting the  member,
    state       with       the       return       value      of      the
    traits::conv_traits::get_offstate(off_type&).

  27.8.1.3.7  basic_convbuf::seekpos              [lib.convbuf::seekpos]

  //  virtual pos_type seekpos(pos_type sp,
  //      ios_base::openmode which
  //        = ios_base::in | ios_base::out);    inherited

1 At first do sync() to clear up the get buffer, and alters  the  stream
  position, as follows:

  --(a)  altering  the  underlaid character stream position by which the
    function, traits::conv_traits::get_posupos(pos), returns.  and,

  --(b) restoring the  member,  state  with  the  return  value  of  the
    traits::conv_traits::get_posstate(pos).
  Returns:
    pos_type,  newpos,  constructed from the resultant upos and state if
    both (a) and (b) are successfully terminated.

2 If either or both (a) or/and (b) fail(s), or if the constructed object
  cannot  represent  the resultant stream position, the object stores an
  invalid stream position.

3 Whichever  value  is  specified   in   the   which   parameters,   the
  basic_convbuf handles only one external source/sink stream.

4 If (a) succeeds, returns a newly constructed streampos object returned
  by traits::conv_traits::get_pos(state, upos) where upos  is  a  UPOS_T

  type  object  which  represent  the  current position of the underlaid
  stream.

5 Otherwise, the object stores an invalid stream position.

  27.8.1.3.8  basic_convbuf::setbuf                [lib.convbuf::setbuf]

  //  virtual basic_streambuf<charT,traits>*
  //      setbuf(char_type* s, streamsize n);    inherited

1 Makes the array of n ( charT type) characters, whose first element  is
  designated by s, available for use as a buffer area for the controlled
  sequences, if possible.

  +-------                BEGIN BOX 31                -------+
  The basic_convbuf does not fix the  buffer  management  strategy.   It
  remains alternatives for the derived class designers.
  +-------                 END BOX 31                 -------+

  27.8.1.3.9  basic_convbuf::sync                    [lib.convbuf::sync]

  //  virtual int sync();    inherited

1 Reflects  the pending sequence to the external sink sequence and reset
  the get/put buffer pointers.  It means that if there are  some  unread
  sequence  on  the  get  buffer and the external source sequense is not
  seekable, the unread sequence is perfectly lost.

2 The detailed behavior is as follows:

  a)Consumes all of the pending  sequence  of  characters,  (as  pending
    sequence  and  ``consumes the sequence,'' see the description in the
    basic_streambuf<charT,traits>::overflow() _lib.streambuf::overflow_)
    In  case that consuming means appending characters to the associated
    output stream, the character sequense shall be converted to the cor­
    responding      underlaid      character     sequence     by     the
    traits::conv_traits::convout().

  b)Clears all of the  following  pointers:  pbase(),  pptr(),  epptr(),
    eback(), gptr(), and egptr().
  Returns:
    -1 if (a) fails, otherwise 0.

  27.8.1.4  Examples of trait specialization       [lib.examples.traits]
  class fstate_t { ... };       // Implementation-defined conversion state
                                // object which is for file I/O.
  class wfstate_t { ... };
  template <class charT> struct file_traits {};

  struct file_traits<char> {
      typedef ios_traits<char> char_traits;
      typedef ios_traits<streampos> char_pos;
      typedef ios_conv_traits<fstate_t> conv_pos;
  };
  struct file_traits<wchar_t>{
      typedef ios_traits<char> char_traits;
      typedef ios_traits<wstreampos> char_pos;
      typedef ios_conv_traits<wfstate_t> conv_pos;
  };
  template <class stateT> struct ios_file_traits {};
  //
  // Specialized for the single-byte filebuf
  //
  struct ios_conv_traits<fstate_t> {
      typedef char       char_type;       // char/wchar_t...
      typedef fstate_t   conv_state;      // key parameter(mainly depend on uchar_type)
      typedef streamoff  conv_upos;       // Physical file offset
      typedef char       uchar_type;      // Physical file I/O
      typedef streampos  pos_type;        // Enough to large
      typedef streamoff  off_type;        // Enough to large
      typedef codecnv<char,wchar_t,fstate_t> codecnv_in;
      typedef codecnv<wchar_t,char,fstate_t> codecnv_out;
      result convin(codecvt_in* ccvt, conv_state& stat,
                            const char *from, const char* from_end,
                            const char*& from_next,
                            char* to, char* to_limit, char*& to_next) {
          return ccvt->convert (stat, from, from_end, from_next,
                               to, to_limit, to_next);
      }
      result convout(codecvt_out* ccvt, conv_state& stat,
                             const char* from, const char* from_end,
                             const char*& from_next,
                             char* to, char* to_limit, char* to_next) {
          return ccvt->convert (stat, from, from_end, from_next,
                               to, to_limit, to_next);
      }
      pos_type get_pos(conv_state&, conv_upos&);
      off_type get_off(conv_state&, conv_upos&);
      conv_state get_posstate(pos_type&);
      conv_state get_offstate(off_type&);
      conv_upos  get_posupos (pos_type&);
      conv_upos  get_offupos (off_type&);
  };
  //
  // Specialized for the wfilebuf
  //

  struct ios_conv_traits<wfstate_t> {
      typedef wchar_t    char_type;       // char/wchar_t...
      typedef wfstate_t   conv_state;     // key parameter(mainly depend on uchar_type)
      typedef streamoff  conv_upos;       // Physical file offset
      typedef char       uchar_type;      // Physical file I/O
      typedef wstreampos pos_type;        // Enough to large
      typedef wstreamoff off_type;        // Enough to large
      typedef codecnv<char,wchar_t,fstate_t> codecnv_in;
      typedef codecnv<wchar_t,char,fstate_t> codecnv_out;
      result convin (codecvt_in* ccvt, conv_state& stat,
                const char *from, const char* from_end, const char*& from_next,
                wchar_t* to, wchar_t* to_limit, wchar_t*& to_next) {
          return ccvt->convert (stat, from, from_end, from_next,
                               to, to_limit, to_next);
      }
      result convout (codecvt_out* ccvt, conv_state& stat,
                const wchar_t* from, const wchar_t* from_end,
                const wchar_t*& from_next,
                char* to, char* to_limit, char* to_next) {
          return ccvt->convert (stat, from, from_end, from_next,
                               to, to_limit, to_next);
      }
      pos_type get_pos (conv_state&, conv_upos&);
          // wstreampos get_pos (wfstate_t&, streampos);
      off_type get_off (conv_state&, conv_upos&);
          // wstreamoff get_off (wfstate_t&, streampos);
      conv_state get_posstate (pos_type&);
          // wfstate_t get_posstate (wstreampos&);
      conv_state get_offstate (off_type&);
          // wfstate_t get_offstate (wstreamoff&);
      conv_upos  get_posupos (pos_type&);
          //
      conv_upos  get_offupos (off_type&);
  };

  27.8.2  File streams                                    [lib.fstreams]

  Header <fstream> synopsis

  #include <cstream>      // for conv_traits, basic_convbuf
  #include <streambuf>
  #include <istream>
  #include <ostream>

  namespace std {
    template <class charT, class traits = conv_traits<charT> >
      class basic_filebuf;
    typedef basic_filebuf<char>    filebuf;
    typedef basic_filebuf<wchar_t> wfilebuf;

    template <class charT, class traits = file_traits<charT> >
      class basic_ifstream;
    typedef basic_ifstream<char>    ifstream;
    typedef basic_ifstream<wchar_t> wifstream;

    template <class charT, class traits = file_traits<charT> >
      class basic_ofstream;
    typedef basic_ofstream<char>    ofstream;
    typedef basic_ofstream<wchar_t> wofstream;
  }

1 The  header  <fstream> defines six types that associate stream buffers
  with files and assist reading and writing files.

  +-------                BEGIN BOX 32                -------+
  basic_filebuf<charT,traits> should be specified so that  it  treats  a
  file  as  a  sequence  of charT.  Except for filebuf and wfilebuf that
  implies it treats the file as binary.
  +-------                 END BOX 32                 -------+

2 In this subclause, the type name  FILE  is  a  synonym  for  the  type
  FILE.45)

  --File  A File provides an external source/sink stream whose underlaid
    character type is char (byte).

  --Multibyte characters and Files Class basic_filebuf is  derived  from
    basic_convbuf  to  support  multibyte  character  I/O.   A File is a
    sequence of multibyte characters.  In order to provide the  contents
    as  a  wide character sequence, wfilebuf should convert between wide
    character sequences and multibyte character sequences.

  --basic_filebuf Derived from  basic_convbuf.   Even  the  single  byte
    character  version because single byte code conversion may be neces­
    sary...  A basic_filebuf provide... file I/O,  char/wchar_t  parity.
    fstate_t.  ios_conv_traits

  --Customize  Mechanism  Change name ( conv_traits-> file_traits), cus­
    tomize  ios_conv_traits<fstate_t>.    Modify   the   definition   of
  _________________________
  45) FILE is defined in <cstdio> (_lib.c.files_).

    ios_conv_traits.

  --Multibyte  character  and  Files A File provides byte sequences.  So
    the streambuf (or its derived classes) treats a file as the external
    source/sink  byte  sequence.   In a large character set environment,
    multibyte character sequences are held in files.  In order  to  pro­
    vide  the  contents  of  a  file  as wide character sequences, wide-
    oriented filebuf, namely  wfilebuf  should  convert  wide  character
    sequences.   Because  of  necessity  of  the  conversion between the
    external source/sink streams and wide character sequences.

  27.8.2.1  Template class basic_filebuf                   [lib.filebuf]
  namespace std {
    template <class charT, class traits = conv_traits<charT> >
    class basic_filebuf : public basic_convbuf<charT,traits> {
    public:
      typedef charT            char_type;
      typedef traits::int_type int_type;
      typedef traits::pos_type pos_type;
      typedef traits::off_type off_type;
      int_type  eof()     { return traits::eof(); }
      char_type newline() { return traits::newline(); }
    public:
      basic_filebuf();
      virtual ~basic_filebuf();
      bool is_open() const;
      basic_filebuf<charT,traits>*
           open(const char* s, ios_base::openmode mode);
  //  basic_filebuf<charT,traits>* open(const char* s, ios::open_mode mode);
      basic_filebuf<charT,traits>* close();
    protected:
  //  virtual int_type overflow (int_type c = eof());     inherited
  //  virtual int_type pbackfail(int_type c = eof());     inherited
  //  virtual int      showmany();                inherited
  //  virtual int_type underflow();               inherited
  //  virtual int_type uflow();                   inherited
  //  virtual streamsize xsgetn(char_type* s  streamsize n);      inherited
  //  virtual streamsize xsputn(const char_type* s, streamsize n);        inherited
  //  virtual pos_type seekoff(off_type off,
  //                           ios_base::seekdir way,
  //                           ios_base::openmode which
  //                             = ios_base::in
  //                             | ios_base::out);        inherited
  //  virtual pos_type seekpos(pos_type sp,
  //                           ios_base::openmode which
  //                             = ios_base::in
  //                             | ios_base::out);        inherited
  //  virtual basic_streambuf<charT,traits>*
  //                   setbuf(char_type* s, streamsize n);        inherited
  //  virtual int sync();                         inherited
    private:
  //  FILE* file; exposition only
    };
  }

1 The    class    basic_filebuf<charT,traits>    is     derived     from
  basic_streambuf<charT,traits> to associate both the input sequence and
  the output sequence with an object of type FILE.

  +-------                BEGIN BOX 33                -------+
  For the sake of exposition, the maintained data is presented here as:

  --FILE* file, points to the FILE associated with the object  of  class
    basic_filebuf<charT,traits>.
  +-------                 END BOX 33                 -------+

2 The  restrictions  on  reading and writing a sequence controlled by an
  object of class basic_filebuf<charT,traits> are the same as for  read­
  ing and writing its associated file.  In particular:

  --If  the  file  is  not  open  for  reading  or for update, the input
    sequence cannot be read.

  --If the file is not open  for  writing  or  for  update,  the  output
    sequence cannot be written.

  --A  joint file position is maintained for both the input sequence and
    the output sequence.

3 In order to support file I/O and multibyte/wide character  conversion,
  the following arrangement is applied to the traits structures:

  --Specify  char as the underlaid character type, uchar_type defined in
    the ios_conv_traits<>.

  --Define state_t, the template parameter of the ios_conv_traits<>,  so
    that  it  can apply to the conversion function.  In case the conver­
    sion function provided by the codecvt facet uses, we  adopt  a  spe­
    cialized  template  parameter stateT for the locale-oriented conver­
    sion function suitable for the multibyte/wide character  conversion.
    Now we assume the name of the conversion state object is fstate_t.

  --Define streamoff (or streampos ) as the repositional information for
    the underlaid byte sequence.

  --Define streamoff, wstreampos for the  wide-oriented  streambufs  (or
    filebufs)  so that some composite function in the ios_conv_traits(),
    for example:
        wstreampos get_pos(fstate_t fs, streampos s);
        wstreamoff get_off(fstate_t fs, streampos s);

  27.8.2.2  basic_filebuf constructors          [lib.basic.filebuf.cons]

  basic_filebuf();

  Effects:
    Constructs   an   object   of   class   basic_filebuf<charT,traits>,

    initializing  the  base  class with basic_streambuf<charT,traits>(),
    and initializing file to a null pointer.

    virtual ~basic_filebuf();

  Effects:
    Destroys an  object  of  class  basic_filebuf<charT,traits>.   Calls
    close().

  27.8.2.3  Member functions                       [lib.filebuf.members]

  27.8.2.3.1  basic_filebuf::is_open              [lib.filebuf::is.open]

  bool is_open() const;

  Returns:
    true if file is not a null pointer.

  27.8.2.3.2  basic_filebuf::open                    [lib.filebuf::open]

  basic_filebuf<charT,traits>* open(const char* s,
                                    ios_base::openmode mode);

  Effects:
    If  file  is not a null pointer, returns a null pointer.  Otherwise,
    calls  basic_streambuf<charT,traits>::basic_streambuf().   It   then
    opens  a  file,  if possible, whose name is the NTBS s, ``as if'' by
    calling fopen(s,modstr) and assigning the return value to file.

1 The NTBS modstr is determined from mode & ~ios_base::ate as  indicated
  in Table 17:

                        Table 17--File open modes

              +---------------------------------------------+
              |        ios_base            stdio equivalent |
              |        Value(s)                             |
              +---------------------------------------------+
              |in                          "r"              |
              |out | trunc                 "w"              |
              |out | app                   "a"              |
              |in | out                    "r+"             |
              |in | binary                 "rb"             |
              |out | trunc | binary        "wb"             |
              |out | app | binary          "ab"             |
              |in | out                    "r+              |
              |in | out | trunc            "w+"             |
              |in | out | app              "a+"             |
              |in | out | binary           "r+b"            |
              |in | out | trunc | binary   "w+b"            |
              |in | out | app | binary     "a+b"            |
              +---------------------------------------------+

2 If  the  resulting file is not a null pointer and mode & ios_base::ate
  != 0, calls fseek(file,0,SEEK_END).46)

3 If fseek returns a null pointer, calls  close()  and  returns  a  null
  pointer.  Otherwise, returns this.

  basic_filebuf<charT,traits>* open(const char* s, ios::open_mode mode);

  Returns:
    open(s, ios_base::openmode(mode)).

  27.8.2.3.3  basic_filebuf::close                  [lib.filebuf::close]

  basic_filebuf* close();

  Effects:
    If  file  is  a null pointer, returns a null pointer.  Otherwise, if
    the call fclose(file) returns  zero,  the  function  stores  a  null
    pointer in file and  returns  this.47)  Otherwise,  returns  a  null
    pointer.

  _________________________
  46) The  macro  SEEK_END  is  defined,  and  the  function  signatures
  fopen(const  char_type*, const char_type*) and fseek(FILE*, long, int)
  are declared, in <cstdio> (_lib.c.files_).
  47)  The  function  signature  fclose(FILE*)  is declared, in <cstdio>
  (_lib.c.files_).

  27.8.2.3.4  basic_filebuf::overflow            [lib.filebuf::overflow]

  //  virtual int_type overflow(int_type c = eof());    inherited

  Effects:
    Behaves   the  same  as  basic_streambuf<charT,traits>::overflow(c),
    except that the behavior of ``consuming a character'' is as follows:

  --(1)  Converting  the  characters  to  be consumed into the underlaid
    character sequence with the function traits::conv_traits::convout().
    During the conversion, convout maintains the conversion state in the
    member rdstate().  At the end of execution of  the  conversion,  the
    conversion state is saved on it.

  --(2)  The  result underlaid character sequence is written to the file
    specified by file.  At the consumption of  the  pending  characters,
    none  of them are discarded.  All of the characters are converted to
    be writted to the file.
  Returns:
    eof() to indicate failure.  If file is a null pointer, the  function
    always fails.

  27.8.2.3.5  basic_filebuf::pbackfail          [lib.filebuf::pbackfail]

  //  virtual int_type pbackfail(int_type c = eof());    inherited

  +-------                BEGIN BOX 34                -------+
  Check vs. _lib.streambuf::pbackfail_.
  +-------                 END BOX 34                 -------+

  Effects:
    Puts  back  the  character designated by c to the input sequence, if
    possible, in one of four ways:

  +-------                BEGIN BOX 35                -------+
  Because the parsing on the underlaid character sequence generally  can
  only  go  advance  or most of parsing machined cannot go back, some of
  the  basic_convbuf  implementations  cannot  ``put   back   characters
  directly to the associated input sequence.''  So the behaviors related
  to putting back the associated input stream are removed.
  +-------                 END BOX 35                 -------+

  --If c != eof() and if the function makes a putback position available
    and  if char_type(c) == char_type(gptr()[-1]), assigns gptr() - 1 to
    gptr().

  --If c != eof() and if the function makes a putback position available
    and  if the function is permitted to assign to the putback position,
    assigns c to *--gptr().

  --If c == eof() and  if  either  the  input  sequence  has  a  putback

    position  available  or the function makes a putback position avail­
    able, assigns gptr() - 1 to gptr().
  Returns:
    eof() to indicate failure, otherwise c.
  Notes:
    If file is a null pointer, the function always fails.
    The function does not put back a character  directly  to  the  input
    sequence.
    If  the  function  can succeed in more than one of these ways, it is
    unspecified which way is chosen.  The function can alter the  number
    of putback positions available as a result of any call.
  Default behavior:
    Returns traits::eof().

  +-------                BEGIN BOX 36                -------+
  Shall   we   impose  Library  uses  onto  performing  sync()...   make
  gbuffer/pbuffer empty every time they try to write after read or  vice
  versa, as in the current MSE?

  No.   On  systems  where  this is necessary the basic_filebuf virtuals
  should keep track of the last operation performed on the FILE  and  do
  whatever  is neccessary (equivalent of an fseek?)  in order to reverse
  the direction.
  +-------                 END BOX 36                 -------+

  27.8.2.3.6  basic_filebuf::showmany            [lib.filebuf::showmany]

  //  virtual int showmany();    inherited

  Effects:
    Behaves the same as basic_streambuf::showmany().
  Notes:
    An implementation might well provide an  overriding  definition  for
    this function signature if it can determine that more characters can
    be read from the input sequence.

  27.8.2.3.7  basic_filebuf::underflow          [lib.filebuf::underflow]

  //  virtual int_type underflow();    inherited

  Effects:
    Behaves the same as basic_convbuf<charT,traits>::underflow(), except
    that  the underlaid input character sequence is the byte sequence in
    the file specified by file.

  +-------                BEGIN BOX 37                -------+
  Describing the behavior about  maintaining  the  conversion  state  is
  needed.
  +-------                 END BOX 37                 -------+

  27.8.2.3.8  basic_filebuf::seekoff              [lib.filebuf::seekoff]

  //  virtual pos_type seekoff(off_type off, ios_base::seekdir way,
  //                           ios_base::openmode which
  //                             = ios_base::in
  //                             | ios_base::out);    inherited

  +-------                BEGIN BOX 38                -------+
  Check vs. _lib.stringbuf::seekoff_.
  +-------                 END BOX 38                 -------+

  Effects:
    Alters  the stream position within the controlled sequences, if pos­
    sible, as described below.
  Returns:
    a newly constructed pos_type object that stores the resultant stream
    position,  if  possible.   If the positioning operation fails, or if
    the object cannot  represent  the  resultant  stream  position,  the
    object stores an invalid stream position.

1 If  file  is  a null pointer, the positioning operation fails.  Other­
  wise, the function determines one of three  values  for  the  argument
  whence, of type int, as indicated in Table 18:

                        Table 18--seekoff effects

                   +----------------------------------+
                   |  way Value      stdio Equivalent |
                   +----------------------------------+
                   |basic_ios::beg   SEEK_SET         |
                   |basic_ios::cur   SEEK_CUR         |
                   |basic_ios::end   SEEK_END         |
                   +----------------------------------+

2 The  function  then calls fseek(file,off,whence) and, if that function
  returns nonzero, the positioning operation fails.48)

3 The function extracts the  conversion  state  from  off  by  means  of
  get_offstate() to reset the rdstate() member.

  27.8.2.3.9  basic_filebuf::seekpos              [lib.filebuf::seekpos]

  _________________________
  48) The macros SEEK_SET, SEEK_CUR, and SEEK_END are defined,  and  the
  function  signature  fseek(FILE*,  long, int) is declared, in <cstdio>
  (_lib.c.files_).

  //  virtual pos_type seekpos(pos_type sp,
  //                           ios_base::openmode which
  //                             = ios_base::in
  //                             | ios_base::out);    inherited

  +-------                BEGIN BOX 39                -------+
  [To Be Filled]

  Check vs. _lib.streambuf::seekpos_ and _lib.stringbuf::seekpos_.
  +-------                 END BOX 39                 -------+

  27.8.2.3.10  basic_filebuf::setbuf               [lib.filebuf::setbuf]

  //  virtual basic_streambuf* setbuf(char_type* s, int n);    inherited

  +-------                BEGIN BOX 40                -------+
  [To Be Filled]

  Check vs. _lib.streambuf::setbuf_ and _lib.stringbuf::setbuf_.
  +-------                 END BOX 40                 -------+

  27.8.2.3.11  basic_filebuf::sync                   [lib.filebuf::sync]

  //  virtual int sync();    inherited

  +-------                BEGIN BOX 41                -------+
  [To Be Filled]

  Check vs. _lib.streambuf::sync_.
  +-------                 END BOX 41                 -------+

  27.8.2.4  Template class basic_ifstream                 [lib.ifstream]
  namespace std {
    template <class charT, class traits = file_traits<charT> >
    class basic_ifstream : public basic_istream<charT,traits> {
    public:
      typedef charT            char_type;
      typedef traits::int_type int_type;
      typedef traits::pos_type pos_type;
      typedef traits::off_type off_type;
      int_type  eof()     { return traits::eof(); }
      char_type newline() { return traits::newline(); }

    public:
      basic_ifstream();
      basic_ifstream(const char* s, openmode mode = in);
      virtual ~basic_ifstream();
      basic_filebuf<charT,traits>* rdbuf() const;
      bool is_open();
      void open(const char* s, openmode mode = in);
  //  void open(const char* s, open_mode mode = in);    optional
      void close();
    private:
  //  basic_filebuf<charT,traits> fb;     exposition only
    };
  }

1 The    class   basic_ifstream<charT,traits>   is   a   derivative   of
  basic_istream<charT,traits> that  assists  in  the  reading  of  named
  files.   It  supplies  a basic_filebuf<charT,traits> object to control
  the associated sequence.

  +-------                BEGIN BOX 42                -------+
  For the sake of exposition, the maintained data is presented here as:

  --basic_filebuf<charT,traits> fb, the basic_filebuf object.
  +-------                 END BOX 42                 -------+

  27.8.2.5  basic_ifstream constructors        [lib.basic.ifstream.cons]

  basic_ifstream();

  Effects:
    Constructs an object of class basic_ifstream<charT,traits>, initial­
    izing the base class with basic_istream<charT,traits>(&fb).

    basic_ifstream(const char* s, openmode mode = in);

  Effects:
    Constructs  an object of class basic_ifstream, initializing the base
    class  with  basic_istream<charT,traits>(&fb),  then  calls  open(s,
    mode).

  27.8.2.6  Member functions                      [lib.ifstream.members]

  27.8.2.6.1  basic_ifstream::rdbuf                [lib.ifstream::rdbuf]

  basic_filebuf<charT,traits>* rdbuf() const;

  Returns:
    dynamic_cast<basic_filebuf<charT,traits>*>
    (basic_istream<charT,traits>::rdbuf()).

  27.8.2.6.2  basic_ifstream::is_open            [lib.ifstream::is.open]

  bool is_open();

  Returns:
    rdbuf().is_open().

  27.8.2.6.3  basic_ifstream::open                  [lib.ifstream::open]

  void open(const char* s, openmode mode = in);

  Effects:
    Calls rdbuf().open(s,mode).  If is_open() returns zero,  calls  set­
    state(failbit).

  27.8.2.6.4  basic_ifstream::close                [lib.ifstream::close]

  void close();

  Effects:
    Calls rdbuf().close() and, if that function returns zero, calls set­
    state(failbit).

  27.8.2.7  Template class basic_ofstream                 [lib.ofstream]
  namespace std {
    template <class charT, class traits = file_traits<charT> >
    class basic_ofstream : public basic_ostream<charT,traits> {
    public:
      typedef charT            char_type;
      typedef traits::int_type int_type;
      typedef traits::pos_type pos_type;
      typedef traits::off_type off_type;
      int_type  eof()     { return traits::eof(); }
      char_type newline() { return traits::newline(); }
    public:
      basic_ofstream();
      basic_ofstream(const char* s, openmode mode = out);
      virtual ~basic_ofstream();
      basic_filebuf<charT,traits>* rdbuf() const;
      bool is_open();
      void open(const char* s, openmode mode = out | trunc);
  //  void open(const char* s, open_mode mode = out | trunc);    optional
      void close();
    };
  }

1 The   class   basic_ofstream<charT,traits>   is   a   derivative    of
  basic_ostream<charT,traits>  that  assists  in  the  writing  of named
  files.  It supplies a basic_filebuf<charT,traits>  object  to  control
  the associated sequence.

  27.8.2.8  basic_ofstream constructors        [lib.basic.ofstream.cons]

  basic_ofstream();

  Effects:
    Constructs an object of class basic_ofstream<charT,traits>, initial­
    izing the base class with basic_ostream<charT,traits>(&fb).

    basic_ofstream(const char* s, openmode mode = out);

  Effects:
    Constructs an object of class basic_ofstream<charT,traits>, initial­
    izing  the  base  class  with basic_ostream<charT,traits>(&fb), then
    calls open(s, mode).

  27.8.2.9  Member functions                      [lib.ofstream.members]

  27.8.2.9.1  basic_ofstream::rdbuf                [lib.ofstream::rdbuf]

  basic_filebuf<charT,traits>* rdbuf() const;

  Returns:
    (basic_filebuf<charT,traits>*)&fb.

  27.8.2.9.2  basic_ofstream::is_open            [lib.ofstream::is.open]

  bool is_open();

  Returns:
    rdbuf().is_open().

  27.8.2.9.3  basic_ofstream::open                  [lib.ofstream::open]

  void open(const char* s, openmode mode = out);

  Effects:
    Calls rdbuf().open(s,mode).  If is_open() is then false, calls  set­
    state(failbit).

  27.8.2.9.4  basic_ofstream::close                [lib.ofstream::close]

  void close();

  Effects:
    Calls rdbuf().close() and, if that function returns zero, calls set­
    state(failbit).

  27.8.3  C Library files                                  [lib.c.files]

1 Headers <cstdio>, and <cwchar>.

                    Table 18--Header <cstdio> synopsis

  +-------------------------------------------------------------------------------+
  |    Type                                   Name(s)                             |
  +-------------------------------------------------------------------------------+
  |Macros:                                                                        |
  |BUFSIZ         L_tmpnam        SEEK_SET   TMP_MAX                              |
  |EOF            NULL <cstdio>   stderr     _IOFBF                               |
  |FILENAME_MAX   SEEK_CUR        stdin      _IOLBF                               |
  |FOPEN_MAX      SEEK_END        stdout     _IONBF                               |
  +-------------------------------------------------------------------------------+
  |Types:         FILE            fpos_t     size_t <cstdio>                      |
  +-------------------------------------------------------------------------------+
  |Functions:                                                                     |
  |clearerr       fgets           fscanf     gets              rewind    tmpfile  |
  |fclose         fopen           fseek      perror            scanf     tmpnam   |
  |feof           fprintf         fsetpos    printf            setbuf    ungetc   |
  |ferror         fputc           ftell      putc              setvbuf   vprintf  |
  |fflush         fputs           fwrite     puts              sprintf   vprintf  |
  |fgetc          fread           getc       remove            sscanf    vsprintf |
  |fgetpos        freopen         getchar    rename            tmpfile            |
  +-------------------------------------------------------------------------------+

                    Table 18--Header <cwchar> synopsis

  +------------------------------------------------------------------------+
  |  Type                               Name(s)                            |
  +------------------------------------------------------------------------+
  |Macros:    NULL <cwchar>   WCHAR_MAX   WCHAR_MIN   WEOF <cwchar>        |
  +------------------------------------------------------------------------+
  |Types:     mbstate_t       wint_t <cwchar>                              |
  +------------------------------------------------------------------------+
  |Struct:    tm <cwchar>                                                  |
  +------------------------------------------------------------------------+
  |Functions:                                                              |
  |btowc      getwchar        ungetwc     wcscpy      wcsrtombs   wmemchr  |
  |fgetwc     mbrlen          vfwprintf   wcscspn     wcsspn      wmemcmp  |
  |fgetws     mbrtowc         vswprintf   wcsftime    wcsstr      wmemcpy  |
  |fputwc     mbsinit         vwprintf    wcslen      wcstod      wmemmove |
  |fputws     mbsrtowcs       wcrtomb     wcsncat     wcstok      wmemset  |
  |fwide      putwc           wcscat      wcsncmp     wcstol      wprintf  |
  |fwprintf   putwchar        wcschr      wcsncpy     wcstoul     wscanf   |
  |fwscanf    swprintf        wcscmp      wcspbrk     wcsxfrm              |
  |getwc      swscanf         wcscoll     wcsrchr     wctob                |
  +------------------------------------------------------------------------+

2 The contents are the same as the Standard C library, except that  none
  of the headers defines wchar_t.  SEE ALSO:

  ISO C subclause 7.9, Amendment 1 subclause 4.6.2.