Parameterized_manipulators
 Each of these manipulators takes a single argument, operates on it
 as described, and returns it.

Additional Information on:

filebuf
 This class specializes the streambuf class to use a file as a
 repository of characters. Writing to the file consumes characters;
 reading from the file produces characters. Files that allow searches
 are said to be seekable. When a file is readable and writable, the
 filebuf object permits character insertion and extraction.

 Header:

	#include <fstream.hxx>

fstream
 This class specializes the class iostream to files using a filebuf
 object to do the input and output. Your program can perform common
 operations, such as opening and closing files, without explicitly
 mentioning filebuf objects.

 Header:

	#include <fstream.hxx>

ifstream
 This class specializes the class istream to files using a filebuf
 object to do the input. Your program can perform common operations,
 such as opening and closing files, without explicitly mentioning
 filebuf objects.

 Header:

	#include <fstream.hxx>

ios
 Classes derived from the ios class provide an interface for
 transferring formatted and unformatted information into and out of
 streambuf objects.

 Header:

	#include <iostream.hxx>

Additional Information on:

iostream
 This class combines the classes istream and ostream. You use it to
 carry out bidirectional operations (inserting into and extracting from
 a single sequence of characters).

 Header:

	#include <iostream.hxx>

iostream_withassign
 This class adds an assignment operator and a constructor with no
 operands to the iostream class.

 Header:

	#include <iostream.hxx>

istream
 This class provides facilities for formatted and unformatted
 extraction from streambuf objects.

 Header:

	#include <iostream.hxx>

istream_withassign
 This class adds an assignment operator and a constructor with no
 operands to the istream class.

 Header:

	#include <iostream.hxx>

istrstream
 This class specializes the istream class to perform extractions from
 arrays of bytes in memory.

 Header:

	#include <strstream.hxx>

ofstream
 This class specializes the class ostream to files using a filebuf
 object to do the output. Your program can perform common operations,
 such as opening and closing files, without explicitly mentioning
 filebuf objects.

 Header:

	#include <fstream.hxx>

ostream
 Objects of this class perform formatted and unformatted insertions
 into streambuf objects.

 Header:

	#include <iostream.hxx>

ostream_withassign
 This class adds an assignment operator and a constructor with no
 operands to the ostream class.

 Header:

	#include <iostream.hxx>

ostrstream
 This class specializes the ostream class to perform insertions into
 arrays of bytes in memory.

 Header:

	#include <strstream.hxx>

stdiobuf
 This class specializes the streambuf class for stdio FILEs. It uses
 unbuffered mode, which causes all operations to be reflected immediately
 in the FILE.

 Header:

	#include <stdiostream.hxx>

stdiostream
 This class specializes the ios class for stdio FILEs; it also
 specializes the ios class to use stdiobuf as its associated streambuf.

 Header:

	#include <stdiostream.hxx>

streambuf
 This class supports buffers into which you can insert (put) or extract
 (get) characters. It contains only the basic members for manipulating
 the characters. To implement the functions of this class, use a
 class derived from the streambuf class.

 The protected members of this class present an interface to the
 derived classes organized around the get, put, and reserve areas
 (arrays of bytes), which are managed cooperatively by the base and
 derived classes.

 The reserve area is a sequence of characters with an associated get
 pointer, put pointer, or both. This area serves mainly as a resource
 in which to allocate space for the put and get areas.  As characters
 enter and exit the reserve area, the put and get areas change but the
 reserve area remains fixed. A collection of character pointer values
 defines the three areas. These pointers infer a boundary condition;
 therefore, it may be helpful to consider such pointers as pointing
 just before the byte but they actually point right at it.

 Classes derived from streambuf vary in their handling of the get and
 put pointers. The simplest are unidirectional buffers that permit only
 get and put operations. Such classes serve as producers and consumers
 of characters. Queue-like buffers (such as strstream and strstreambuf)
 have a put and a get pointer that move independently of each other. In
 such buffers, stored characters are queued until later fetched.
 File-like buffers (such as filebuf) allow both get and put operations
 but have their get and put pointers linked together, so that when one
 pointer moves so does the other.

 To manage the collections of characters in the get and put areas, you
 can call virtual functions. Services supplied by virtual functions
 include fetching more characters from an ultimate producer and
 flushing a collection of characters to an ultimate consumer.

 Header:

	#include <iostream.hxx>

strstream
 This class specializes iostream for storing in and fetching from
 arrays of bytes. It handles all predefined data types, and provides an
 extensive set of options for performing input and output on these data
 types.

 Header:

	#include <strstream.hxx>

strstreambuf
 Objects of this class let you use an array of bytes (a string of
 characters) in memory as a streambuf for stream input/output
 operations on various kinds of data. Mapping between abstract get and
 put pointers and char* pointers is direct in the sense that a char* is
 interpreted as pointing immediately ahead of the char it points to.
 Moving the pointers corresponds to incrementing and decrementing the
 char* values.

 To accommodate the need for strings of arbitrary length, this class
 supports a dynamic mode. When a strstreambuf object is in dynamic
 mode, space for the character is allocated as needed. When the
 sequence is extended too far, it is copied to a new array.

 Header:

	#include <strstream.hxx>

Manipulators
 Manipulators are supplied to let executing programs insert values into or
 extract values from a stream to cause some special effect as follows:

 ios &dec(ios &s)	     Sets the conversion base format to decimal.
 ios &hex(ios &s)	     Sets the conversion base format to hexadecimal.
 ios &oct(ios &s)	     Sets the conversion base format to octal.
 ios &lock(ios &s)           Locks a predefined object  
 ios &unlock(ios &s)         Unlcks a predefined object
 istream &ws(istream &i)     Extracts (skips) white-space characters.
 ostream &endl(ostream &o)   Ends a line by inserting a new-line character and
				flushing.
 ostream &ends(ostream &o)   Ends a string by inserting a null (0) character.
 ostream &flush(ostream &o)  Flushes ostreams.


IMANIP(TYPE)
 This class supplies predefined parameterized manipulators and provides
 macros for user-defined parameterized manipulators for istream
 objects.

 Header:

	#include <iomanip.hxx>

IOMANIP(TYPE)
 This class supplies predefined parameterized manipulators and provides
 macros for user-defined parameterized manipulators for iostream
 objects.

 Header:

	#include <iomanip.hxx>

OMANIP(TYPE)
 This class supplies predefined parameterized manipulators and provides
 macros for user-defined parameterized manipulators for ostream
 objects.

 Header:

	#include <iomanip.hxx>

SMANIP(TYPE)
 This class supplies predefined parameterized manipulators and provides
 macros for user-defined parameterized manipulators for ios objects.

 Header:

	#include <iomanip.hxx>

Predefined_stream_objects_synchronization
 Two unparameterized locking and unlocking manipulators, lock and unlock,
 are available for use in synchronizing access to the predefined stream
 objects: cerr, cin, clog, and cout. If your application needs to lock
 two or more of these objects at the same time, the application must
 adhere to this locking order:

    cin, cerr, clog, cout

 The unlocking order is not important.

 When your application calls a member function for a predefined stream
 object, the member function will typically lock the object for the
 duration of the call.  Therefore, if your application has locked one of
 the stream objects and then uses another, this use must also adhere to
 the predefined locking order.  For example, your application should not
 send output to cerr while cout is locked.

 The locking order necessarily matches the default 'ties' between the
 stream objects as follows:

 cin is tied to cout
 cerr  is tied to cout
 clog is tied to cout
 cout has no ties

 Any input/output operation on a stream object causes the iostream
 Package to flush the object to which it is tied. Thus, an output to
 cerr flushes cout.

User-defined_stream_objects_synchronization
  Two parameterized locking and unlocking manipulators, lock and unlock,
  are available for use in synchronizing access to user-defined stream
  objects.  To use these manipulators, you must first define a Mutex
  object which you then pass to the manipulator.  The association
  of a Mutex object with a stream object is not enforced by the iostream
  package. This association is enforced only by a program developer.
  For more information, see help on the Mutex_package.

privacy and legal statement