<ios>basic_ios
· fpos · ios · ios_base · streamoff · streampos · streamsize · wios · wstreampos
boolalpha
· dec · fixed · hex · internal · left · noboolalpha
· noshowbase
· noshowpoint
· noshowpos
· noskipws
· nounitbuf
· nouppercase
· oct · right · scientific · showbase · showpoint · showpos · skipws · unitbuf · uppercase
namespace std {
typedef T1 streamoff;
typedef T2 streamsize;
class ios_base;
// TEMPLATE CLASSES
template <class E, class T = char_traits<E> >
class basic_ios;
typedef basic_ios<char, char_traits<char> > ios;
typedef basic_ios<wchar_t, char_traits<wchar_t> >
wios;
template <class St>
class fpos;
typedef fpos<mbstate_t> streampos;
typedef fpos<mbstate_t> wstreampos;
// 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);
};
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 a
specialization of one of the template classes basic_istream or basic_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).
basic_iosbad
· basic_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
template <class E, class T = char_traits<E> >
class basic_ios : public ios_base {
public:
typedef E char_type;
typedef T traits_type;
typedef typename T::int_type int_type;
typedef typename T::pos_type pos_type;
typedef typename T::off_type off_type;
explicit basic_ios(basic_streambuf<E, T> *sb);
virtual ~basic_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);
basic_ios& copyfmt(const basic_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);
basic_ostream<E, T> *tie() const;
basic_ostream<E, T> *tie(basic_ostream<E, T> *str);
basic_streambuf<E, T> *rdbuf() const;
basic_streambuf<E, T>
*rdbuf(basic_streambuf<E, T> *sb);
E widen(char ch);
char narrow(E ch, char dflt);
protected:
void init(basic_streambuf<E, T> *sb);
basic_ios();
basic_ios(const facet&) // not defined
void operator=(const facet&) // not defined
};
The template class describes the storage and member functions
common to both input streams (of template class basic_istream)
and output streams (of template class basic_ostream)
that depend on the template parameters. (The class ios_base
describes what is common and not dependent on template
parameters. An object of class basic_ios<E, T>
helps control a stream with elements of type E,
whose character traits
are determined by the class T.
An object of class basic_ios<E, T> stores:
basic_ostream<E,
T>basic_streambuf<E,
T>ios_basebasic_ios::badbool bad() const;
The member function returns true if rdstate() & badbit.
basic_ios::basic_iosexplicit basic_ios(basic_streambuf<E, T> *sb); basic_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.
basic_ios::char_typetypedef E char_type;
The type is a synonym for the template parameter E.
basic_ios::clearvoid 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.
basic_ios::copyfmtbasic_ios& copyfmt(const basic_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.
basic_ios::eofbool eof() const;
The member function returns true if rdstate() & eofbit.
basic_ios::exceptionsiostate 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. Note that
storing a new exception mask can throw an exception just like the
call clear( rdstate()).
basic_ios::failbool fail() const;
The member function returns true if rdstate() & failbit.
basic_ios::fillchar_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.
basic_ios::goodbool good() const;
The member function returns true if rdstate() == goodbit
(no state flags are set).
basic_ios::imbuelocale 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).
basic_ios::initvoid init(basic_streambuf<E, T> *sb);
The member function stores values in all member objects, so that:
rdbuf()
returns sbtie()
returns a null pointerrdstate()
returns goodbit
if sb is nonzero; otherwise, it returns badbitexceptions()
returns goodbitflags()
returns skipws | decwidth()
returns zeroprecision()
returns 6fill()
returns the space charactergetloc()
returns locale::classic()iword
returns zero and pword
returns a null pointer for all argument valuebasic_ios::int_typetypedef typename T::int_type int_type;
The type is a synonym for T::int_type.
basic_ios::narrowchar narrow(char_type ch, char dflt);
The member function returns use_facet< ctype<E> >( getloc()). narrow(ch, dflt).
basic_ios::off_typetypedef typename T::off_type off_type;
The type is a synonym for T::off_type.
basic_ios::operator
void *operator void *() const;
The operator returns a null pointer only if fail().
basic_ios::operator!bool operator!() const;
The operator returns fail().
basic_ios::pos_typetypedef typename T::pos_type pos_type;
The type is a synonym for T::pos_type.
basic_ios::rdbufbasic_streambuf<E, T> *rdbuf() const; basic_streambuf<E, T> *rdbuf(basic_streambuf<E, T> *sb);
The member function returns the stored stream buffer pointer.
basic_ios::rdstateiostate rdstate() const;
The member function returns the stored stream state information.
basic_ios::setstatevoid setstate(iostate state);
The member function effectively calls clear(state
| rdstate()).
basic_ios::tiebasic_ostream<E, T> *tie() const; basic_ostream<E, T> *tie(basic_ostream<E, T> *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.
basic_ios::traits_typetypedef T traits_type;
The type is a synonym for the template parameter T.
basic_ios::widenchar_type widen(char ch);
The member function returns use_facet< ctype<E> >( getloc()). widen(ch).
boolalphaios_base& boolalpha(ios_base& str);
The manipulator effectively calls str.setf(ios_base::
boolalpha),
then returns str.
decios_base& dec(ios_base& str);
The manipulator effectively calls str.setf(ios_base::
dec,
ios_base:: basefield),
then returns str.
fixedios_base& fixed(ios_base& str);
The manipulator effectively calls str.setf(ios_base::
fixed,
ios_base:: floatfield),
then returns str.
fpostemplate <class St>
class fpos {
public:
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 template 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<St>
effectively stores at least two member objects:
streamoffbasic_filebuf,
of type St, typically mbstate_tIt can also store an arbitrary file position, for use by an
object of class basic_filebuf,
of type fpos_t. For
an environment with limited file size, however, streamoff
and fpos_t may sometimes be used interchangeably.
And for an environment with no streams that have a state-dependent
encoding, mbstate_t may actually be unused. So
the number of member objects stored may vary.
fpos::fposfpos(streamoff off); explicit fpos(St state);
The first constructor stores the offset off,
relative to the beginning of file and in the initial
conversion state (if that matters). 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
that do not have a state-dependent
encoding.
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 that do not have a state-dependent
encoding.
fpos::operator==bool operator==(const fpos& rhs) const;
The member function returns (streamoff)*this ==
(streamoff)rhs.
fpos::operator
streamoffoperator 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::stateSt 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.
hexios_base& hex(ios_base& str);
The manipulator effectively calls str.setf(ios_base::
hex,
ios_base:: basefield),
then returns str.
internalios_base& internal(ios_base& str);
The manipulator effectively calls str.setf(ios_base::
internal,
ios_base:: adjustfield),
then returns str.
iostypedef basic_ios<char, char_traits<char> > ios;
The type is a synonym for template class basic_ios,
specialized for elements of type char with default character traits.
ios_baseevent · 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 that does not depend on the
template parameters. (The template class basic_ios describes
what is common and is dependent on template parameters.
An object of class ios_base stores formatting information,
which consists of:
fmtflagsiostatelocaleAn object of class ios_base also stores stream state information,
in an object of type iostate,
and a callback stack.
ios_base::eventtypedef 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:
copyfmt,
just before the exception mask is
copied.copyfmt,
or at the beginning of a call to the destructor for *this.imbue, just
before the function returns.ios_base::event_callbacktypedef 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::failureclass 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 basic_ios.
The value returned by what() is what_arg.data().
ios_base::flagsfmtflags 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::fmtflagstypedef 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:
true and false) rather
than as numeric valuesIn addition, several useful values are:
internal
| left | rightdec
| hex | octfixed
| scientificios_base::getloclocale getloc() const;
The member function returns the stored locale object.
ios_base::imbuelocale 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::Initclass 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_baseios_base();
The (protected) constructor does nothing. A later call to basic_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 basic_ios.
ios_base::iostatetypedef 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::iwordlong& 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 basic_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::openmodetypedef 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::precisionstreamsize 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::pwordvoid *& 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 basic_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_callbackvoid 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::seekdirtypedef 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::setfvoid 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_stdiostatic 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::unsetfvoid unsetf(fmtflags mask);
The member function effectively calls flags(~mask
& flags()) (clear selected bits).
ios_base::widthstreamsize 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::xallocstatic 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.
leftios_base& left(ios_base& str);
The manipulator effectively calls str.setf(ios_base::
left,
ios_base:: adjustfield),
then returns str.
noboolalphaios_base& noboolalpha(ios_base& str);
The manipulator effectively calls str.unsetf(ios_base::
boolalpha),
then returns str.
noshowbaseios_base& noshowbase(ios_base& str);
The manipulator effectively calls str.unsetf(ios_base::
showbase),
then returns str.
noshowpointios_base& noshowpoint(ios_base& str);
The manipulator effectively calls str.unsetf(ios_base::
showpoint),
then returns str.
noshowposios_base& noshowpos(ios_base& str);
The manipulator effectively calls str.unsetf(ios_base::
showpos"),
then returns str.
noskipwsios_base& noskipws(ios_base& str);
The manipulator effectively calls str.unsetf(ios_base::
skipws),
then returns str.
nounitbufios_base& nounitbuf(ios_base& str);
The manipulator effectively calls str.unsetf(ios_base::
unitbuf),
then returns str.
nouppercaseios_base& nouppercase(ios_base& str);
The manipulator effectively calls str.unsetf(ios_base::
uppercase),
then returns str.
octios_base& oct(ios_base& str);
The manipulator effectively calls str.setf(ios_base::
oct,
ios_base:: basefield),
then returns str.
rightios_base& right(ios_base& str);
The maiipulator effectively calls str.setf(ios_base::
right,
ios_base:: adjustfield),
then returns str.
scientificios_base& scientific(ios_base& str);
The manipulator effectively calls str.setf(ios_base::
scientific,
ios_base:: floatfield),
then returns str.
showbaseios_base& showbase(ios_base& str);
The manipulator effectively calls str.setf(ios_base::
showbase),
then returns str.
showpointios_base& showpoint(ios_base& str);
The manipulator effectively calls str.setf(ios_base::
showpoint),
then returns str.
showposios_base& showpos(ios_base& str);
The manipulator effectively calls str.setf(ios_base::
showpos),
then returns str.
skipwsios_base& skipws(ios_base& str);
The manipulator effectively calls str.setf(ios_base::
skipws),
then returns str.
streamofftypedef 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.
streampostypedef fpos<mbstate_t> streampos;
The type is a synonym for fpos< mbstate_t>.
streamsizetypedef 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.
unitbufios_base& unitbuf(ios_base& str);
The manipulator effectively calls str.setf(ios_base::
unitbuf),
then returns str.
uppercaseios_base& uppercase(ios_base& str);
The manipulator effectively calls str.setf(ios_base::
uppercase),
then returns str.
wiostypedef basic_ios<wchar_t, char_traits<wchar_t> > wios;
The type is a synonym for template class basic_ios,
specialized for elements of type wchar_t with
default character traits.
wstreampostypedef fpos<mbstate_t> wstreampos;
The type is a synonym for fpos< mbstate_t>.
See also the Table of Contents .
Copyright © 1992-1996 by P.J. Plauger. All rights reserved.