<ios>


ios · fpos · ios_base · locale · mbstate_t · streamoff · streampos · streamsize

boolalpha · dec · fixed · hex · internal · left · noboolalpha · noshowbase · noshowpoint · noshowpos · noskipws · nounitbuf · nouppercase · oct · right · scientific · showbase · showpoint · showpos · skipws · unitbuf · uppercase


// DECLARATIONS
    typedef T1 streamoff;
    typedef T2 streamsize;
    class ios_base;
    class ios;
    class fpos;
    class locale;
    typedef T3 mbstate_t;
    typedef fpos streampos;
//      MANIPULATORS
    ios_base& boolalpha(ios_base& str);
    ios_base& noboolalpha(ios_base& str);
    ios_base& showbase(ios_base& str);
    ios_base& noshowbase(ios_base& str);
    ios_base& showpoint(ios_base& str);
    ios_base& noshowpoint(ios_base& str);
    ios_base& showpos(ios_base& str);
    ios_base& noshowpos(ios_base& str);
    ios_base& skipws(ios_base& str);
    ios_base& noskipws(ios_base& str);
    ios_base& unitbuf(ios_base& str);
    ios_base& nounitbuf(ios_base& str);
    ios_base& uppercase(ios_base& str);
    ios_base& nouppercase(ios_base& str);
    ios_base& internal(ios_base& str);
    ios_base& left(ios_base& str);
    ios_base& right(ios_base& str);
    ios_base& dec(ios_base& str);
    ios_base& hex(ios_base& str);
    ios_base& oct(ios_base& str);
    ios_base& fixed(ios_base& str);
    ios_base& scientific(ios_base& str);
// END OF DECLARATIONS

Include the iostreams standard header <ios> to define several types and functions basic to the operation of iostreams. (This header is typically included for you by another of the iostreams headers. You seldom have occasion to include it directly.)

A large group of functions are manipulators. The manipulators declared in <ios> alter the values stored in its argument object of class ios_base. Other manipulators perform actions on streams controlled by objects of a type derived from this class, such as one of the classes istream or ostream. For example, noskipws(str) clears the format flag ios_base::skipws in the object str, which might be of one of these types.

You can also call a manipulator by inserting it into an output stream or extracting it from an input stream, thanks to some special machinery supplied in the classes derived from ios_base. For example:

istr >> noskipws;

calls noskipws(istr).

ios


bad · ios · char_type · clear · copyfmt · eof · exceptions · init · fail · good · imbue · init · int_type · narrow · off_type · operator! · operator void * · pos_type · rdbuf · rdstate · setstate · tie · traits_type · widen


class ios : public ios_base {
public:
    typedef char char_type;
    typedef char_traits traits_type;
    typedef char_traits::int_type int_type;
    typedef char_traits::pos_type pos_type;
    typedef char_traits::off_type off_type;
    explicit ios(streambuf *sb);
    virtual ~ios();
    operator void *() const;
    bool operator!() const;
    iostate rdstate() const;
    void clear(iostate state = goodbit);
    void setstate(iostate state);
    bool good() const;
    bool eof() const;
    bool fail() const;
    bool bad() const;
    iostate exceptions() const;
    iostate exceptions(iostate except);
    ios& copyfmt(const ios& rhs);
    locale imbue(const locale& loc);
    char_type widen(char ch);
    char narrow(char_type ch, char dflt);
    char_type fill() const;
    char_type fill(char_type ch);
    ostream *tie() const;
    ostream *tie(ostream *str);
    streambuf *rdbuf() const;
    streambuf *rdbuf(streambuf *sb);
protected:
    void init(streambuf *sb);
    ios();
    ios(const facet&)          // not defined
    void operator=(const facet&) // not defined
        };

The class describes the storage and member functions common to both input streams (of class istream) and output streams (of class ostream). An object of class ios helps control a stream with elements of type char, also known as char_type, whose character traits are determined by the class char_traits.

An object of class ios stores:

ios::bad

bool bad() const;

The member function returns true if rdstate() & badbit.

ios::ios

explicit ios(streambuf *sb);
ios();

The first constructor initializes its member objects by calling init(sb). The second (protected) constructor leaves its member objects uninitialized. A later call to init must initialize the object before it can be safely destroyed.

ios::char_type

typedef char char_type;

The type is a synonym for char.

ios::clear

void clear(iostate state = goodbit);

The member function replaces the stored stream state information with state | (rdbuf() != 0 ? goodbit : badbit). If state & exceptions() is nonzero, it then throws an object of class failure.

ios::copyfmt

ios& copyfmt(const ios& rhs);

The member function reports the callback event erase_event. It then copies from rhs into *this the fill character, the tie pointer, and the formatting information. Before altering the exception mask, it reports the callback event copyfmt_event. If, after the copy is complete, state & exceptions() is nonzero, the function effectively calls clear with the argument rdstate(). It returns *this.

ios::eof

bool eof() const;

The member function returns true if rdstate() & eofbit.

ios::exceptions

iostate exceptions() const;
iostate exceptions(iostate except);

The first member function returns the stored exception mask. The second member function stores except in the exception mask and returns its previous stored value.

ios::fail

bool fail() const;

The member function returns true if rdstate() & failbit.

ios::fill

char_type fill() const;
char_type fill(char_type ch);

The first member function returns the stored fill character. The second member function stores ch in the fill character and returns its previous stored value.

ios::good

bool good() const;

The member function returns true if rdstate() == goodbit (no state flags are set).

ios::imbue

locale imbue(const locale& loc);

If rdbuf is not a null pointer, the member function calls rdbuf()->pubimbue(loc). In any case, it returns ios_base::imbue(loc).

ios::init

void init(streambuf *sb);

The member function stores values in all member objects, so that:

ios::int_type

typedef int int_type;

The type is a synonym for int.

ios::narrow

char narrow(char_type ch, char dflt);

The member function returns ch.

ios::off_type

typedef streamoff off_type;

The type is a synonym for streamoff.

ios::operator void *

operator void *() const;

The operator returns a null pointer only if fail().

ios::operator!

bool operator!() const;

The operator returns fail().

ios::pos_type

typedef streampos pos_type;

The type is a synonym for streampos.

ios::rdbuf

streambuf *rdbuf() const;
streambuf *rdbuf(streambuf *sb);

The member function returns the stored stream buffer pointer.

ios::rdstate

iostate rdstate() const;

The member function returns the stored stream state information.

ios::setstate

void setstate(iostate state);

The member function effectively calls clear(state | rdstate()).

ios::tie

ostream *tie() const;
ostream *tie(ostream *str);

The first member function returns the stored tie pointer. The second member function stores str in the tie pointer and returns its previous stored value.

ios::traits_type

typedef char_traits traits_type;

The type is a synonym for char_traits.

ios::widen

char_type widen(char ch);

The member function returns ch.

boolalpha

ios_base& boolalpha(ios_base& str);

The manipulator effectively calls str.setf(ios_base:: boolalpha), then returns str.

dec

ios_base& dec(ios_base& str);

The manipulator effectively calls str.setf(ios_base:: dec, ios_base:: basefield), then returns str.

fixed

ios_base& fixed(ios_base& str);

The manipulator effectively calls str.setf(ios_base:: fixed, ios_base:: floatfield), then returns str.

fpos

class fpos {
public:
    typedef mbstate_t St;
    fpos(streamoff off);
    explicit fpos(St state);
    St state() const;
    void state(St state);
    operator streamoff() const;
    streamoff operator-(const fpos& rhs) const;
    fpos& operator+=(streamoff off);
    fpos& operator-=(streamoff off);
    fpos operator+(streamoff off) const;
    fpos operator-(streamoff off) const;
    bool operator==(const fpos& rhs) const;
    bool operator!=(const fpos& rhs) const;
    };

The class describes an object that can store all the information needed to restore an arbitrary file-position indicator within any stream. An object of class fpos effectively stores at least two member objects:

It can also store an arbitrary file position, for use by an object of class filebuf, of type fpos_t. For an environment with limited file size, however, streamoff and fpos_t may sometimes be used interchangeably. So the number of member objects stored may vary.

fpos::fpos

fpos(streamoff off);
explicit fpos(St state);

The first constructor stores the offset off, relative to the beginning of file. If off is -1, the resulting object represents an invalid stream position.

The second constructor stores a zero offset and the object state.

In this implementation, the constructor:

explicit fpos(St state);

is replaced by:

fpos(St state, fpos_t fposn);
fpos_t seekpos() const;

The two-argument constructor avoids an ambiguity when the state type St is an integer type. It also provides a way to store an object fposn of type fpos_t. The added member function seekpos returns the value of this stored object.

fpos::operator!=

bool operator!=(const fpos& rhs) const;

The member function returns !(*this == rhs).

fpos::operator+

fpos operator+(streamoff off) const;

The member function returns fpos(*this) += off.

fpos::operator+=

fpos& operator+=(streamoff off);

The member function adds off to the stored offset member object, then returns *this. For positioning within a file, the result is generally valid only for binary streams.

fpos::operator-

streamoff operator-(const fpos& rhs) const;
fpos operator-(streamoff off) const;

The first member function returns (streamoff)*this - (streamoff)rhs. The second member function returns fpos(*this) -= off.

fpos::operator-=

fpos& operator-=(streamoff off);

The member function returns fpos(*this) -= off. For positioning within a file, the result is generally valid only for binary streams.

fpos::operator==

bool operator==(const fpos& rhs) const;

The member function returns (streamoff)*this == (streamoff)rhs.

fpos::operator streamoff

operator streamoff() const;

The member function returns the stored offset member object, plus any additional offset stored as part of the fpos_t member object.

fpos::state

St state() const;
void state(St state);

The first member function returns the value stored in the St member object. The second member function stores state in the St member object.

hex

ios_base& hex(ios_base& str);

The manipulator effectively calls str.setf(ios_base:: hex, ios_base:: basefield), then returns str.

internal

ios_base& internal(ios_base& str);

The manipulator effectively calls str.setf(ios_base:: internal, ios_base:: adjustfield), then returns str.

ios_base


event · event_callback · failure · flags · fmtflags · getloc · imbue · Init · ios_base · iostate · iword · openmode · operator= · precision · pword · register_callback · seekdir · setf · sync_with_stdio · unsetf · width · xalloc


class ios_base {
public:
    class failure;
    typedef T1 fmtflags;
    static const fmtflags boolalpha, dec, fixed, hex,
        internal, left, oct, right, scientific,
        showbase, showpoint, showpos, skipws, unitbuf,
        uppercase, adjustfield, basefield, floatfield;
    typedef T2 iostate;
    static const iostate badbit, eofbit, failbit,
        goodbit;
    typedef T3 openmode;
    static const openmode app, ate, binary, in, out,
        trunc;
    typedef T4 seekdir;
    static const seekdir beg, cur, end;
    typedef T5 event;
    static const event copyfmt_event, erase_event,
        copyfmt_event;
    class Init;
    ios_base& operator=(const ios_base& rhs);
    fmtflags flags() const;
    fmtflags flags(fmtflags fmtfl);
    fmtflags setf(fmtflags fmtfl);
    fmtflags setf(fmtflags fmtfl, fmtflags mask);
    void unsetf(fmtflags mask);
    streamsize precision() const;
    streamsize precision(streamsize prec);
    streamsize width() const;
    stramsize width(streamsize wide);
    locale imbue(const locale& loc);
    locale getloc() const;
    static int xalloc();
    long& iword(int idx);
    void *& pword(int idx);
    typedef void *(event_callback(event ev,
        ios_base& ios, int idx);
    void register_callback(event_callback pfn, int idx);
    static bool sync_with_stdio(bool sync = true);
protected:
    ios_base();
    };

The class describes the storage and member functions common to both input and output streams. The class ios describes additional common features.

An object of class ios_base stores formatting information, which consists of:

An object of class ios_base also stores stream state information, in an object of type iostate, and a callback stack.

ios_base::event

typedef T5 event;
static const event copyfmt_event, erase_event,
    imbue_event;

The type is an enumerated type T5 that describes an object that can store the callback event used as an argument to a function registered with register_callback. The distinct event values are:

ios_base::event_callback

typedef void *(event_callback(event ev,
        ios_base& ios, int idx);

The type describes a pointer to a function that can be registered with register_callback. Such a function must not throw an exception.

ios_base::failure

class failure : public exception {
public:
    explicit failure(const string& what_arg) {
    };

The member class serves as the base class for all exceptions thrown by the member function clear in template class ios. The value returned by what() is what_arg.data().

ios_base::flags

fmtflags flags() const;
fmtflags flags(fmtflags fmtfl);

The first member function returns the stored format flags. The second member function stores fmtfl in the format flags and returns its previous stored value.

ios_base::fmtflags

typedef T1 fmtflags;
static const fmtflags boolalpha, dec, fixed, hex,
    internal, left, oct, right, scientific,
    showbase, showpoint, showpos, skipws, unitbuf,
    uppercase, adjustfield, basefield, floatfield;

The type is an enumerated type T1 that describes an object that can store format flags. The distinct flag values are:

In addition, several useful values are:

ios_base::getloc

locale getloc() const;

The member function returns the stored locale object.

ios_base::imbue

locale imbue(const locale& loc);

The member function stores loc in the locale object, then reports the callback event imbue_event. It returns the previous stored value.

ios_base::Init

class Init {
    };

The nested class describes an object whose construction ensures that the standard iostreams objects are properly constructed, even during the execution of a constructor for an arbitrary static object.

ios_base::ios_base

ios_base();

The (protected) constructor does nothing. A later call to ios::init must initialize the object before it can be safely destroyed. Thus, the only safe use for class ios_base is as a base class for template class ios.

ios_base::iostate

typedef T2 iostate;
static const iostate badbit, eofbit, failbit, goodbit;

The type is an enumerated type T2 that describes an object that can store stream state information. The distinct flag values are:

In addition, a useful value is:

ios_base::iword

long& iword(int idx);

The member function returns a reference to element idx of the extensible array with elements of type long. All elements are effectively present and initially store the value zero. The returned reference is invalid after the next call to iword for the object, after the object is altered by a call to ios::copyfmt, or after the object is destroyed.

If idx is negative, or if unique storage is unavailable for the element, the function calls setstate(badbit) and returns a reference that might not be unique.

To obtain a unique index, for use across all objects of type ios_base, call xalloc.

ios_base::openmode

typedef T3 openmode;
static const openmode app, ate, binary, in, out, trunc;

The type is an enumerated type T3 that describes an object that can store the opening mode for several iostreams objects. The distinct flag values are:

ios_base::operator=

ios_base& operator=(const ios_base& rhs);

The operator copies the stored formatting information, making a new copy of any extensible arrays. It then returns *this. Note that the callback stack is not copied.

ios_base::precision

streamsize precision() const;
streamsize precision(streamsize prec);

The first member function returns the stored display precision. The second member function stores prec in the display precision and returns its previous stored value.

ios_base::pword

void *& pword(int idx);

The member function returns a reference to element idx of the extensible array with elements of type void pointer. All elements are effectively present and initially store the null pointer. The returned reference is invalid after the next call to pword for the object, after the object is altered by a call to ios::copyfmt, or after the object is destroyed.

If idx is negative, or if unique storage is unavailable for the element, the function calls setstate(badbit) and returns a reference that might not be unique.

To obtain a unique index, for use across all objects of type ios_base, call xalloc.

ios_base::register_callback

void register_callback(event_callback pfn, int idx);

The member function pushes the pair {pfn, idx} onto the stored callback stack. When a callback event ev is reported, the functions are called, in reverse order of registry, by the expression (*pfn)(ev, *this, idx).

ios_base::seekdir

typedef T4 seekdir;
static const seekdir beg, cur, end;

The type is an enumerated type T4 that describes an object that can store the seek mode used as an argument to the member functions of several iostreams classes. The distinct flag values are:

ios_base::setf

void setf(fmtflags mask);
fmtflags setf(fmtflags fmtfl, fmtflags mask);

The first member function effectively calls flags(mask | flags()) (set selected bits), then returns the previous format flags. The second member function effectively calls flags(mask & fmtfl, flags() & ~mask) (replace selected bits under a mask), then returns the previous format flags.

ios_base::sync_with_stdio

static bool sync_with_stdio(bool sync = true);

The static member function stores a stdio sync flag, which is initially true. When true, this flag ensures that operations on the same file are properly synchronized between the iostreams functions and those defined in the Standard C library. Otherwise, synchronization may or may not be guaranteed, but performance may be improved. The function stores sync in the stdio sync flag and returns its previous stored value. You can call it reliably only before performing any operations on the standard streams.

ios_base::unsetf

void unsetf(fmtflags mask);

The member function effectively calls flags(~mask & flags()) (clear selected bits).

ios_base::width

streamsize width() const;
streamsize width(streamsize wide);

The first member function returns the stored field width. The second member function stores wide in the field width and returns its previous stored value.

ios_base::xalloc

static int xalloc();

The static member function returns a stored static value, which it increments on each call. You can use the return value as a unique index argument when calling the member functions iword or pword.

left

ios_base& left(ios_base& str);

The manipulator effectively calls str.setf(ios_base:: left, ios_base:: adjustfield), then returns str.

locale

class locale {
    };

The class serves as a placeholder for the much more elaborate locale machinery mandated by Standard C++.

mbstate_t

typedef T3 mbstate_t;

The type is an unspecified type T3 that serves as a placeholder for the more elaborate conversion-state machinery, used to convert between multibyte and wide-character encodings, mandated by Standard C.

noboolalpha

ios_base& noboolalpha(ios_base& str);

The manipulator effectively calls str.unsetf(ios_base:: boolalpha), then returns str.

noshowbase

ios_base& noshowbase(ios_base& str);

The manipulator effectively calls str.unsetf(ios_base:: showbase), then returns str.

noshowpoint

ios_base& noshowpoint(ios_base& str);

The manipulator effectively calls str.unsetf(ios_base:: showpoint), then returns str.

noshowpos

ios_base& noshowpos(ios_base& str);

The manipulator effectively calls str.unsetf(ios_base:: showpos"), then returns str.

noskipws

ios_base& noskipws(ios_base& str);

The manipulator effectively calls str.unsetf(ios_base:: skipws), then returns str.

nounitbuf

ios_base& nounitbuf(ios_base& str);

The manipulator effectively calls str.unsetf(ios_base:: unitbuf), then returns str.

nouppercase

ios_base& nouppercase(ios_base& str);

The manipulator effectively calls str.unsetf(ios_base:: uppercase), then returns str.

oct

ios_base& oct(ios_base& str);

The manipulator effectively calls str.setf(ios_base:: oct, ios_base:: basefield), then returns str.

right

ios_base& right(ios_base& str);

The maiipulator effectively calls str.setf(ios_base:: right, ios_base:: adjustfield), then returns str.

scientific

ios_base& scientific(ios_base& str);

The manipulator effectively calls str.setf(ios_base:: scientific, ios_base:: floatfield), then returns str.

showbase

ios_base& showbase(ios_base& str);

The manipulator effectively calls str.setf(ios_base:: showbase), then returns str.

showpoint

ios_base& showpoint(ios_base& str);

The manipulator effectively calls str.setf(ios_base:: showpoint), then returns str.

showpos

ios_base& showpos(ios_base& str);

The manipulator effectively calls str.setf(ios_base:: showpos), then returns str.

skipws

ios_base& skipws(ios_base& str);

The manipulator effectively calls str.setf(ios_base:: skipws), then returns str.

streamoff

typedef T1 streamoff;

The type is a signed integer type T1 that describes an object that can store a byte offset involved in various stream positioning operations. Its representation has at least 32 value bits. It is not necessarily large enough to represent an arbitrary byte position within a stream. The value streamoff(-1) generally indicates an erroneous offset.

streampos

typedef fpos streampos;

The type is a synonym for fpos.

streamsize

typedef T2 streamsize;

The type is a signed integer type T3 that describes an object that can store a count of the number of elements involved in various stream operations. Its representation has at least 16 bits. It is not necessarily large enough to represent an arbitrary byte position within a stream.

unitbuf

ios_base& unitbuf(ios_base& str);

The manipulator effectively calls str.setf(ios_base:: unitbuf), then returns str.

uppercase

ios_base& uppercase(ios_base& str);

The manipulator effectively calls str.setf(ios_base:: uppercase), then returns str.


See also the Table of Contents and the Index.

Copyright © 1992-1996 by P.J. Plauger. All rights reserved.