Liren Large Software Subsidy 7

home *** CD-ROM | disk | FTP | other *** search

/ Liren Large Software Subsidy 7 / 07.iso / c / c021 / 8.img / DOC.ZIP / OLDSTR.DOC < prev next >

Wrap

Text File | 1990-05-04 | 36.7 KB | 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