United States    
COMPAQ STORE | PRODUCTS |
SERVICES | SUPPORT | CONTACT US | SEARCH
cxxtitle.gif (12116 bytes)
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.

      

    1.800.AT.COMPAQ

    privacy and legal statement