Power-Programmierung/CD2.mdf/c/tcpp/oldstr.doc

Text File | 1990-06-09 | 38KB | 1,108 lines

HOW TO USE THIS FILE: This file has a table of contents and
an index that refer to "pages" in this file. If your editor
has a search facility, you can use it to search for the page
numbers listed in either the table of contents or in the index.
The phrase "Page n" (where n represents the actual page number)
appears at the bottom left of the "page" it refers to. Thus, at
the bottom of page 1, you'll find "Page 1" as the last item on
that "page."

                   C++ VERSION 1.2 STREAMS
                      TABLE OF CONTENTS
___________________________________________________________________

Overview                       1       Get functions . . . . . .  8
Output . . . . . . . . . . . . 1       Putback (function)  . . .  8
  Built-in types . . . . . . . 2       Controlling whitespace
  Put functions  . . . . . . . 2       skipping  . . . . . . . .  9
  Built-in formatting                User-defined types  . . . . 10
  functions  . . . . . . . . . 2     Initializing streams  . . . 10
    Numeric conversion . . . . 3     Output streams  . . . . . . 10
    Character string                 Input streams . . . . . . . 11
    conversion . . . . . . . . 4   File I/O  . . . . . . . . . . 12
    General Formatting . . . . 5   Buffering streams . . . . . . 15
  User-defined types . . . . . 6   String I/O  . . . . . . . . . 16
Input  . . . . . . . . . . . . 6   Stream states . . . . . . . . 18
  Built-in types . . . . . . . 7
  Controlling whitespace . . . 7   Index                         19


OVERVIEW

This file describes C++ version 1.2 stream I/O. If you are planning
to program using or converting over to version 2.0 streams, see
Chapter 3, "C++ streams," in the Programmer's Guide.

Stream I/O in C++ is used to convert typed objects into readable text,
and vice-versa. It provides an easier and more intelligent alternative
to printf and scanf, and allows you to define input/output functions
which are then used automatically for corresponding user-defined
types. To access stream I/O, use the directive #include <stream.h>.

C++ programs start with three predefined open streams. These are
called cin, cout, and cerr. They correspond to the standard input,
output and error (stdin, stdout, and stderr) files of standard I/O
in C. You can reassign these standard names to other files or
character buffers after program startup.


Output

Stream output is accomplished via the << (put to) operator, which
is overloaded for stream output. Its left operand is an object
whose type is class ostream. Its right operand is any type for
which stream output has been defined (more about this later).
Stream output is predefined for built-in types. For example,

   cout << "Hello\n"

writes the string "Hello" to cout (normally the standard output
file) followed by a newline.

The << operator binds left to right and returns its left operand,
so that several output operations may be combined in one statement.
For example,

  void function display(int i, double d)
  {
     cout << "i = " << i << ", d = " << d << "\n";
  }

Page 1

will write something like

   i = 8, d = 2.34

to standard output.


  Built-in types

The types directly supported for output, as in the example above,
are the built-in types char (both signed and unsigned), short, int,
long, char * (treated as a string), float, long double, and double.
Integral types are converted according to the default rules for the
ANSI C function printf. That is, for example, given the declara-
tions int i; long l;, the two statements

  cout << i << " " << l;
  printf("%d %ld", i, l);

produce the same result.

Similarly, floating-point types are converted according to the
default rules for the %g conversion. That is, for example, given
the declaration double d, the statements

  cout << d;
  printf("%g", d);

produce the same result. With character types,

  cout << 'a';

produces a, not 97.


   Put functions

The member function

   ostream& ostream::put(char c);

writes the character c to an ostream as a character.


        Built-in
      formatting
       functions

The following functions are defined in stream.h to aid in output
formatting. Each of these functions returns a pointer to a string
stored in a circular, or cyclical, static buffer. The buffer is
large enough to support reasonable sequences of output conversions,

Page 2

but the pointers returned should not be saved for later use--the
characters they point to may change in the meantime.


         Numeric
      conversion

Here are the three numeric conversion functions:

  char * dec(long val, int width = 0);

  char * hex(long val, int width = 0);

  char * oct(long val, int width = 0);

Each of these functions takes an integral value val and returns a
pointer to a string corresponding to its decimal, hexadecimal, or
octal representation. The optional width parameter specifies the
number of characters in the returned string. If you omit this pa-
rameter or set it to zero, the exact number of characters required
will be used. Otherwise the string will be truncated on the right
or blank-filled on the left as needed.

Note that each of the statements

  cout << i;
  cout << dec(i);
  cout << dec(i, 0);

produce identical results.


ANSI C equivalent

The numeric conversion routines have equivalents in ANSI C. For
example, the C++ statement

   cout << dec(val, width);

is equivalent to the ANSI C statement

  (width==0 ?
     printf("%ld", (long) val) :    /* convert to natural length */
     (sprintf(t, "%ld", (long) val),     /* else convert and */
     printf("%*.*s, width, width, t)));  /* possibly truncate */

where t is a temporary character array. C++ does not strictly
follow the ANSI printf conventions. In particular, passing a
negative value for width is the same as passing 0, unlike printf,
which takes a negative width value with * as a left-justify flag
(-), followed by a positive width.

Page 3

The hex and oct routines have similar equivalents, using the printf
%lx and %lo conversions, respectively.


Character string
      conversion

Here are the two character string conversion functions:

  char * chr(int ch, int width = 0);
  char * str(const char *s, int width = 0);

Function chr returns a pointer to a string version of the input
character value. Function str takes a string pointer and returns a
string pointer. For both functions, the optional width parameter
specifies the number of characters in the returned string. If this
parameter is omitted or is zero, the exact number of characters
required will be used. Otherwise the string will be truncated on
the right or blank-filled on the left as needed.

For example, the expressions

  chr(0)
  str("")

are equivalent, and each returns an empty string.

Function chr is the third way to print a character as a character.
The previous example using the put function (on page 2) could also
be written as

   cout << int('A') << " represents " << chr('A');

again resulting in "65 represents A".

Function str called with no width parameter (or with a 0 width)
returns a copy of the input string, but one with an undependable
lifetime. If it is called with width greater than 0, it returns a
string of the specified size, appropriately truncated or blank-
padded.


C equivalent

These string conversion routines have equivalents in C. The
following pairs of expressions are equivalent.

Page 4

___________________________________________________________________

  C++                       C
___________________________________________________________________

  cout << chr(ch, width);   (width==0 ?
                              printf("%c", ch) :
                              printf("%*c", width, ch));


  cout << str(s, width);    (width==0 ?
                              (void) printf("%s", s) :
                              (void) printf("%*.*s",
                                            width, width, s));
___________________________________________________________________


         General
      Formatting

This function provides general formatting:

   char * form (char * format ...);

As with the other conversion functions, it returns a pointer to a
static area which could be overwritten at a later time.

ANSI C equivalent

The form function is essentially the same as the ANSI C sprintf
function. The two differences are in the calling sequence.

1. The first argument of sprintf is a pointer to a character vector
   to be written; form omits this argument and uses a static circu-
   lar buffer instead.

2. sprintf returns the number of characters written; form returns a
   pointer to the output character vector.

The form function can thus be used as part of an output specifica-
tion where the basic formatting is not adequate. For example:

   cout << "pi = " << form ("%1.10f", pi); // show 10 decimal
places

The format string and additional parameters (if any) to form are
identical to those of sprintf. A C++ expression like

   form (format, params)

is equivalent to the ANSI C expression

   (sprintf(s, format, params), s)

Page 5

where s is a static character vector. Refer to the definition of
sprintf in the Reference Guide for further details.


    User-defined
           types

You can write your own output functions for your own defined types
simply by further overloading the << operator. For example, suppose
you have a type

  typedef struct {
     char *name;
     double val;
     char *units;
  } info;

You could then define a function

  ostream& operator << (ostream& s, info& m)
  {
     s << m.name << " = " << m.val << " " << m.units;
     return s;
  }

Then a simple reference such as

   cout << m;

would produce output like "capacity = 1.25 liters".


Input

Stream input is accomplished via the >> (get from) operator, which
is overloaded for stream input. Its left operand is an object whose
type is class istream. Its right operand is any type for which
stream input has been defined. Stream input is predefined for
built-in types.

The >> input operator skips whitespace (as defined by the isspace
function in ctype.h), then reads in characters appropriate to the
type of the input object. (Actually, whitespace skipping can be
turned off; this is described below.)

The >> operator binds left to right and returns its left operand,
so that several input operations can be combined in one statement.
For example, consider

  int i;
  double d;
  cin >> i >> d;

Page 6

This statement will cause whitespace to be skipped, digits read in
and converted to internal binary form and saved in variable i, more
whitespace to be skipped, and finally a floating-point number read
in and saved in variable d.


  Built-in types

For types short, int, and long, the effect of operator >> is to
skip whitespace and convert an integral value, reading input char-
acters until one is found which cannot be part of the representa-
tion of the type. The format of integral values recognized is the
same as that of integer constants in C++, excluding integer
suffixes. That is, a leading 0x or 0X denotes hexadecimal
representation, a leading 0 not followed by x or X denotes octal
representation, and a leading 1 through 9 denotes decimal
representation. A trailing l, L, u, or U is not part of the value
and is not removed from the input stream.

For types float and double, the effect of operator >> is to skip
whitespace and convert a floating-point value, reading input
characters until one is found which cannot be part of a floating-
point representation. The format of floating-point values recog-
nized is the same as that of floating-point constants in C++,
excluding floating suffixes. That is, a trailing f, F, l, or L is
not part of the value and is not removed from the input stream.

For all numeric types, if the first non-whitespace character is not
a sign or digit (or decimal point for floating-point conversion),
the stream enters the _fail state (described on page 18) and no
further input will be done until the condition is cleared.

For type char, the effect of operator >> is to skip whitespace and
store the next (non-whitespace) character.

For type char * (treated as a string), the effect of operator >> is
to skip whitespace and store the next (non-whitespace) characters
until another whitespace character is found.

In all cases, if end of input occurs before any non-whitespace
character is found, nothing is stored in the target object. That
is, if the target was uninitialized, it will still be
uninitialized.


     Controlling
      whitespace

A whitespace character is one for which function isspace (in
ctype.h) returns a nonzero value. These are presently the blank
(' '), tab (\t), carriage-return (\r), newline (\n), formfeed (\f),
and vertical tab (\v).

Page 7

A standard object called WS of type struct whitespace is predefined
as a "sink" for (place to discard) whitespace characters. For
example,

   cin >> WS;

will skip consecutive whitespace characters from the standard
input. The next character input will not be whitespace. This is
useful in routines reading user-defined types in conjunction with
one of the get member functions, or when skipping is turned off. We
discuss this in more detail later.


   Get functions

As noted above, the >> operator for built-in types reads and
discards whitespace. The two get member functions in class istream
provide a way to read and process whitespace characters.

1. istream& istream::get (char& c);

   This function reads the next character, whatever it is, into its
   parameter.

2. istream& istream::get (char *buf, int max, int term='\n');

   This function reads characters from the input stream into the
   character vector pointed to by buf until max characters have
   been read, or until the character term has been encountered,
   whichever comes first. The default termination character (which
   need not be specified) is the newline. The termination character
   is not part of the characters read, and is not removed from the
   input stream. The character vector buf must be larger than max,
   since it must also hold the terminating null.

   If we simply use s >> p instead, we would not be able to control
   the number of characters read nor the termination character.

These are member functions, and so must be called in relation to
the input stream they are to read. See the example in the next
section.


         Putback
      (function)

The member function

   void istream::putback(char c);

Page 8

pushes back one character into the input stream. putback pushes
back one (and only one) character onto the input stream; extras are
silently ignored. You cannot push back EOF.

Here is a simple routine which reads a C++ style identifier.

  void getident (char *s /* where to put ident */)
  {
     char c = 0;                     // guard against EOF

     cin >> c;                       // skips leading whitespace
     if (isalpha(c)  ||  c == '_')
         do {
            *s++ = c;
            c = 0;                   // guard against EOF
            cin.get(c);
         } while (isalnum(c) ||  c == '_');
     *s = 0;                         // terminate the string
     if (c)
        cin.putback(c);              // we always get one too many
  }


     Controlling
      whitespace
        skipping

Input streams skip whitespace by default. However, you can
initialize an input stream to not skip whitespace. In addition, you
can turn the skipping on and off via the member function

   int istream::skip (int doskip);

This function turns off the whitespace skipping state if parameter
doskip is zero, and turns it on otherwise. It returns the previous
skipping state.

When whitespace skipping is off, default input to the numeric,
character, and string types will fail if the next input character
is whitespace. Sending input to the WS object will discard
whitespace.

For example, suppose you want special processing for fields which
are separated by nonblank whitespace, such as tabs and newlines,
and normal processing for fields separated by blank characters.

  char string[MAX], c;
  int old_skip = cin.skip(0);     // skipping off
  while (cin.good()) {
     do {
      cin.get(c);

Page 9

     }  while (c == ' ');        // skip blank characters
     if (isspace(c))
        special();                // nonblank whitespace
     else {
        cin.putback(c);           // replace printable character
        cin >> string;            // get field and process
        process(string);
     }
  }
  cin.skip(old_skip);             // restore old skip state


    User-defined
           types

You can write your own input functions for your own defined types
in the same way as for output functions. Here is a simple example
with no error checking to read in type info defined above.

  istream& operator >> (istream& s, info& m)
  {
     s >> m.name >> m.val >> m.units;
     return s;
  }

An input line of text like "capacity 1.25 liters" can then be read
with a simple reference like

   cin >> m;


    Initializing
         streams

The streams cin, cout, and cerr are initialized and open at program
start, and are connected to, respectively, the standard input,
standard output, and standard error files.

Initializing (constructing) a stream means associating it with a
stream buffer. We discuss input and output streams separately.


  Output streams

Class ostream provides these three constructors.

1. ostream::ostream (streambuf *s);

   This associates a named output stream with a stream buffer
   (class streambuf or its derived classes, such as class filebuf).

Page 10

2. ostream::ostream (int fd);

   This associates a named output stream with a file already
   opened, and assigns a stream buffer to it. The normal use for
   this is first to open a file as described below, and then imme-
   diately to initialize a stream associated with it.

3. ostream::ostream (int size, char *buf);

   This associates a named output stream with a character vector.
   All "output" to the stream will be written to the vector. This
   is described below.

The destructor for class ostream

  ostream::~ostream()

flushes the output stream via the member function

  ostream::flush()

You can also call this member function explicitly if you want, as
in this example:

   cout << stuff; cout.flush();


   Input streams

Class istream provides these three constructors.

1. istream::istream (streambuf *s, int skip = 1, ostream *t = 0);

   This associates a named input stream with a stream buffer (class
   streambuf).

   Optional parameter skip specifies whether whitespace should be
   skipped in input operations. The default is to skip.

   Optional parameter t specifies an output stream to which this
   input stream should be "tied". When two streams are tied, the
   output stream is always flushed before anything is read from the
   input stream. Standard streams cin and cout are tied.

2. istream::istream (int fd, int skip = 1, ostream *t = 0);

   This associates a named input stream with a file already opened,
   and assigns a stream buffer to it. The normal use for this is
   first to open a file as described below, and then immediately to
   initialize a stream associated with it.

   The optional skip and t parameters are as described above.

Page 11

3. istream::istream (int size, char *buf, int skip = 1);

   This associates a named input stream with a character vector.
   All "input" from the stream will be read from the vector, as
   described below.

   The optional skip parameter is as described above.

Class istream includes member function

   ostream * istream::tie (ostream *to);

Calling tie with the address of an output stream ties these two
streams together. Only one output stream may be tied to an input
stream. Calling tie again with a different output stream breaks the
previous tie and establishes a new one. Calling tie again with the
same output stream has no effect. Calling tie with an argument of
zero breaks the tie and associates no output stream with the input
stream.

Function tie returns the output stream previously associated, or
zero if there was none. For example, cin and cout are tied by
default. The statement

   ostream *old_tie = cin.tie(0);

breaks the tie and allows asynchronous input and output with cin
and, presumably, cout. The statement

   cin.tie(old_tie);

re-establishes the previous tie (presumably to cout) and ensures
that pending output is flushed before any input is requested from
cin. If cin and cout are connected to the user's terminal, you
would want them tied so that an output prompt would always appear
on the terminal before input was attempted.


File I/O

Apart from the files associated with standard streams cin, cout,
and cerr, you can associate an external file with class filebuf,
derived from class streambuf. Once you do this, you can associate
this file buffer with a stream to accomplish stream I/O on the
file.

Class filebuf has these four constructors:

1. filebuf::filebuf();

   This only allocates a file buffer, without yet tying it to an
   external file.

Page 12

2. filebuf::filebuf (FILE *f);

   This associates a file buffer with an ANSI C standard I/O file
   already open. This allows you to mix C standard I/O with stream
   I/O in the same program. In the present implementation, all file
   I/O is done via C standard I/O; in fact, using filebuf::open()
   creates a C standard I/O file.

3. filebuf::filebuf (int fd);

   This associates a file buffer with a file already open, such as
   via the library function open. If input or output has already
   taken place on this file, it is not guaranteed that further I/O
   will work as desired. Stream I/O can't be mixed with low-level
   read and write functions in particular.

4. filebuf::filebuf (int fd, char *buf, size len);

   As above, this associates a file buffer with a file already
   open. It further uses the supplied buffer specified by buf and
   len for any file buffering, rather than allocating its own
   buffer.

The class destructor, filebuf::~filebuf(), invokes member function
close, described below. Class filebuf includes the following five
public member functions:

1. filebuf * filebuf::open (char *name, open_mode om);

   This member function opens a named file according to enumerated
   type open_mode. It returns a pointer to the filebuf on success,
   or zero on error.

   Type open_mode is defined by enumerated type open_mode as
   follows:

     enum open_mode { input, output, append };

   Mode append is for extending an existing output file. There is
   no way to open a stream for both input and output (update mode).

2. int filebuf::close();

   This member function closes the associated file and does any
   other housekeeping actions required. It returns zero if the file
   was closed successfully, and nonzero otherwise.

3. virtual int filebuf::snextc();

   This gets and returns the next character from the input stream
   buffer, or returns EOF on end of input.

Page 13

4. virtual int filebuf::sputc (int c);

   This writes c, converted to a char, to the output stream buffer.
   It returns C if successful, EOF on error.

5. virtual void filebuf::sputbackc(char c);

   This pushes back one character into the (input) stream buffer.
   You can always push back at least one character before reading a
   character again. If you try to push back too many characters,
   the extras are silently ignored. You cannot push back EOF. (That
   is, the attempt to push back EOF is ignored.)

Associating a named file with a stream normally follows a sequence
such as this:

  #include <stream.h>
  filebuf inf;
  if (inf.open(name, input) == 0) {
     ...error condition: exit
  }
  istream indata(&inf);

  filebuf outf;
  if (outf.open(name, output) == 0) {
     ...error condition: exit
  }
  ostream outdata(&outf);

If, for example, the input file were already open, we could replace
the first part of the code with

  extern int fd;
  filebuf inf(fd);
  istream indata(&inf);

Be sure to call open to set up fd. Don't confuse open and
filebuf::open.
Or even more simply:

  extern int fd;
  istream(fd);

which includes allocating the file buffer.

Alternatively, we could open either file as a C standard I/O file.

  FILE *f;
  if ((f = fopen(name, "r")) == 0) {
     ...error condition: exit
  }
  filebuf inf(f);

Page 14

  istream indata(&inf);

Finally, suppose a file has already been opened for C standard I/
 O. We can associate a stream buffer with it like this:

  extern FILE *f;
  filebuf inf(f);
  istream indata(&inf);


Buffering streams

Streams implement buffered text I/O. A stream is always associated
with a stream buffer, which is an object of class streambuf. This
class provides the basic buffering mechanisms independent of the
kind of device which might be physically associated with the
stream.

Class streambuf has the following two constructors:

1. streambuf::streambuf();

   This only allocates a streambuf, with no buffer space reserved.

2. streambuf::streambuf (char *buf, int len);

   This allocates a streambuf, using the given buffer address and
   length. This is particularly useful for a stream attached to a
   string.

Class streambuf has the following two protected member functions.
These are available for use by derived classes, but not by ordinary
user functions. (Notice that equivalent functions are provided by
derived classes istream and ostream where appropriate.)

1. int streambuf::allocate();

   This allocates a 512 byte buffer (via new) for use by this
   stream if one has not already been allocated. It returns zero if
   all is well, and EOF to indicate that no buffer could be
   allocated. If this mechanism allocates a buffer, the buffer is
   automatically deleted by the class destructor
   streambuf::~streambuf().

2. streambuf * streambuf::setbuf(char *buf, int len,
   int offset = 0);

   This assigns a user-supplied buffer to the streambuf. Any
   previously-assigned buffer is disassociated. If the previous
   buffer had been assigned via the allocate mechanism, it is
   deleted. The optional parameter offset specifies where the next
   free byte in the buffer is located. This allows a full or

Page 15

   partially full buffer to be assigned to a streambuf, and is the
   only way for a string to be usefully assigned to an input
   stream. This member function always returns the streambuf.

The following three virtual functions are also protected:

1. virtual int streambuf::overflow(int c = EOF);

   The derived class is responsible for providing a suitable
   function for overflow. The overflow function should empty the
   stream buffer, place c in the buffer, and return c, except
   return EOF. This member function cannot empty a buffer (since
   there is no place to put the data), so it just returns EOF.

2. virtual int streambuf::underflow();

   The derived class is responsible for providing a suitable
   function for underflow. This function always returns EOF.

3. virtual void streambuf::terminate();

   This routine terminates the buffer with a null byte without
   advancing the pointer.

The following three virtual functions are public.

1. virtual int streambuf::snextc();

   This gets and returns the next character from an input stream
   buffer, or EOF on end of input.

2. virtual int streambuf::sputc (int c);

   This writes c, converted to a char, to an output stream buffer.
   It returns c if ok, EOF on error.

3. virtual void streambuf::sputbackc(char c);

   This pushes back one character into the (input) stream buffer.
   You can always push back at least one character before reading a
   character again. If you try to push back too many characters,
   the extras are silently ignored. You cannot push back EOF.


String I/O

You can tie an input or output stream to a character vector instead
of a file. For input, the null byte terminating the string is taken
as end of file. For output, the ostream mechanism knows how big the
vector is, and will never write past the end.

Page 16

For input, an initializing part of a program can tie the input
stream to standard input, to a file, or to a string, and the rest
of the program simply does stream I/O without needing to know the
source of the input.

For output, a string can be formatted by a hierarchy of routines
which do not need to know whether they are writing to a file or to
a string, and which do not need to keep track of the current end of
the string or check for overflow.

In the following example, the main program can be invoked with a
literal string to process (flagged by "-" as the first program
parameter), with one or more file names to process, or with no
arguments, signifying that standard input is to be processed.

  #include <stream.h>

  // function "process" deals only with input streams,
  // regardless of the actual source
  void process (istream&);

  main (int argc, char *argv[])
  {
     if (argc == 1) {
        // no name given: use standard input
        process(cin);
     }
     else if (argc == 3 && strcmp(argv[1], "-") == 0) {
        // use the string
        istream inp(strlen(argv[2]), argv[2]);
        process(inp);
     }
     else {
        for (int i = 1;  i < argc;  ++i) {
           // process each file name
           filebuf f; // new filebuf each iteration
           if (f.open(argv[i], input) == 0) {
              cerr << "Can't open " << argv[i] << '\n';
           }
           else {
              istream inp(&f); // new istream each iteration
              process(inp);
           }
           // automatically close and destruct at end of each
  iteration
        }
     }
  }

Page 17

Stream states

Each istream and ostream has a "state" associated with it, along
with public member functions to read and change the state. The
state is defined by enumerated type stream_state as follows:

   enum stream_state { _good, _eof, _fail, _bad };

Don't rely on any particular numerical values for these state
names.

State _good means that the last I/O operation succeeded, and the
next one might succeed. State _eof means that no more input is
available from an input stream. State _fail means that the last
operation failed, and no further operations will succeed (no I/O
will be attempted once the _fail state is reached). State _bad
means that not only is the stream in a failed state, but that the
stream has been corrupted, meaning characters were lost.

The following five member functions are defined for both class
istream and ostream for testing the state:

1. enum stream_state rdstate();   // return the state

2. int eof();                     // return nonzero if _eof

3. int fail();                    // return nonzero if _failed or
   _bad

4. int bad();                    // return nonzero if _bad

5. int good();                   // return nonzero if _good

The following member function can be used to set the state of a
stream. The default is to set the state to _good. Obviously, you
should use this function with care.

   void clear (enum stream_state val = _good);

Finally, you can test a stream itself, with a nonzero return only
if the state is _good. This allows loops like

  // process each item in file
  while (cin >> val)
     process(val);

or

  // copy file, stripping all whitespace
  char str[BIG_ARRAY];
  while (cin >> str)
     if (! (cout << str))
        break;               // error in output

Page 18
___________________________________________________________________

INDEX

>> (get from) operator                input 6-12
  concatenation 6                       data types supported 7
  overloading                           user-defined 10
    user-defined types and 10         member functions
<< (put to) operator                    pushing characters into
  concatenation 1                       input stream 8
  overloading                           put 2
    user-defined types and 6            putback 8
<< operator                             skip 9
  streams and 1                       numbers
>> operator                             converting
  streams and 6                           ANSI C and 3
                                        converting and conversions
                                        3
A                                         C++ 3
allocate (member function) 15         operators
ANSI                                    >> (get from)
  C standard                              overloading 10
    C++ numeric conversion                streams and 6
    routines and 3                      << (put to)
    C++ string conversion                 concatenation 1
    routines and 4                        overloading 6
ASCII codes                               streams and 1
  printing as characters              operators (get from)
    C++ 2                               >>
                                          concatenation 6
                                      output 1-6
C                                       data types supported 2
C++                                     formatting 2
  characters                            user-defined 6
    converting 4                      streams
      C and 4                           << operator and 1
  concatenation                         >> operator and 6
    << (get from) operator 1            buffering 15-16
    >> (put to) operator 6              cout
  constructors                            printf and 2
    filebuf 12                          initializing 10-12
    istream and ostream 10, 11          using 1-19
    streambuf 15                      strings
  destructors                           converting 4
    ~filebuf 13                           C and 4
  files                                 input and output 16-17
    input and output 12-15            whitespace in
  identifiers                           controlling 7
    reading 9

Page 19

characters                          D
  converting                        data types
    C++ 4                             C++
  input                                 input and 7
    C++ 7, 8                            output and 2
  output
    C++ 2
  pushing onto C++ input stream     F
    8                               floating point
classes                               input
  filebuf                               C++ 7
    close member function 13          output
    constructors 12                     C++ 2
    destructor 13                   form (function)
    open member function 13           sprintf and 5
    snextc member function 13       format specifiers
    sputbackc member function         C++ and 2
    14                              formatting
    sputc member function 14          C++
  istream and ostream                   form function and 5
    constructors 10, 11                 output 2
    member functions 18
    states 18
    tie member function 12          I
  streambuf 15                      integers
    allocate member function 15       input
    constructors 15                     C++ 7
    overflow member function 16       output
    setbuf member function 15           C++ 2
    snextc virtual member
    function 16
    sputbackc virtual member        O
    function 16                     open (member function) 13
    sputc virtual member            overflow
    function 16                       member function 16
    terminate virtual member
    functions 16
    underflow virtual member        P
    functions 16                    printf (function)
close (member function) 13            cout and 2
conversions                         putback (member function) 8
  C++ 3
    ASCII code to characters 2
  character                         S
    C++ 4                           setbuf (member function) 15
  numeric                           skip (member function) 9
    C++ 3                           snextc (member function) 13, 16
  strings                           sprintf (function)
    C++ 4                             form function and 5
                                    sputbackc (member function) 14,
                                      16
                                    sputc (member function) 14, 16

Page 20

strings                             U
  converting                        underflow
    C++ 4                             member function 16


T                                   W
terminate (member function) 16      whitespace
tie (member function) 12              C++ and 7
                                        skipping 9

Page 21