United States

cxxl$help.HLP

##

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

Additional Information on:

- lock(Mutex &)
- resetiosflags(long)
- setfill(int)
- setiosflags(long)
- setprecision(int)
- setw(int w)
- unlock(Mutex &)

  ##

  ##

  ##

  ##

      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:

- Deriving_a_user_class

  ##

  ##

  ##

  ##

  ##

  ##

  ##

  ##

  ##

  ##

  ##

  ##

  ##

  ##

  ##

  ##

  ##

  ##

  ##

  ##

  ##

      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