______________________________________________________________________
27 Input/output library [lib.input.output]
______________________________________________________________________
1 This clause describes components that C++ programs may use to perform
input/output operations.
2 The following subclauses describe requirements for stream parameters,
and components for forward declarations of iostreams, predefined
iostreams objects, base iostreams classes, stream buffering, stream
formatting and manipulators, string streams, and file streams, as sum
marized in Table 1:
Table 1--Input/output library summary
+----------------------------------------------------------------+
| Subclause Header(s) |
+----------------------------------------------------------------+
|_lib.iostreams.requirements_ Requirements |
+----------------------------------------------------------------+
|_lib.iostream.forward_ Forward declarations <iosfwd> |
+----------------------------------------------------------------+
|_lib.iostream.objects_ Standard iostream objects <iostream> |
+----------------------------------------------------------------+
|_lib.iostreams.base_ Iostreams base classes <ios> |
+----------------------------------------------------------------+
|_lib.stream.buffers_ Stream buffers <streambuf> |
+----------------------------------------------------------------+
| <istream> |
|_lib.iostream.format_ Formatting and manipulators <ostream> |
| <iomanip> |
+----------------------------------------------------------------+
|_lib.string.streams_ String streams <sstream> |
| <cstdlib> |
+----------------------------------------------------------------+
| <fstream> |
|_lib.file.streams_ File streams <cstdio> |
| <cwchar> |
+----------------------------------------------------------------+
27.1 Iostreams requirements [lib.iostreams.requirements]
27.1.1 Definitions [lib.iostreams.definitions]
1 For character-related definitions, see _lib.char.traits.defs_. Addi
tional iostreams definitions:
--iostream class templates The iostream class templates are templates
defined in this clause that take two template arguments: charT and
traits. The argument charT is a character container class, and the
argument traits is a structure which defines additional characteris
tics and functions of the character type represented by charT neces
sary to implement the iostream class templates.
--narrow-oriented iostream classes The narrow-oriented iostream
classes are the instantiations of the iostream class templates on
the character container class char and the default value of the
traits parameter. The traditional iostream classes are regarded as
the narrow-oriented iostream classes (_lib.narrow.stream.objects_).
--wide-oriented iostream classes The wide-oriented iostream classes
are the instantiations of the iostream class templates on the char
acter container class wchar_t and the default value of the traits
parameter. (_lib.wide.stream.objects_).
--repositional streams and arbitrary-positional streams A repositional
stream, can seek to only the position where we previously encoun
tered. On the other hand, an arbitrary-positional stream can seek
to any integral position within the length of the stream. Every
arbitrary-positional stream is repositional.
27.1.2 Limitations [lib.iostream.limits]
27.1.2.1 Imbue Limitations [lib.iostream.limits.imbue]
No function described in _lib.input.output_ except for ios_base::imbue
causes any instance of basic_ios::imbue or basic_streambuf::imbue to
be called. If any user function called from a function declared in
_lib.input.output_ or as an overriding virtual function of any class
declared in _lib.input.output_ calls imbue the behavior is undefined.
27.1.2.2 Positioning Type Limitations [lib.iostreams.limits.pos]
The classes of clause _lib.input.output_ with template arguments charT
and traits behave as described if traits::pos_type and
traits::off_type are streampos and streamoff respectively. Except as
noted explicitly below their behavior when traits::pos_type and
traits::off_type are other types are implementation-defined.
27.2 Forward declarations [lib.iostream.forward]
Header <iosfwd> synopsis
namespace std {
template<> class char_traits<char>;
template<> class char_traits<wchar_t>;
template <class charT, class traits = char_traits<charT> >
class basic_ios;
template <class charT, class traits = char_traits<charT> >
class basic_streambuf;
template <class charT, class traits = char_traits<charT> >
class basic_istream;
template <class charT, class traits = char_traits<charT> >
class basic_ostream;
template <class charT, class traits = char_traits<charT> >
class basic_iostream;
template <class charT, class traits = char_traits<charT> >
class basic_stringbuf;
template <class charT, class traits = char_traits<charT> >
class basic_istringstream;
template <class charT, class traits = char_traits<charT> >
class basic_ostringstream;
template <class charT, class traits = char_traits<charT> >
class basic_stringstream;
template <class charT, class traits = char_traits<charT> >
class basic_filebuf;
template <class charT, class traits = char_traits<charT> >
class basic_ifstream;
template <class charT, class traits = char_traits<charT> >
class basic_ofstream;
template <class charT, class traits = char_traits<charT> >
class basic_fstream;
template <class charT, class traits = char_traits<charT> >
class basic_istreambuf_iterator;
template <class charT, class traits = char_traits<charT> >
class basic_ostreambuf_iterator;
typedef basic_ios<char> ios;
typedef basic_ios<wchar_t> wios;
+------- BEGIN BOX 1 -------+
The typedef for wios disappeared during editing, but Jerry Schwarz
says he cannot find a motion requesting that it be dropped. I have
therefore restored it; this should be checked in Hawaii. --ARK
+------- END BOX 1 -------+
typedef basic_streambuf<char> streambuf;
typedef basic_istream<char> istream;
typedef basic_ostream<char> ostream;
typedef basic_ostream<char> iostream;
typedef basic_stringbuf<char> stringbuf;
typedef basic_istringstream<char> istringstream;
typedef basic_ostringstream<char> ostringstream;
typedef basic_stringstream<char> stringstream;
typedef basic_filebuf<char> filebuf;
typedef basic_ifstream<char> ifstream;
typedef basic_ofstream<char> ofstream;
typedef basic_fstream<char> fstream;
typedef basic_streambuf<wchar_t> wstreambuf;
typedef basic_istream<wchar_t> wistream;
typedef basic_ostream<wchar_t> wostream;
typedef basic_stringbuf<wchar_t> wstringbuf;
typedef basic_istringstream<wchar_t> wistringstream;
typedef basic_ostringstream<wchar_t> wostringstream;
typedef basic_stringstream<wchar_t> wstringstream;
typedef basic_filebuf<wchar_t> wfilebuf;
typedef basic_ifstream<wchar_t> wifstream;
typedef basic_ofstream<wchar_t> wofstream;
typedef basic_fstream<wchar_t> wfstream;
template <class state> class fpos;
typedef fpos<char_traits<char>::state_type> streampos;
typedef fpos<char_traits<wchar_t>::state_type> wstreampos;
}
+------- BEGIN BOX 2 -------+
Should there be a typedef for streamoff here?
+------- END BOX 2 -------+
[Note:
1 The template class basic_ios<charT,traits> serves as a virtual base
class for the classes basic_istream<charT,traits>,
basic_ostream<charT,traits>, and classes derived from them.
basic_iostream<charT,traits> is a class derived from both
basic_istream and basic_ostream.
2 The template class basic_streambuf<charT,traits> serves as a base
class for template classes basic_stringbuf, and basic_filebuf.
3 The template class basic_istream serves as a base class for template
classes basic_istringstream, and basic_ifstream
4 The template class basic_ostream serves as a base class for template
classes basic_ostringstream, and basic_ofstream
5 The template class basic_iostream serves as a base class for template
classes basic_stringstream, and basic_fstream.
6 Other typedefs define instances of template classes specialized for
char or wchar_t types.
7 The template class fpos<charT> is a class used for specifying file
position information.
8 The types streampos and wstreampos are used for positioning streams
specialized on char and wchar_t respectively.
9 This synopsis suggests a circularity between streampos and
char_traits<char>. An implementation can avoid this circularity by
substituting equivalent types. One way to do this might be
template<class stateT> class fpos { ... }; // depends on nothing
typedef ... _STATE; // implementation private declaration of stateT
typedef fpos<_STATE> streampos;
template<> struct char_traits<char> {
typedef streampos pos_type;
// ....
}
--end note]
27.3 Standard iostream objects [lib.iostream.objects]
Header <iostream> synopsis
namespace std {
extern istream cin;
extern ostream cout;
extern ostream cerr;
extern ostream clog;
extern wistream wcin;
extern wostream wcout;
extern wostream wcerr;
extern wostream wclog;
}
1 The header <iostream> declares objects that associate objects with the
standard C streams provided for by the functions declared in <cstdio>
(_lib.c.files_).
2 Mixing operations on corresponding wide- and narrow-character streams
follows the same semantics as mixing such operations on FILEs, as
specified in Amendment 1 of the ISO C standard.
+------- BEGIN BOX 3 -------+
These objects need to be constructed and associations established
before dynamic initialization of file scope variables is begun.
+------- END BOX 3 -------+
The objects are constructed, and the associations are established at
some time prior to or during first time an object of class
basic_ios<charT,traits>::Init is constructed.
+------- BEGIN BOX 4 -------+
Change: Added the provision for construction prior to the first time
an Init is constructed. I do not believe this is substantive because
I think it is impossible to detect such early construction. And I
can't conceive of the committee breaking all existing code that
doesn't construct any Init's.
+------- END BOX 4 -------+
The objects are not destroyed during program execution.1)
27.3.1 Narrow stream objects [lib.narrow.stream.objects]
istream cin;
1 The object cin controls input from an unbuffered stream buffer associ
ated with the object stdin, declared in <cstdio>.
2 After the object cin is initialized, cin.tie() returns &cout.
ostream cout;
3 The object cout controls output to an unbuffered stream buffer associ
ated with the object stdout, declared in <cstdio> (_lib.c.files_).
ostream cerr;
4 The object cerr controls output to an unbuffered stream buffer associ
ated with the object stderr, declared in <cstdio> (_lib.c.files_).
5 After the object cerr is initialized, cerr.flags() & unitbuf is
nonzero.
ostream clog;
_________________________
1) Constructors and destructors for static objects can access these
objects to read input from stdin or write output to stdout or stderr.
6 The object clog controls output to a stream buffer associated with the
object stderr, declared in <cstdio> (_lib.c.files_).
+------- BEGIN BOX 5 -------+
This leaves other parts of the state unspecified. I believe they
should be initialized as if by init.
+------- END BOX 5 -------+
27.3.2 Wide stream objects [lib.wide.stream.objects]
wistream wcin;
1 The object wcin controls input from an unbuffered stream buffer asso
ciated with the object stdin, declared in <cstdio>.
2 After the object wcin is initialized, wcin.tie() returns &wcout.
wostream wcout;
3 The object wcout controls output to an unbuffered stream buffer asso
ciated with the object stdout, declared in <cstdio> (_lib.c.files_).
wostream wcerr;
4 The object wcerr controls output to an unbuffered stream buffer asso
ciated with the object stderr, declared in <cstdio> (_lib.c.files_).
5 After the object wcerr is initialized, wcerr.flags() & unitbuf is
nonzero.
wostream wclog;
6 The object wclog controls output to a stream buffer associated with
the object stderr, declared in <cstdio> (_lib.c.files_).
27.4 Iostreams base classes [lib.iostreams.base]
Header <ios> synopsis
namespace std {
typedef OFF_T streamoff;
typedef SZ_T streamsize;
template <class stateT> class fpos;
class ios_base;
template <class charT, class traits = char_traits<charT> >
class basic_ios;
typedef basic_ios<char> ios;
typedef basic_ios<wchar_t> wios;
// _lib.std.ios.manip_, 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& uppercase (ios_base& str);
ios_base& nouppercase(ios_base& str);
// _lib.adjustfield.manip_ adjustfield:
ios_base& internal (ios_base& str);
ios_base& left (ios_base& str);
ios_base& right (ios_base& str);
// _lib.basefield.manip_ basefield:
ios_base& dec (ios_base& str);
ios_base& hex (ios_base& str);
ios_base& oct (ios_base& str);
// _lib.floatfield.manip_ floatfield:
ios_base& fixed (ios_base& str);
ios_base& scientific (ios_base& str);
}
27.4.1 Types [lib.stream.types]
typedef OFF_T streamoff;
1 The type streamoff is an implementation-defined type that satisfies
the requirements of _lib.fpos.operations_.
+------- BEGIN BOX 6 -------+
Change: Discussion of streampos was removed. This is consistent with
the motion that introduced fpos although that motion did not specifi
cally authorize this change.
+------- END BOX 6 -------+
typedef SZ_T streamsize;
2 The type streamsize is a synonym for one of the signed basic integral
types. It is used to represent the number of characters transferred
in an I/O operation, or the size of I/O buffers.2)
27.4.2 Class ios_base [lib.ios.base]
namespace std {
class ios_base {
public:
class failure;
typedef T1 fmtflags;
static const fmtflags boolalpha;
static const fmtflags dec;
static const fmtflags fixed;
static const fmtflags hex;
static const fmtflags internal;
static const fmtflags left;
static const fmtflags oct;
static const fmtflags right;
static const fmtflags scientific;
static const fmtflags showbase;
static const fmtflags showpoint;
static const fmtflags showpos;
static const fmtflags skipws;
static const fmtflags unitbuf;
static const fmtflags uppercase;
static const fmtflags adjustfield;
static const fmtflags basefield;
static const fmtflags floatfield;
typedef T2 iostate;
static const iostate badbit;
static const iostate eofbit;
static const iostate failbit;
static const iostate goodbit;
typedef T3 openmode;
static const openmode app;
static const openmode ate;
static const openmode binary;
static const openmode in;
static const openmode out;
static const openmode trunc;
_________________________
2) streamsize is used in most places where ISO C would use size_t.
Most of the uses of streamsize could use size_t, except for the
strstreambuf constructors, which require negative values. It should
probably be the signed type corresponding to size_t (which is what
Posix.2 calls ssize_t).
typedef T4 seekdir;
static const seekdir beg;
static const seekdir cur;
static const seekdir end;
class Init;
// _lib.fmtflags.state_ fmtflags state:
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;
streamsize width(streamsize wide);
// _lib.ios.base.locales_ locales:
locale imbue(const locale& loc);
locale getloc() const;
// _lib.ios.base.storage_ storage:
static int xalloc();
long& iword(int index);
void*& pword(int index);
// destructor
~ios_base();
// _lib.ios.base.callback_ callbacks;
enum event { erase_event, imbue_event, copyfmt_event };
typedef void (*event_callback)(event, ios_base&, int index);
void register_callback(event_call_back fn, int index);
public static bool sync_with_stdio(bool sync = true);
protected:
ios_base();
private:
// static int index; exposition only
// long* iarray; exposition only
// void** parray; exposition only
};
}
1 ios_base defines several member types:
--a class failure derived from exception;
--a class Init;
--three bitmask types, fmtflags, iostate, and openmode;
--an enumerated type, seekdir.
2 It maintains several kinds of data:
--state information that reflects the integrity of the stream buffer;
--control information that influences how to interpret (format) input
sequences and how to generate (format) output sequences;
--additional information that is stored by the program for its private
use.
3 [Note: For the sake of exposition, the maintained data is presented
here as:
--static int index, specifies the next available unique index for the
integer or pointer arrays maintained for the private use of the pro
gram, initialized to an unspecified value;
--long* iarray, points to the first element of an arbitrary-length
long array maintained for the private use of the program;
--void** parray, points to the first element of an arbitrary-length
pointer array maintained for the private use of the program. --end
note]
27.4.2.1 Types [lib.ios.types]
27.4.2.1.1 Class ios_base::failure [lib.ios::failure]
namespace std {
class ios_base::failure : public exception {
public:
explicit failure(const string& msg);
virtual ~failure();
virtual const char* what() const;
};
}
1 The class failure defines the base class for the types of all objects
thrown as exceptions, by functions in the iostreams library, to report
errors detected during stream buffer operations.
explicit failure(const string& msg);
Effects:
Constructs an object of class failure, initializing the base class
with exception(msg).
Postcondition:
what() == msg.str()
const char* what() const;
Returns:
The message msg with which the exception was created.
27.4.2.1.2 Type ios_base::fmtflags [lib.ios::fmtflags]
typedef T1 fmtflags;
1 The type fmtflags is a bitmask type (_lib.bitmask.types_). Setting
its elements has the effects indicated in Table 2:
Table 2--fmtflags effects
+-----------------------------------------------------------+
| Element Effect(s) if set |
+-----------------------------------------------------------+
|boolalpha insert and extract bool type in alphabetic |
| format |
|dec converts integer input or generates integer |
| output in decimal base |
|fixed generate floating-point output in fixed-point |
| notation; |
|hex converts integer input or generates integer |
| output in hexadecimal base; |
|internal adds fill characters at a designated internal |
| point in certain generated output, or identi |
| cal to right if no such point is designated; |
|left adds fill characters on the right (final po |
| sitions) of certain generated output; |
|oct converts integer input or generates integer |
| output in octal base; |
|right adds fill characters on the left (initial po |
| sitions) of certain generated output; |
|scientific generates floating-point output in scientific |
| notation; |
|showbase generates a prefix indicating the numeric |
| base of generated integer output; |
|showpoint generates a decimal-point character uncondi |
| tionally in generated floating-point output; |
|showpos generates a + sign in non-negative generated |
| numeric output; |
|skipws skips leading white space before certain in |
| put operations; |
|unitbuf flushes output after each output operation; |
|uppercase replaces certain lowercase letters with their |
| uppercase equivalents in generated output. |
+-----------------------------------------------------------+
2 Type fmtflags also defines the constants indicated in Table 3:
Table 3--fmtflags constants
+--------------------------------------+
| Constant Allowable values |
+--------------------------------------+
|adjustfield left | right | internal |
|basefield dec | oct | hex |
|floatfield scientific | fixed |
+--------------------------------------+
27.4.2.1.3 Type ios_base::iostate [lib.ios::iostate]
typedef T2 iostate;
1 The type iostate is a bitmask type (_lib.bitmask.types_) that contains
the elements indicated in Table 4:
Table 4--iostate effects
+--------------------------------------------------------+
|Element Effect(s) if set |
+--------------------------------------------------------+
|badbit indicates a loss of integrity in an input or |
| output sequence (such as an irrecoverable |
| read error from a file); |
|eofbit indicates that an input operation reached the |
| end of an input sequence; |
|failbit indicates that an input operation failed to |
| read the expected characters, or that an out |
| put operation failed to generate the desired |
| characters. |
+--------------------------------------------------------+
2 Type iostate also defines the constant:
--goodbit, the value zero.
27.4.2.1.4 Type ios_base::openmode [lib.ios::openmode]
typedef T3 openmode;
1 The type openmode is a bitmask type (_lib.bitmask.types_). It con
tains the elements indicated in Table 5:
Table 5--openmode effects
+---------------------------------------------------+
|Element Effect(s) if set |
+---------------------------------------------------+
|app seek to end before each write |
|ate open and seek to end immediately after |
| opening |
|binary perform input and output in binary mode |
| (as opposed to text mode) |
|in open for input |
|out open for output |
|trunc truncate an existing stream when opening |
+---------------------------------------------------+
27.4.2.1.5 Type ios_base::seekdir [lib.ios::seekdir]
typedef T4 seekdir;
1 The type seekdir is an enumerated type (_lib.enumerated.types_) that
contains the elements indicated in Table 6:
Table 6--seekdir effects
+----------------------------------------------------------+
|Element Meaning |
+----------------------------------------------------------+
|beg request a seek (for subsequent input or output) |
| relative to the beginning of the stream |
|cur request a seek relative to the current position |
| within the sequence |
|end request a seek relative to the current end of |
| the sequence |
+----------------------------------------------------------+
27.4.2.1.6 Class ios_base::Init [lib.ios::Init]
namespace std {
class ios_base::Init {
public:
Init();
~Init();
private:
// static int init_cnt; exposition only
};
}
1 The class Init describes an object whose construction ensures the con
struction of the eight objects declared in <iostream>
(_lib.iostream.objects_) that associate file stream buffers with the
standard C streams provided for by the functions declared in <cstdio>
(_lib.c.files_).
2 For the sake of exposition, the maintained data is presented here as:
--static int init_cnt, counts the number of constructor and destructor
calls for class Init, initialized to zero.
Init();
Effects:
Constructs an object of class Init. If init_cnt is zero, the func
tion stores the value one in init_cnt, then constructs and initial
izes the objects cin, cout, cerr, clog (_lib.nar
row.stream.objects_), wcin, wcout, wcerr, and wclog
(_lib.wide.stream.objects_). In any case, the function then adds
one to the value stored in init_cnt.
~Init();
Effects:
Destroys an object of class Init. The function subtracts one from
the value stored in init_cnt and, if the resulting stored value is
one, calls cout.flush(), cerr.flush(), clog.flush(), wcout.flush(),
wcerr.flush(), wclog.flush().
27.4.2.2 ios_base fmtflags state functions [lib.fmtflags.state]
fmtflags flags() const;
Returns:
The format control information for both input and output.
fmtflags flags(fmtflags fmtfl);
Postcondition:
fmtfl == flags().
Returns:
The previous value of flags().
fmtflags setf(fmtflags fmtfl);
Effects:
Sets fmtfl in flags().
Returns:
The previous value of flags().
fmtflags setf(fmtflags fmtfl, fmtflags mask);
Effects:
Clears mask in flags(), sets fmtfl & mask in flags().
Returns:
The previous value of flags().
void unsetf(fmtflags mask);
Effects:
Clears mask in flags().
streamsize precision() const;
Returns:
The precision (number of digits after the decimal point) to generate
on certain output conversions.
streamsize precision(streamsize prec);
Postcondition:
prec == precision().
Returns:
The previous value of precision().
streamsize width() const;
Returns:
The minimum field width (number of characters) to generate on cer
tain output conversions.
streamsize width(streamsize wide);
Postcondition:
wide == width().
Returns:
The previous value of width().
27.4.2.3 ios_base locale functions [lib.ios.base.locales]
locale imbue(const locale loc);
Postcondition:
loc == getloc().
Returns:
The previous value of getloc().
locale getloc() const;
Effects:
Calls each registered callback pair (fn,index) (_lib.ios.base.call
back_) as (*fn)(imbue_event,*this,index) at such a time that a call
to ios_base::getloc() from within fn returns the new locale value
loc.
Returns:
If no locale has been imbued, a copy of the global C++ locale,
locale(), in effect at the time of construction. Otherwise, returns
the imbued locale, to be used to perform locale-dependent input and
output operations
27.4.2.4 ios_base static members [lib.ios.members.static]
bool sync_with_stdio(bool sync = true);
Returns:
true, the first time it is called; otherwise, returns true if the
standard iostream objects(_lib.iostream.objects_) are synchronized
and otherwise returns false.
Effects:
If any input or output operation has occurred using the standard
streams prior to the call, the effect is implementation-defined Oth
erwise, called with a false argument, it allows the standard streams
to operate independently of the standard C streams.
+------- BEGIN BOX 7 -------+
"independent operation" may be need a more careful definition.
+------- END BOX 7 -------+
27.4.2.5 ios_base storage functions [lib.ios.base.storage]
static int xalloc();
Returns:
index ++.
long& iword(int idx);
Effects:
If iarray is a null pointer, allocates an array of long of unspeci
fied size and stores a pointer to its first element in iarray. The
function then extends the array pointed at by iarray as necessary to
include the element iarray[idx]. Each newly allocated element of
the array is initialized to zero. The reference returned may become
invalid after another call to the object's iword member with a dif
ferent index, after a call to its copyfmt member, or when the object
is destroyed.
Returns:
iarray[idx].
void* & pword(int idx);
Effects:
If parray is a null pointer, allocates an array of pointers to void
of unspecified size and stores a pointer to its first element in
parray. The function then extends the array pointed at by parray as
necessary to include the element parray[idx]. Each newly allocated
element of the array is initialized to a null pointer. The refer
ence returned may become invalid after another call to the object's
pword member with a different index, after call to its copyfmt mem
ber, or when the object is destroyed.
Returns:
parray[idx].
Notes:
After a subsequent call to pword(int) for the same object, the ear
lier return value may no longer be valid.
27.4.2.6 ios_base callbacks [lib.ios.base.callback]
void register_callback(event_callback fn, int index);
Effects:
Registers the pair (fn,index) such that during calls to imbue()
_________________________
3) An implementation is free to implement both the integer array
pointed at by iarray and the pointer array pointed at by parray as
sparse data structures, possibly with a one-element cache for each.
(_lib.ios.base.locales_), copyfmt(), or ~ios_base()
(_lib.ios.base.cons_), the function fn is called with argument
index. Functions registered are called when an event occurs, in
opposite order of registration. Functions registered while a call
back function is active are not called until the next event.
Notes:
Identical pairs are not merged. A function registered twice will be
called twice.
27.4.2.7 ios_base constructors/destructors [lib.ios.base.cons]
ios_base();
Effects:
The ios_base members are have an indeterminate value after construc
tion.
Effects:
Destroys an object of class ios_base. Calls each registered call
back pair (fn,index) (_lib.ios.base.callback_) as
(*fn)(imbue_event,*this,index) at such time that any ios_base member
function called from within fn has well defined results.
27.4.3 Template class fpos [lib.fpos]
namespace std {
template <class stateT> class fpos {
public:
// _lib.fpos.cons_ Constructors
fpos(stateT);
// _lib.fpos.members_ Members
stateT state() const;
void state(stateT);
private;
stateT st; // exposition only
};
}
27.4.3.1 fpos Constructor [lib.fpos.cons]
fpos(stateT s)
Effects:
Constructs an object and assigns s to st An fpos will also contain
private information needed to position a file. This information is
initialized in an unspecified fashion.
27.4.3.2 fpos Members [lib.fpos.members]
void state(stateT s);
Effects:
Assign s to st.
stateT state();
Returns:
Current value of st.
27.4.4 fpos requirements [lib.fpos.operations]
1 Operations specified in Table 7 are permitted. In that table,
--P refers to an instance of fpos,
--p and q refer to an values of type P,
--O refers to type streamoff,
--o refers to a value of type streamoff, and
--i refers to a value of type int.
Table 7--Position type requirements
+-----------------------------------------------------------------------------------------+
|expression return type operational assertion/note |
| semantics pre/post-condition |
+-----------------------------------------------------------------------------------------+
|P(i) p == P(i) |
| note: a destructor is assumed. |
+-----------------------------------------------------------------------------------------+
|P p(i); |
|P p = i; post: p == P(i). |
+-----------------------------------------------------------------------------------------+
|P(o) POS_T converts from offset |
+-----------------------------------------------------------------------------------------+
|O(p) OFF_T converts to offset P(O(p)) == p |
+-----------------------------------------------------------------------------------------+
|p == q convertible to bool == is an equivalence relation |
+-----------------------------------------------------------------------------------------+
|p != q convertible to bool !(p==q) |
+-----------------------------------------------------------------------------------------+
|q = p + o POS_T + offset q-o == p |
|p += o |
+-----------------------------------------------------------------------------------------+
|q = p - o POS_T - offset q+o == p |
|p -= o |
+-----------------------------------------------------------------------------------------+
|o = p - q OFF_T distance q+o == p |
+-----------------------------------------------------------------------------------------+
[Note: Every implementation is required to supply overloaded opera
tors on fpos objects to satisfy the requirements of _lib.fpos.opera
tions_. It is unspecified whether these operators are members of
fpos, global operators, or provided in some other way. --end note]
2 Stream operations that return a value of type traits::pos_type return
P(O(-1)) as an invalid value to signal an error. If this value is
used as an argument to any istream, ostream, or streambufmember that
accepts a value of type traits::pos_type then the behavior of that
function is undefined.
27.4.5 Template class basic_ios [lib.ios]
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_ios : public ios_base {
public:
// Types:
typedef charT char_type;
typedef typename traits::int_type int_type;
typedef typename traits::pos_type pos_type;
typedef typename traits::off_type off_type;
typedef traits traits_type;
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;
void exceptions(iostate except);
// _lib.basic.ios.cons_ Constructor/destructor:
explicit basic_ios(basic_streambuf<charT,traits>* sb);
virtual ~basic_ios();
// _lib.basic.ios.members_ Members:
basic_ostream<charT,traits>* tie() const;
basic_ostream<charT,traits>* tie(basic_ostream<charT,traits>* tiestr);
basic_streambuf<charT,traits>* rdbuf() const;
basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb);
basic_ios& copyfmt(const basic_ios& rhs);
char_type fill() const;
char_type fill(char_type ch);
// _lib.ios.base.locales_ locales:
locale imbue(const locale& loc);
char narrow(char_type c, char dfault) const;
char_type widen(char c) const;
protected:
basic_ios();
void init(basic_streambuf<charT,traits>* sb);
};
}
27.4.5.1 basic_ios constructors [lib.basic.ios.cons]
explicit basic_ios(basic_streambuf<charT,traits>* sb);
Effects:
Constructs an object of class basic_ios, assigning initial values to
its member objects by calling init(sb).
basic_ios();
Effects:
Constructs an object of class basic_ios (_lib.ios.base.cons_) leav
ing its member objects uninitialized. The object must be initialized
by calling its init member function. If it is destroyed before it
has been initialized the behavior is undefined.
void init(basic_streambuf<charT,traits>* sb);
Postconditions:
The postconditions of this function are indicated in Table 8:
Table 8--ios_base() effects
+--------------------------------------------------------+
| Element Value |
+--------------------------------------------------------+
|rdbuf() sb |
|tie() 0 |
|rdstate() goodbit if sb is not a null pointer, |
| otherwise badbit. |
|exceptions() goodbit |
|flags() skipws | dec |
|width() 0 |
|precision() 6 |
|fill() the space character |
|getloc() a copy of the value returned by locale() |
|iarray a null pointer |
|parray a null pointer |
+--------------------------------------------------------+
+------- BEGIN BOX 8 -------+
Change: Removed index from the above table. It isn't a part of the
object.
+------- END BOX 8 -------+
+------- BEGIN BOX 9 -------+
What does "the space character" refer to?
+------- END BOX 9 -------+
27.4.5.2 Member functions [lib.basic.ios.members]
basic_ostream<charT,traits>* tie() const;
Returns:
An output sequence that is tied to (synchronized with) the sequence
controlled by the stream buffer.
basic_ostream<charT,traits>* tie(basic_ostream<charT,traits>* tiestr);
Postcondition:
tiestr == tie().
Returns:
The previous value of tie().
basic_streambuf<charT,traits>* rdbuf() const;
Returns:
A pointer to the streambuf associated with the stream.
basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb);
Postcondition:
sb == rdbuf().
Effects:
Calls clear().
+------- BEGIN BOX 10 -------+
Issue We need to consider whether the the the locale currently imbued
in the stream should be imbued into the streambuf.
+------- END BOX 10 -------+
Returns:
The previous value of rdbuf().
// _lib.ios.base.locales_ locales:
locale imbue(const locale& loc);
Effects:
Calls ios_base::imbue(loc) (_lib.ios.base.locales_) and if
rdbuf()!=0 then rdbuf()->pubimbue(loc) (_lib.streambuf.locales_).
Returns:
The prior value of ios_base::imbue().
char narrow(char_type c, char dfault) const;
Returns:
use_facet< ctype<char_type> >(getloc()).narrow(c,dfault)
char_type widen(char c) const;
Returns:
use_facet< ctype<char_type> >(getloc()).widen(c)
char_type fill() const
Returns:
The character used to pad (fill) an output conversion to the speci
fied field width.
char_type fill(char_type fillch);
Postcondition:
fillch == fill()
Returns:
The previous value of fill().
basic_ios& copyfmt(const basic_ios& rhs);
Effects:
Assigns to the member objects of *this the corresponding member
objects of rhs, except that:
--rdstate() and rdbuf() are left unchanged;
--exceptions() is altered last by calling exception(rhs.except).
--The contents of arrays pointed at by pword and iword are copied not
the pointers themselves.4)
1 If any newly stored pointer values in *this point at objects stored
outside the object rhs, and those objects are destroyed when rhs is
destroyed, the newly stored pointer values are altered to point at
newly constructed copies of the objects.
2 Before copying any parts of rhs, calls each registered callback pair
(fn,index) as (*fn)(ease_event,*this,index). After all parts but
exceptions() have been replaced, calls each callback pair that was
copied from rhs as (*fn)(copy_event,*this,index),.
Notes:
The second pass permits a copied pword value to be zeroed, or its
referent deep copied or reference counted or have other special
action taken.
Returns:
*this.
27.4.5.3 basic_ios iostate flags functions [lib.iostate.flags]
operator void*() const
Returns:
If fail() then a null pointer; otherwise some non-null pointer to
indicate success.
bool operator!() const
Returns:
fail().
_________________________
4) This suggests an infinite amount of copying, but the implementation
can keep track of the maximum element of the arrays that is non-zero.
iostate rdstate() const;
Returns:
The control state of the stream buffer.
void clear(iostate state = goodbit);
Postcondition:
If rdbuf()!=0 then state == rdstate(); otherwise
rdstate()==state|ios_base::badbit.
Effects:
If (rdstate() & exceptions()) == 0, returns. Otherwise, the func
tion throws an object fail of class basic_ios::failure
(_lib.ios::failure_), constructed with implementation-defined argu
ment values.
void setstate(iostate state);
Effects:
Calls clear(rdstate() | state) (which may throw basic_ios::failure
(_lib.ios::failure_)).
bool good() const;
Returns:
rdstate() == 0
bool eof() const;
Returns:
true if eofbit is set in rdstate().
bool fail() const;
Returns:
true if failbit or badbit is set in rdstate().5)
bool bad() const;
Returns:
true if badbit is set in rdstate().
iostate exceptions() const;
_________________________
5) Checking badbit also for fail() is historical practice.
Returns:
A mask that determines what elements set in rdstate() cause excep
tions to be thrown.
void exceptions(iostate except);
Postcondition:
except == exceptions().
Effects:
Calls clear(rdstate()).
27.4.6 ios_base manipulators [lib.std.ios.manip]
27.4.6.1 fmtflags manipulators [lib.fmtflags.manip]
ios_base& boolalpha(ios_base& str);
Effects:
Calls str.setf(ios_base::boolalpha).
Returns:
str.
ios_base& noboolalpha(ios_base& str);
Effects:
Calls str.unsetf(ios_base::boolalpha).
Returns:
str.
ios_base& showbase(ios_base& str);
Effects:
Calls str.setf(ios_base::showbase).
Returns:
str.
ios_base& noshowbase(ios_base& str);
Effects:
Calls str.unsetf(ios_base::showbase).
Returns:
str.
ios_base& showpoint(ios_base& str);
Effects:
Calls str.setf(ios_base::showpoint).
Returns:
str.
ios_base& noshowpoint(ios_base& str);
Effects:
Calls str.unsetf(ios_base::showpoint).
Returns:
str.
ios_base& showpos(ios_base& str);
Effects:
Calls str.setf(ios_base::showpos).
Returns:
str.
ios_base& noshowpos(ios_base& str);
Effects:
Calls str.unsetf(ios_base::showpos).
Returns:
str.
ios_base& skipws(ios_base& str);
Effects:
Calls str.setf(ios_base::skipws).
Returns:
str.
ios_base& noskipws(ios_base& str);
Effects:
Calls str.unsetf(ios_base::skipws).
Returns:
str.
ios_base& uppercase(ios_base& str);
Effects:
Calls str.setf(ios_base::uppercase).
Returns:
str.
ios_base& nouppercase(ios_base& str);
Effects:
Calls str.unsetf(ios_base::uppercase).
Returns:
str.
ios_base& unitbuf(ios_base& str);
Effects:
Calls str.setf(ios_base::unitbuf).
Returns:
str.
ios_base& nounitbuf(ios_base& str);
Effects:
Calls str.unsetf(ios_base::unitbuf).
Returns:
str.
27.4.6.2 adjustfield manipulators [lib.adjustfield.manip]
ios_base& internal(ios_base& str);
Effects:
Calls str.setf(ios_base::internal, ios_base::adjustfield).
Returns:
str.
ios_base& left(ios_base& str);
Effects:
Calls str.setf(ios_base::left, ios_base::adjustfield).
Returns:
str.
ios_base& right(ios_base& str);
Effects:
Calls str.setf(ios_base::right, ios_base::adjustfield).
Returns:
str.
27.4.6.3 basefield manipulators [lib.basefield.manip]
ios_base& dec(ios_base& str);
Effects:
Calls str.setf(ios_base::dec, ios_base::basefield).
Returns:
str.
ios_base& hex(ios_base& str);
Effects:
Calls str.setf(ios_base::hex, ios_base::basefield).
Returns:
str.
ios_base& oct(ios_base& str);
Effects:
Calls str.setf(ios_base::oct, ios_base::basefield).
Returns:
str.
27.4.6.4 floatfield manipulators [lib.floatfield.manip]
ios_base& fixed(ios_base& str);
Effects:
Calls str.setf(ios_base::fixed, ios_base::floatfield).
Returns:
str.
ios_base& scientific(ios_base& str);
Effects:
Calls str.setf(ios_base::scientific, ios_base::floatfield).
Returns:
str.
27.5 Stream buffers [lib.stream.buffers]
Header <streambuf> synopsis
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_streambuf;
typedef basic_streambuf<char> streambuf;
typedef basic_streambuf<wchar_t> wstreambuf;
}
_________________________
6) The function signature dec(ios_base&) can be called by the function
signature basic_ostream& stream::operator<<(ios_base& (*)(ios_base&))
to permit expressions of the form cout << dec to change the format
flags stored in cout.
1 The header <streambuf> defines types that control input from and out
put to character sequences.
27.5.1 Stream buffer requirements [lib.streambuf.reqts]
1 Stream buffers can impose various constraints on the sequences they
control. Some constraints are:
--The controlled input sequence can be not readable.
--The controlled output sequence can be not writable.
--The controlled sequences can be associated with the contents of
other representations for character sequences, such as external
files.
--The controlled sequences can support operations directly to or from
associated sequences.
--The controlled sequences can impose limitations on how the program
can read characters from a sequence, write characters to a sequence,
put characters back into an input sequence, or alter the stream
position.
2 Each sequence is characterized by three pointers which, if non-null,
all point into the same charT array object. The array object repre
sents, at any moment, a (sub)sequence of characters from the sequence.
Operations performed on a sequence alter the values stored in these
pointers, perform reads and writes directly to or from associated
sequences, and alter ``the stream position'' and conversion state as
needed to maintain this subsequence relationship. The three pointers
are:
--the beginning pointer, or lowest element address in the array
(called xbeg here);
--the next pointer, or next element address that is a current candi
date for reading or writing (called xnext here);
--the end pointer, or first element address beyond the end of the
array (called xend here).
3 The following semantic constraints shall always apply for any set of
three pointers for a sequence, using the pointer names given immedi
ately above:
--If xnext is not a null pointer, then xbeg and xend shall also be
non-null pointers into the same charT array, as described above;
otherwise, xbeg and xend shall also be null.
--If xnext is not a null pointer and xnext < xend for an output
sequence, then a write position is available. In this case, *xnext
shall be assignable as the next element to write (to put, or to
store a character value, into the sequence).
--If xnext is not a null pointer and xbeg < xnext for an input
sequence, then a putback position is available. In this case,
xnext[-1] shall have a defined value and is the next (preceding)
element to store a character that is put back into the input
sequence.
--If xnext is not a null pointer and xnext < xend for an input
sequence, then a read position is available. In this case, *xnext
shall have a defined value and is the next element to read (to get,
or to obtain a character value, from the sequence).
27.5.2 Template class [lib.streambuf]
basic_streambuf<charT,traits>
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_streambuf {
public:
// Types:
typedef charT char_type;
typedef typename traits::int_type int_type;
typedef typename traits::pos_type pos_type;
typedef typename traits::off_type off_type;
typedef traits traits_type;
virtual ~basic_streambuf();
// _lib.streambuf.locales_ locales:
locale pubimbue(const locale &loc);
locale getloc() const;
// _lib.streambuf.buffer_ buffer and positioning:
basic_streambuf<char_type,traits>*
pubsetbuf(char_type* s, streamsize n);
pos_type pubseekoff(off_type off, ios_base::seekdir way,
ios_base::openmode which = ios_base::in | ios_base::out);
pos_type pubseekpos(pos_type sp,
ios_base::openmode which = ios_base::in | ios_base::out);
int pubsync();
// Get and put areas:
// _lib.streambuf.pub.get_ Get area:
streamsize in_avail();
int_type snextc();
int_type sbumpc();
int_type sgetc();
streamsize sgetn(char_type* s, streamsize n);
// _lib.streambuf.pub.pback_ Putback:
int_type sputbackc(char_type c);
int_type sungetc();
// _lib.streambuf.pub.put_ Put area:
int_type sputc(char_type c);
streamsize sputn(const char_type* s, streamsize n);
protected:
basic_streambuf();
// _lib.streambuf.get.area_ Get area:
char_type* eback() const;
char_type* gptr() const;
char_type* egptr() const;
void gbump(int n);
void setg(char_type* gbeg, char_type* gnext, char_type* gend);
// _lib.streambuf.put.area_ Put area:
char_type* pbase() const;
char_type* pptr() const;
char_type* epptr() const;
void pbump(int n);
void setp(char_type* pbeg, char_type* pend);
// _lib.streambuf.virtuals_ virtual functions:
// _lib.streambuf.virt.locales_ Locales:
virtual void imbue(const locale &loc);
// _lib.streambuf.virt.buffer_ Buffer management and positioning:
virtual basic_streambuf<char_type,traits>*
setbuf(char_type* s, streamsize n);
virtual pos_type seekoff(off_type off, ios_base::seekdir way,
ios_base::openmode which = ios_base::in | ios_base::out);
virtual pos_type seekpos(pos_type sp,
ios_base::openmode which = ios_base::in | ios_base::out);
virtual int sync();
// _lib.streambuf.virt.get_ Get area:
virtual int showmanyc();
virtual streamsize xsgetn(char_type* s, streamsize n);
virtual int_type underflow();
virtual int_type uflow();
// _lib.streambuf.virt.pback_ Putback:
virtual int_type pbackfail(int_type c = traits::eof());
// _lib.streambuf.virt.put_ Put area:
virtual streamsize xsputn(const char_type* s, streamsize n);
virtual int_type overflow (int_type c = traits::eof());
};
}
1 The class template basic_streambuf<charT,traits> serves as an abstract
base class for deriving various stream buffers whose objects each con
trol two character sequences:
--a character input sequence;
--a character output sequence.
2 The class streambuf is an instantiation of the template class
basic_streambuf specialized by the type char.
3 The class wstreambuf is an instantiation of the template class
basic_streambuf specialized by the type wchar_t.
27.5.2.1 basic_streambuf constructors [lib.streambuf.cons]
basic_streambuf();
Effects:
Constructs an object of class basic_streambuf<charT,traits> and
initializes:7)
--all its pointer member objects to null pointers,
--the getloc() member to to a copy the global locale, locale(), at the
time of construction.
Notes:
Once the getloc() member is initialized, results of calling locale
member functions, and of members of facets so obtained, can safely
be cached until the next time the member imbue is called.
27.5.2.2 basic_streambuf public member [lib.streambuf.members]
functions
27.5.2.2.1 Locales [lib.streambuf.locales]
locale pubimbue(const locale& loc);
Postcondition:
loc == getloc().
Effects:
Calls imbue(loc).
Returns:
Previous value of getloc().
locale getloc() const;
Returns:
If pubimbue() has ever been called, then the last value of loc sup
plied, otherwise the current global locale, locale(). If called
after pubimbue() has been called but before pubimbue has returned
(i.e. from within the call of imbue()) then it returns the previous
value.
27.5.2.2.2 Buffer management and [lib.streambuf.buffer]
positioning
basic_streambuf<char_type,traits>* pubsetbuf(char_type* s, streamsize n);
_________________________
7) The default constructor is protected for class basic_streambuf to
assure that only objects for classes derived from this class may be
constructed.
Returns:
setbuf(s,n).
pos_type pubseekoff(off_type off, ios_base::seekdir way,
ios_base::openmode which = ios_base::in | ios_base::out);
Returns:
seekoff(off,way,which).
pos_type pubseekpos(pos_type sp,
ios_base::openmode which = ios_base::in | ios_base::out);
Returns:
seekpos(sp,which).
int pubsync();
Returns:
sync().
27.5.2.2.3 Get area [lib.streambuf.pub.get]
streamsize in_avail();
Returns:
If a read position is available, returns egptr() - gptr(). Other
wise returns showmanyc() (_lib.streambuf.virt.get_).
int_type snextc();
Effects:
Calls sbumpc().
Returns:
if that function returns traits::eof(), returns traits::eof(). Oth
erwise, returns sgetc().
int_type sbumpc();
Returns:
If the input sequence read position is not available, returns
uflow(). Otherwise, returns traits::to_int_type(*gptr()) and incre
ments the next pointer for the input sequence.
int_type sgetc();
Returns:
If the input sequence read position is not available, returns
underflow(). Otherwise, returns traits::to_int_type(*gptr()).
streamsize sgetn(char_type* s, streamsize n);
Returns:
xsgetn(s,n).
27.5.2.2.4 Putback [lib.streambuf.pub.pback]
int_type sputbackc(char_type c);
Returns:
If the input sequence putback position is not available, or if
traits::eq(c,gptr()[-1]) is false, returns pback
fail(traits::to_int_type(c)). Otherwise, decrements the next
pointer for the input sequence and returns
traits::to_int_type(*gptr()).
int_type sungetc();
Returns:
If the input sequence putback position is not available, returns
pbackfail(). Otherwise, decrements the next pointer for the input
sequence and returns traits::to_int_type(*gptr()).
27.5.2.2.5 Put area [lib.streambuf.pub.put]
int_type sputc(char_type c);
Returns:
If the output sequence write position is not available, returns
overflow(traits::to_int_type(c)). Otherwise, stores c at the next
pointer for the output sequence, increments the pointer, and returns
traits::to_int_type(c).
streamsize sputn(const char_type* s, streamsize n);
Returns:
xsputn(s,n).
27.5.2.3 basic_streambuf protected [lib.streambuf.protected]
member functions
27.5.2.3.1 Get area access [lib.streambuf.get.area]
char_type* eback() const;
Returns:
The beginning pointer for the input sequence.
char_type* gptr() const;
Returns:
The next pointer for the input sequence.
char_type* egptr() const;
Returns:
The end pointer for the input sequence.
void gbump(int n);
Effects:
Advances the next pointer for the input sequence by n.
void setg(char_type* gbeg, char_type* gnext, char_type* gend);
Postconditions:
gbeg == eback(), gnext == gptr(), and gend == egptr().
27.5.2.3.2 Put area access [lib.streambuf.put.area]
char_type* pbase() const;
Returns:
The beginning pointer for the output sequence.
char_type* pptr() const;
Returns:
The next pointer for the output sequence.
char_type* epptr() const;
Returns:
The end pointer for the output sequence.
void pbump(int n);
Effects:
Advances the next pointer for the output sequence by n.
void setp(char_type* pbeg, char_type* pend);
Postconditions:
pbeg == pbase(), pbeg == pptr(), and pend == epptr().
27.5.2.4 basic_streambuf virtual [lib.streambuf.virtuals]
functions
27.5.2.4.1 Locales [lib.streambuf.virt.locales]
void imbue(const locale&)
Effects:
Change any translations based on locale.
Notes:
Allows the derived class to be informed of changes in locale at the
time they occur. Between invocations of this function a class
derived from streambuf can safely cache results of calls to locale
functions and to members of facets so obtained.
Default behavior:
Does nothing.
27.5.2.4.2 Buffer management and [lib.streambuf.virt.buffer]
positioning
basic_streambuf* setbuf(char_type* s, streamsize n);
Effects:
Performs an operation that is defined separately for each class
derived from basic_streambuf in this clause (_lib.stringbuf.virtu
als_, _lib.filebuf.virtuals_).
Default behavior:
If gptr() is non-null and gptr()!=egptr() then do nothing. Returns
this.
pos_type seekoff(off_type off, ios_base::seekdir way,
ios_base::openmode which
= ios_base::in | ios_base::out);
Effects:
Alters the stream positions within one or more of the controlled
sequences in a way that is defined separately for each class derived
from basic_streambuf in this clause (_lib.stringbuf.virtuals_,
_lib.filebuf.virtuals_).
Default behavior:
Returns an object of class pos_type that stores an invalid stream
position (_lib.iostreams.definitions_).
pos_type seekpos(pos_type sp,
ios_base::openmode which = in | out);
Effects:
Alters the stream positions within one or more of the controlled
sequences in a way that is defined separately for each class derived
from basic_streambuf in this clause (_lib.stringbuf_, _lib.file
buf_).
Default behavior:
Returns an object of class pos_type that stores an invalid stream
position.
int sync();
Effects:
Synchronizes the controlled sequences with the arrays. That is, if
pbase() is non-null the characters between pbase() and pptr() are
written to the controlled sequence. The pointers may then be reset
as appropriate.
Returns:
-1 on failure. What constitutes failure is determined by each
derived class (_lib.filebuf.virtuals_).
Default behavior:
Returns zero.
27.5.2.4.3 Get area [lib.streambuf.virt.get]
int showmanyc();8)
Returns:
an estimate of the number of characters available in the sequence,
or -1. If it returns a positive value, then successive calls to
underflow() will not return traits::eof() until at least that number
of characters have been supplied. If showmanyc() returns -1, then
calls to underflow() or uflow() will fail.9)
Default behavior:
Returns zero.
Notes:
Uses traits::eof().
streamsize xsgetn(char_type* s, streamsize n);
Effects:
Assigns up to n characters to successive elements of the array whose
_________________________
8) The morphemes of showmanyc are "es-how-many-see", not "show-manic".
9) underflow or uflow might fail by throwing an exception prematurely.
The intention is not only that the calls will not return eof() but
that they will return ``immediately.''
first element is designated by s. The characters assigned are read
from the input sequence as if by repeated calls to sbumpc().
Assigning stops when either n characters have been assigned or a
call to sbumpc() would return traits::eof().
Returns:
The number of characters assigned.10)
Notes:
Uses traits::eof().
int_type underflow();
Notes:
The public members of basic_streambuf call this virtual function
only if gptr() is null or gptr() >= egptr()
Returns:
traits::to_int_type(c), where c is the first character of the pend
ing sequence, without moving the input sequence position past it.
If the pending sequence is null then the function returns
traits::eof() to indicate failure.
1 The pending sequence of characters is defined as the concatenation of:
a)If gptr() is non- NULL, then the egptr() - gptr() characters start
ing at gptr(), otherwise the empty sequence.
b)Some sequence (possibly empty) of characters read from the input
sequence.
2 The result character is
a)If the pending sequence is non-empty, the first character of the
sequence.
b)If the pending sequence empty then the next character that would be
read from the input sequence.
3 The backup sequence is defined as the concatenation of:
a)If eback() is null then empty,
b)Otherwise the gptr() - eback() characters beginning at eback().
Effects:
The function sets up the gptr() and egptr() satisfying one of:
a)If the pending sequence is non-empty, egptr() is non-null and
egptr() - gptr() characters starting at gptr() are the characters in
the pending sequence
_________________________
10) Classes derived from basic_streambuf can provide more efficient
ways to implement xsgetn() and xsputn() by overriding these defini
tions from the base class.
b)If the pending sequence is empty, either gptr() is null or gptr()
and egptr() are set to the same non-NULL pointer.
4 If eback() and gptr() are non-null then the function is not con
strained as to their contents, but the ``usual backup condition'' is
that either:
a)If the backup sequence contains at least gptr() - eback() charac
ters, then the gptr() - eback() characters starting at eback() agree
with the last gptr() - eback() characters of the backup sequence.
b)Or the n characters starting at gptr() - n agree with the backup
sequence (where n is the length of the backup sequence)
Default behavior:
Returns traits::eof().
int_type uflow();
Requires:
The constraints are the same as for underflow(), except that the
result character is transferred from the pending sequence to the
backup sequence, and the pending sequence may not be empty before
the transfer.
Default behavior:
Calls underflow(). If underflow() returns traits::eof(), returns
traits::eof(). Otherwise, returns the value of
traits::to_int_type(*gptr()) and increment the value of the next
pointer for the input sequence.
Returns:
traits::eof() to indicate failure.
27.5.2.4.4 Putback [lib.streambuf.virt.pback]
int_type pbackfail(int_type c = traits::eof());
Notes:
The public functions of basic_streambuf call this virtual function
only when gptr() is null, gptr() == eback(), or
traits::eq(*gptr(),traits::to_char_type(c)) returns false. Other
calls shall also satisfy that constraint.
The pending sequence is defined as for underflow(), with the modifi
cations that
--If traits::eq_int_type(c,traits::eof()) returns true, then the input
sequence is backed up one character before the pending sequence is
determined.
--If traits::eq_int_type(c,traits::eof()) return false, then c is
prepended. Whether the input sequence is backed up or modified in
any other way is unspecified.
Postcondition:
On return, the constraints of gptr(), eback(), and pptr() are the
same as for underflow().
Returns:
traits::eof() to indicate failure. Failure may occur because the
input sequence could not be backed up, or if for some other reason
the pointers could not be set consistent with the constraints.
pbackfail() is called only when put back has really failed.
Returns some value other than traits::eof() to indicate success.
Default behavior:
Returns traits::eof().
27.5.2.4.5 Put area [lib.streambuf.virt.put]
streamsize xsputn(const char_type* s, streamsize n);
Effects:
Writes up to n characters to the output sequence as if by repeated
calls to sputc(c). The characters written are obtained from succes
sive elements of the array whose first element is designated by s.
Writing stops when either n characters have been written or a call
to sputc(c) would return traits::eof().
Returns:
The number of characters written.
int_type overflow(int_type c = traits::eof());
Effects:
Consumes some initial subsequence of the characters of the pending
sequence. The pending sequence is defined as the concatenation of
a)if pbase() is NULL then the empty sequence otherwise, pptr() -
pbase() characters beginning at pbase().
b)if traits::eq_int_type(c,traits::eof()) returns true, then the empty
sequence otherwise, the sequence consisting of c.
Notes:
The member functions sputc() and sputn() call this function in case
that no room can be found in the put buffer enough to accomodate the
argument character sequence.
Requires:
Every overriding definition of this virtual function shall obey the
following constraints:
1)The effect of consuming a character on the associated output
sequence is specified11)
2)Let r be the number of characters in the pending sequence not
_________________________
11) That is, for each class derived from an instance of basic_stream
buf in this clause (_lib.stringbuf_, _lib.filebuf_), a specification
of how consuming a character effects the associated output sequence is
given. There is no requirement on a program-defined class.
consumed. If r is non-zero then pbase() and pptr() must be set so
that: pptr() - pbase() == r and the r characters starting at pbase()
are the associated output stream. In case r is zero (all charac
ters of the pending sequence have been consumed) then either pbase()
is set to NULL, or pbase() and pptr() are both set to the same non-
NULL value.
3)The function may fail if either appending some character to the
associated output stream fails or if it is unable to establish
pbase() and pptr() according to the above rules.
Returns:
traits::eof() or throws an exception if the function fails.
Otherwise, returns some value other than traits::eof() to indicate
success.12)
Default behavior:
Returns traits::eof().
27.6 Formatting and manipulators [lib.iostream.format]
Header <istream> synopsis
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_istream;
typedef basic_istream<char> istream;
typedef basic_istream<wchar_t> wistream;
template <class charT, class traits>
basic_istream<charT,traits>& ws(basic_istream<charT,traits>& is);
}
Header <ostream> synopsis
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_ostream;
typedef basic_ostream<char> ostream;
typedef basic_ostream<wchar_t> wostream;
template <class charT, class traits>
basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);
template <class charT, class traits>
basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);
template <class charT, class traits>
basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);
}
Header <iomanip> synopsis
_________________________
12) Typically, overflow returns c to indicate success, except when
traits::eq_int_type(c,traits::eof()) returns true, in which case it
returns traits::not_eof(c).
namespace std {
// Types T1, T2, ... are unspecified
// implementation types
T1 resetiosflags(ios_base::fmtflags mask);
T2 setiosflags (ios_base::fmtflags mask);
T3 setbase(int base);
T4 setfill(int c);
T5 setprecision(int n);
T6 setw(int n);
}
27.6.1 Input streams [lib.input.streams]
1 The header <istream> defines two types and a function signature that
control input from a stream buffer.
27.6.1.1 Template class basic_istream [lib.istream]
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_istream : virtual public basic_ios<charT,traits> {
public:
// Types:
typedef charT char_type;
typedef typename traits::int_type int_type;
typedef typename traits::pos_type pos_type;
typedef typename traits::off_type off_type;
typedef traits traits_type;
// _lib.istream.cons_ Constructor/destructor:
explicit basic_istream(basic_streambuf<charT,traits>* sb);
virtual ~basic_istream();
// _lib.istream::sentry_ Prefix/suffix:
class sentry;
// _lib.istream.formatted_ Formatted input:
basic_istream<charT,traits>& operator>>
(basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&))
basic_istream<charT,traits>& operator>>
(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&))
basic_istream<charT,traits>& operator>>
(ios_base& (*pf)(ios_base&))
basic_istream<charT,traits>& operator>>(bool& n);
basic_istream<charT,traits>& operator>>(short& n);
basic_istream<charT,traits>& operator>>(unsigned short& n);
basic_istream<charT,traits>& operator>>(int& n);
basic_istream<charT,traits>& operator>>(unsigned int& n);
basic_istream<charT,traits>& operator>>(long& n);
basic_istream<charT,traits>& operator>>(unsigned long& n);
basic_istream<charT,traits>& operator>>(float& f);
basic_istream<charT,traits>& operator>>(double& f);
basic_istream<charT,traits>& operator>>(long double& f);
basic_istream<charT,traits>& operator>>(void*& p);
basic_istream<charT,traits>& operator>>
(basic_streambuf<char_type,traits>* sb);
// _lib.istream.unformatted_ Unformatted input:
streamsize gcount() const;
int_type get();
basic_istream<charT,traits>& get(char_type& c);
basic_istream<charT,traits>& get(char_type* s, streamsize n,
char_type delim = traits::newline());
basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb,
char_type delim = traits::newline());
basic_istream<charT,traits>& getline(char_type* s, streamsize n);
basic_istream<charT,traits>& getline(char_type* s, streamsize n,
char_type delim);
basic_istream<charT,traits>& ignore
(streamsize n = 1, int_type delim = traits::eof());
int_type peek();
basic_istream<charT,traits>& read (char_type* s, streamsize n);
streamsize readsome(char_type* s, streamsize n);
basic_istream<charT,traits>& putback(char_type c);
basic_istream<charT,traits>& unget();
int sync();
pos_type tellg();
basic_istream<charT,traits>& seekg(pos_type);
basic_istream<charT,traits>& seekg(off_type, ios_base::seekdir);
};
// _lib.istream::extractors_ character extraction templates
template<class charT, class traits>
basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&,
charT&);
template<class traits>
basic_istream<char,traits>& operator>>(basic_istream<char,traits>&,
unsigned char&);
template<class traits>
basic_istream<char,traits>& operator>>(basic_istream<char,traits>&,
signed char&);
template<class charT, class traits>
basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&,
charT*);
template<class traits>
basic_istream<char,traits>& operator>>(basic_istream<charT,traits>&,
unsigned char*);
template<class traits>
basic_istream<char,traits>& operator>>(basic_istream<charT,traits>&,
signed char*);
}
1 The class basic_istream defines a number of member function signatures
that assist in reading and interpreting input from sequences con
trolled by a stream buffer.
2 Two groups of member function signatures share common properties: the
formatted input functions (or extractors) and the unformatted input
functions. Both groups of input functions are described as if they
obtain (or extract) input characters by calling rdbuf()->sbumpc() or
rdbuf()->sgetc(). They may use other public members of istream.
3 If rdbuf()->sbumpc() or rdbuf()->sgetc() returns traits::eof(), then
the input function, except as explicitly noted otherwise, completes
its actions and does setstate(eofbit), which may throw ios_base::fail
ure (_lib.iostate.flags_), before returning.
4 If one of these called functions throws an exception, then unless
explicitly noted otherwise, the input function sets badbit in error
state. If badbit is on in exception(), the input function rethrows
the exception without completing its actions, otherwise it does not
throw anything and proceeds as if the called function had returned a
failure indication.
27.6.1.1.1 basic_istream constructors [lib.istream.cons]
explicit basic_istream(basic_streambuf<charT,traits>* sb);
Effects:
Constructs an object of class basic_istream, assigning initial val
ues to the base class by calling basic_ios::init(sb)
(_lib.basic.ios.cons_).
Postcondition:
gcount() == 0
virtual ~basic_istream();
Effects:
Destroys an object of class basic_istream.
Notes:
Does not perform any operations of rdbuf().
27.6.1.1.2 Class basic_istream::sentry [lib.istream::sentry]
namespace std {
template <class charT,class traits = char_traits<charT> >
class basic_istream<charT,traits>::sentry {
typedef traits traits_type;
bool ok_; // exposition only
public:
explicit sentry(basic_istream<charT,traits>& is, bool noskipws = false);
~sentry();
operator bool() { return ok_; }
};
}
+------- BEGIN BOX 11 -------+
traits_type was added by Stockholm motion that refered to all classes
that have traits although it seems silly here.
+------- END BOX 11 -------+
1 The class sentry defines a class that is responsible for doing excep
tion safe prefix and suffix operations.
explicit sentry(basic_istream<charT,traits>& is, bool noskipws = false);
Effects:
If is.good() is true, prepares for formatted or unformatted input.
First, if is.tie() is not a null pointer, the function calls
is.tie()->flush() to synchronize the output sequence with any asso
ciated external C stream.13) If noskipws is zero and is.flags() &
ios_base::skipws is nonzero, the function extracts and discards each
character as long as the next available input character c is a
whitespace character.
Notes:
The constructor explicit sentry(basic_istream<charT,traits>& is,
bool noskipws = false) uses the currently imbued locale in is , to
determine whether the next input character is whitespace or not.
To decide if the character c is a whitespace character, the con
structor performs ``as if'' it executes the following code fragment:
const ctype<charT>& ctype = use_facet<ctype<charT> >(is.getloc());
if (ctype.is(ctype.space,c)!=0)
// c is a whitespace character.
If, after any preparation is completed, is.good() is true, ok_ !=
false otherwise, ok_ == false. During preparation, the constructor
may call setstate(failbit) (which may throw ios_base::failure
(_lib.iostate.flags_))14)
2 [Example: A typical implementation of the sentry constructor might
include code such as:
template <class charT, class traits = char_traits<charT> >
basic_istream<charT,traits>::sentry(
basic_istream<charT,traits>& is, bool noskipws = false) {
...
int_type c;
typedef ctype<charT> ctype_type;
const ctype_type& ctype = use_facet<ctype_type>(is.getloc());
while ((c = is.rdbuf()->snextc()) != traits::eof()) {
if (ctype.is(ctype.space,c)==0) {
is.rdbuf()->sputbackc (c);
break;
}
}
...
}
--end example]
_________________________
13) The call is.tie()->flush() does not necessarily occur if the func
tion can determine that no synchronization is necessary.
14) The sentry constructor and destructor can also perform additional
implementation-dependent operations.
~sentry();
Effects:
None.
operator bool();
Effects:
Returns ok_.
27.6.1.2 Formatted input functions [lib.istream.formatted]
27.6.1.2.1 Common requirements [lib.istream.formatted.reqmts]
1 Each formatted input function begins execution by constructing an
object of class sentry with the noskipws (second) argument false. If
the sentry object returns true, when converted to a value of type
bool, the function endeavors to obtain the requested input. If an
exception is thrown during input then ios::badbit is turned on15) in
*this's error state. If (exception()&badbit)!= 0 then the exception
is rethrown In any case, the formatted input function destructs the
sentry object. If no exception has been thrown it returns *this
27.6.1.2.2 Arithmetic [lib.istream.formatted.arithmetic]
Extractors
operator>>(short& val);
operator>>(unsigned short& val);
operator>>(int& val);
operator>>(unsigned int& val);
operator>>(long& val);
operator>>(unsigned long& val);
operator>>(float& val);
operator>>(double& val);
operator>>(long double& val);
operator>>(bool& val);
operator>>(void*& val);
As in the case of the inserters, these extractors depend on the
locale's num_get<> (_lib.locale.num.get_) object to perform parsing
the input stream data. The conversion occurs as if performed by the
following code fragment:
typedef num_get< charT,istreambuf_iterator<charT,traits> > numget;
iostate err = 0;
use_facet< numget >(loc).get(*this, 0, *this, err, val);
setstate(err);
In the above fragment, loc stands for the private member of the
_________________________
15) This is done without causing an ios::failure to be thrown.
basic_ios class, [Note: The first argument provides an object of the
istream_iterator class which is an iterator pointed to an input
stream. It bypasses istreams and uses streambufs directly. Class
--end note] locale relies on this type as its interface to istream,
since the flexibility it has been abstracted away from direct depen
dence on istream.
27.6.1.2.3 basic_istream::operator>> [lib.istream::extractors]
basic_istream<charT,traits>& operator>>
(basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&))
Returns:
pf(*this).16)
basic_istream<charT,traits>& operator>>
(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&));
Effects:
Calls pf(*this).
Returns:
*this.
basic_istream<charT,traits>& operator>>
(ios_base& (*pf)(ios_base&));
Effects:
Calls pf(*this).17)
Returns:
*this.
template<class charT, class traits>
basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>& in,
charT* s);
template<class traits>
basic_istream<char,traits>& operator>>(basic_istream<char,traits>& in,
unsigned char* s);
template<class traits>
basic_istream<char,traits>& operator>>(basic_istream<char,traits>& in,
signed char* s);
Effects:
Behaves like a formatted input member (as described in
_________________________
16) See, for example, the function signature ws(basic_istream&)
(_lib.istream.manip_).
17) See, for example, the function signature dec(ios_base&)
(_lib.basefield.manip_).
_lib.istream.formatted.reqmts_) of in. After a sentry object is
constructed, operator>> extracts characters and stores them into
successive locations of an array whose first element is designated
by s. If width() is greater than zero, n is width(). Otherwise n
is the the number of elements of the largest array of char_type that
can store a terminating eos. n is the maximum number of characters
stored.
1 Characters are extracted and stored until any of the following occurs:
--n-1 characters are stored;
--end of file occurs on the input sequence;
--ct.is(ct.space,c) is true for the next available input character c,
where ct is use_facet<ctype<charT> >(in.getloc()).
--A null byte ( traits::eos()) in the next position, which may be the
first position if no characters were extracted.
operator>> then calls width(0).
2 If the function extracted no characters, it calls setstate(failbit),
which may throw ios_base::failure (_lib.iostate.flags_).
Returns:
in.
template<class charT, class traits>
basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>& in,
charT& c);
template<class traits>
basic_istream<char,traits>& operator>>(basic_istream<char,traits>& in,
unsigned char& c);
template<class traits>
basic_istream<char,traits>& operator>>(basic_istream<char,traits>& in,
signed char& c);
Effects:
Behaves like a formatted input member (as described in
_lib.istream.formatted.reqmts_) of in. After a sentry object is
constructed a character is extracted from in, if one is available,
and stored in c. Otherwise, the function calls in.setstate(fail
bit).
Returns:
in.
basic_istream<charT,traits>& operator>>
(basic_streambuf<charT,traits>* sb);
Effects:
If sb is null, calls setstate(failbit), which may throw
ios_base::failure (_lib.iostate.flags_).
Extracts characters from *this and inserts them in the output
sequence controlled by sb. Characters are extracted and inserted
until any of the following occurs:
--end-of-file occurs on the input sequence;
--inserting in the output sequence fails (in which case the character
to be inserted is not extracted);
--an exception occurs (in which case the exception is caught).
If the function inserts no characters, it calls setstate(failbit),
which may throw ios_base::failure (_lib.iostate.flags_). If failure
was due to catching an exception thrown while extracting characters
from sb and failbit is on in exceptions() (_lib.iostate.flags_),
then the caught exception is rethrown.
Returns:
*this.
27.6.1.3 Unformatted input functions [lib.istream.unformatted]
1 Each unformatted input function begins execution by constructing an
object of class sentry with the default argument noskipws (second)
argument true. If the sentry object returns true, when converted to a
value of type bool, the function endeavors to obtain the requested
input. If an exception is thrown during input then ios::badbit is
turned on18) in *this's error state. If (exception()&badbit)!= 0 then
the exception is rethrown It also counts the number of characters
extracted. If no exception has been thrown it ends by storing the
count in a member object and returning the value specified. In any
event the sentry object is destroyed before leaving the unformatted
input function.
+------- BEGIN BOX 12 -------+
Change: The sentence dealing with exceptions was added in this draft.
Aggressive editing in this area was authorized after Monterey, and
this change should have been made for Stockholm.
+------- END BOX 12 -------+
streamsize gcount() const;
Returns:
The number of characters extracted by the last unformatted input
member function called for the object.
int_type get();
_________________________
18) This is done without causing an ios::failure to be thrown.
Effects:
Extracts a character c, if one is available. Otherwise, the func
tion calls setstate(failbit), which may throw ios_base::failure
(_lib.iostate.flags_),
Returns:
c if available, otherwise traits::eof().
basic_istream<charT,traits>& get(char_type& c);
Effects:
Extracts a character, if one is available, and assigns it to c.19)
Otherwise, the function calls setstate(failbit) (which may throw
ios_base::failure (_lib.iostate.flags_)).
Returns:
*this.
basic_istream<charT,traits>& get(char_type* s, streamsize n,
char_type delim = traits::newline());
Effects:
Extracts characters and stores them into successive locations of an
array whose first element is designated by s.20) Characters are
extracted and stored until any of the following occurs:
--n - 1 characters are stored;
--end-of-file occurs on the input sequence (in which case the function
calls setstate(eofbit));
--c == delim for the next available input character c (in which case c
is not extracted).
2 If the function stores no characters, it calls setstate(failbit)
(which may throw ios_base::failure (_lib.iostate.flags_)). In any
case, it then stores a null character into the next successive loca
tion of the array.
Returns:
*this.
basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb,
char_type delim = traits::newline());
Effects:
Extracts characters and inserts them in the output sequence
_________________________
19) Note that this function is not overloaded on types signed charand
unsigned char.
20) Note that this function is not overloaded on types signed char and
unsigned char.
controlled by sb. Characters are extracted and inserted until any
of the following occurs:
--end-of-file occurs on the input sequence;
--inserting in the output sequence fails (in which case the character
to be inserted is not extracted);
--c == delim for the next available input character c (in which case c
is not extracted);
--an exception occurs (in which case, the exception is caught but not
rethrown).
3 If the function inserts no characters, it calls setstate(failbit),
which may throw ios_base::failure (_lib.iostate.flags_).
Returns:
*this.
basic_istream<charT,traits>& getline(char_type* s, streamsize n,
char_type delim);
Effects:
Extracts characters and stores them into successive locations of an
array whose first element is designated by s.21) Characters are
extracted and stored until one of the following occurs:
1)end-of-file occurs on the input sequence (in which case the function
calls setstate(eofbit));
2)c == delim for the next available input character c (in which case
the input character is extracted but not stored);22)
3)n - 1 characters are stored (in which case the function calls set
state(failbit)).
4 These conditions are tested in the order shown.23)
5 If the function extracts no characters, it calls setstate(failbit)
(which may throw ios_base::failure (_lib.iostate.flags_)).24)
_________________________
21) Note that this function is not overloaded on types signed char and
unsigned char.
22) Since the final input character is ``extracted,'' it is counted in
the gcount(), even though it is not stored.
23) This allows an input line which exactly fills the buffer, without
setting failbit. This is different behavior than the historical AT&T
implementation.
24) This implies an empty input line will not cause failbit to be set.
6 In any case, it then stores a null character (using traits::eos())
into the next successive location of the array.
Returns:
*this.
7 [Example:
#include <iostream>
int main()
{
using namespace std;
const int line_buffer_size = 100;
char buffer[line_buffer_size];
int line_number = 0;
while (cin.getline(buffer, line_buffer_size, '\n') || cin.gcount()) {
int count = cin.gcount();
if (cin.eof())
cout << "Partial final line"; // cin.fail() is false
else if (cin.fail()) {
cout << "Partial long line";
cin.clear(cin.rdstate() & ~ios::failbit);
} else {
count--; // Don't include '\n' in count
cout << "Line " << ++line_number;
}
cout << " (" << count << " chars): " << buffer << endl;
}
}
--end example]
basic_istream<charT,traits>& getline(char_type* s, streamsize n);
Returns:
getline(p,n,widen('\n'))
basic_istream<charT,traits>&
ignore(int n = 1, int_type delim = traits::eof());
Effects:
Extracts characters and discards them. Characters are extracted
until any of the following occurs:
--if n != numeric_limits<int>::max() (_lib.limits_), n characters are
extracted
--end-of-file occurs on the input sequence (in which case the function
calls setstate(eofbit), which may throw ios_base::failure
(_lib.iostate.flags_));
--c == delim for the next available input character c (in which case c
is extracted).
Notes:
The last condition will never occur if delim == traits::eof().
Returns:
*this.
int_type peek();
Returns:
traits::eof() if good() is false. Otherwise, returns
rdbuf()->sgetc().
basic_istream<charT,traits>& read(char_type* s, streamsize n);
Effects:
Extracts characters and stores them into successive locations of an
array whose first element is designated by s.25) Characters are
extracted and stored until either of the following occurs:
--n characters are stored;
--end-of-file occurs on the input sequence (in which case the function
calls setstate(failbit), which may throw ios_base::failure
(_lib.iostate.flags_)).
Returns:
*this.
streamsize readsome(char_type* s, streamsize n);
Effects:
If !good() calls setstate(failbit) which may throw an exception, and
return. Otherwise extracts characters and stores them into succes
sive locations of an array whose first element is designated by s.
If rdbuf()->in_avail() == -1, calls setstate(eofbit) (which may
throw ios_base::failure (_lib.iostate.flags_)), and extracts no
characters;
--If rdbuf()->in_avail() == 0, extracts no characters
--If rdbuf()->in_avail() > 0, extracts min(rdbuf()->in_avail(),n)).
Returns:
The number of characters extracted.
basic_istream<charT,traits>& putback(char_type c);
_________________________
25) Note that this function is not overloaded on types signed char and
unsigned char.
Effects:
If !good() calls setstate(failbit) which may throw an exception, and
return. If rdbuf() is not null, calls rdbuf->sputbackc() . If
rdbuf() is null, or if sputback() returns traits::eof(), calls set
state(badbit) (which may throw ios_base::failure
(_lib.iostate.flags_)).
Returns:
*this.
basic_istream<charT,traits>& unget();
Effects:
If !good() calls setstate(failbit) which may throw an exception, and
return. If rdbuf() is not null, calls rdbuf()->sungetc(). If
rdbuf() is null, or if sungetc() returns traits::eof(), calls set
state(badbit) (which may throw ios_base::failure
(_lib.iostate.flags_)).
Returns:
*this.
int sync();
Effects:
If rdbuf() is a null pointer, returns -1 . Otherwise, calls
rdbuf()->pubsync() and, if that function returns -1 calls set
state(badbit) (which may throw ios_base::failure
(_lib.iostate.flags_), and returns traits::eof(). Otherwise,
returns zero.
pos_type tellg();
Returns:
if fail() != false, returns pos_type(-1) to indicate failure. Oth
erwise, returns rdbuf()->pubseekoff(0, cur, in).
basic_istream<charT,traits>& seekg(pos_type pos);
Effects:
If fail() != true, executes rdbuf()->pubseekpos(pos).
Returns:
*this.
basic_istream<charT,traits>& seekg(off_type& off, ios_base::seekdir dir);
Effects:
If fail() != true, executes rdbuf()->pubseekoff(off, dir).
Returns:
*this.
27.6.1.4 Standard basic_istream manipulators [lib.istream.manip]
namespace std {
template <class charT, class traits>
basic_istream<charT,traits>& ws(basic_istream<charT,traits>& is);
}
Effects:
Extracts characters as long as the next available character c is
whitespace or until there are no more characters in the sequence.
Whitespace characters are distinguished with the same criterion as
used by sentry::sentry. [_lib.istream::sentry]. If ws stops
extracting characters because there are no more available it sets
eofbit, but not failbit.
Returns:
is.
27.6.1.5 Template class basic_iostream [lib.iostreamclass]
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_iostream :
public basic_istream<charT,traits>,
public basic_ostream<charT,traits> {
public:
// constructor/destructor
explicit basic_iostream(basic_streambuf<charT,traits>* sb);
virtual ~basic_iostream();
};
}
1 The class basic_iostream inherits a number of functions that allow
reading input and writing output to sequences controlled by a stream
buffer.
27.6.1.5.1 basic_iostream constructors [lib.iostream.cons]
explicit basic_iostream(basic_streambuf<charT,traits>* sb);
Effects
Constructs an object of class basic_iostream, assigning initial val
ues to the base classes by calling basic_istream<charT,traits>(sb)
(_lib.istream_) and basic_ostream<charT,traits>(sb) (_lib.ostream_)
Postcondition:
rdbuf()==sb and gcount()==0.
27.6.1.5.2 basic_iostream destructor [lib.iostream.dest]
virtual ~basic_iostream();
Effects:
Destroys an object of class basic_iostream.
Notes:
Does not perform any operations on rdbuf().
27.6.2 Output streams [lib.output.streams]
1 The header <ostream> defines a type and several function signatures
that control output to a stream buffer.
27.6.2.1 Template class basic_ostream [lib.ostream]
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_ostream : virtual public basic_ios<charT,traits> {
public:
// Types:
typedef charT char_type;
typedef typename traits::int_type int_type;
typedef typename traits::pos_type pos_type;
typedef typename traits::off_type off_type;
// _lib.ostream.cons_ Constructor/destructor:
explicit basic_ostream(basic_streambuf<char_type,traits>* sb);
virtual ~basic_ostream();
// _lib.ostream::sentry_ Prefix/suffix:
class sentry;
// _lib.ostream.formatted_ Formatted output:
basic_ostream<charT,traits>& operator<<
(basic_ostream<charT,traits>& (*pf)(basic_ostream<charT,traits>&));
basic_ostream<charT,traits>& operator<<
(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&));
basic_ostream<charT,traits>& operator<<
(ios_base& (*pf)(ios_base&));
basic_ostream<charT,traits>& operator<<(bool n);
basic_ostream<charT,traits>& operator<<(short n);
basic_ostream<charT,traits>& operator<<(unsigned short n);
basic_ostream<charT,traits>& operator<<(int n);
basic_ostream<charT,traits>& operator<<(unsigned int n);
basic_ostream<charT,traits>& operator<<(long n);
basic_ostream<charT,traits>& operator<<(unsigned long n);
basic_ostream<charT,traits>& operator<<(float f);
basic_ostream<charT,traits>& operator<<(double f);
basic_ostream<charT,traits>& operator<<(long double f);
basic_ostream<charT,traits>& operator<<(void* p);
basic_ostream<charT,traits>& operator<<
(basic_streambuf<char_type,traits>* sb);
// _lib.ostream.unformatted_ Unformatted output:
basic_ostream<charT,traits>& put(char_type c);
basic_ostream<charT,traits>& write(const char_type* s, streamsize n);
basic_ostream<charT,traits>& flush();
pos_type tellp();
basic_ostream<charT,traits>& seekp(pos_type);
basic_ostream<charT,traits>& seekp(off_type, ios_base::seekdir);
};
// _lib.ostream.inserters.character_ character inserters
template<class charT, class traits>
basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&,
charT);
template<class charT, class traits>
basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&,
char);
// specialization
template<class traits>
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
char);
// signed and unsigned
template<class traits>
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
signed char);
template<class traits>
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
unsigned char);
template<class charT, class traits>
basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&,
const charT*);
template<class charT, class traits>
basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&,
const char*);
// partial specializationss
template<class traits>
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
const char*);
// signed and unsigned
template<class traits>
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
const signed char*);
template<class traits>
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
const unsigned char*);
}
1 The class basic_ostream defines a number of member function signatures
that assist in formatting and writing output to output sequences con
trolled by a stream buffer.
2 Two groups of member function signatures share common properties: the
formatted output functions (or inserters) and the unformatted output
functions. Both groups of output functions generate (or insert) out
put characters by actions equivalent to calling
rdbuf().sputc(int_type). They may use other public members of
basic_ostream except that they do not invoke any virtual members of
rdbuf() except overflow().
3 If one of these called functions throws an exception, then unless
explicitly noted otherwise the output function set badbit in error
state. If badbit is on in exception(), the output function rethrows
the exception without completing its actions, otherwise it does not
throw anything and treat as an error.
27.6.2.2 basic_ostream constructors [lib.ostream.cons]
explicit basic_ostream(basic_streambuf<charT,traits>* sb);
Effects:
Constructs an object of class basic_ostream, assigning initial val
ues to the base class by calling basic_ios<charT,traits>::init(sb)
(_lib.basic.ios.cons_).
Postcondition:
rdbuf() == sb.
virtual ~basic_ostream();
Effects:
Destroys an object of class basic_ostream.
Notes:
Does not perform any operations on rdbuf().
27.6.2.3 Class basic_ostream::sentry [lib.ostream::sentry]
namespace std {
template <class charT,class traits = char_traits<charT> >
class basic_ostream<charT,traits>::sentry {
bool ok_; // exposition only
public:
explicit sentry(basic_ostream<charT,traits>& os);
~sentry();
operator bool() { return ok_; }
};
}
1 The class sentry defines a class that is responsible for doing excep
tion safe prefix and suffix operations.
explicit sentry(basic_ostream<charT,traits>& os);
2 If os.good() is nonzero, prepares for formatted or unformatted output.
If os.tie() is not a null pointer, calls os.tie()->flush().26)
_________________________
26) The call os.tie()->flush() does not necessarily occur if the func
tion can determine that no synchronization is necessary.
3 If, after any preparation is completed, os.good() is true, ok_ == true
otherwise, ok_ == false. During preparation, the constructor may call
setstate(failbit) (which may throw ios_base::failure
(_lib.iostate.flags_))27)
~sentry();
4 If ((os.flags() & ios_base::unitbuf) && !uncaught_exception()) is
true, calls os.flush().
operator bool();
Effects:
Returns ok_.
pos_type tellp();
Returns:
if fail() != false, returns pos_type(-1) to indicate failure. Oth
erwise, returns rdbuf()->pubseekoff(0, cur, out).
basic_ostream<charT,traits>& seekp(pos_type& pos);
Effects:
If fail() != true, executes rdbuf()->pubseekpos(pos).
Returns:
*this.
basic_ostream<charT,traits>& seekp(off_type& off, ios_base::seekdir dir);
If fail() != true, executes rdbuf()->pubseekoff(off, dir).
Returns:
*this.
27.6.2.4 Formatted output functions [lib.ostream.formatted]
27.6.2.4.1 Common requirements [lib.ostream.formatted.reqmts]
1 Each formatted output function begins execution by constructing an
object of class sentry. If this object returns true when converted to
a value of type bool, the function endeavors to generate the requested
output. If the generation fails, then the formatted output function
does setstate(ios::fail) which might throw and exception. If an
_________________________
27) The sentry constructor and destructor can also perform additional
implementation-dependent operations.
exception is thrown during output then ios::badbit is turned on28) in
*this's error state If (exception()&badbit)!= 0 then the exception is
rethrown. Whether or not an exception is thrown, the sentry object is
destroyed before leaving the formatted output function. If no excep
tion is thrown, the result of the formattted output function is *this.
2 The descriptions of the individual formatted output operations
describes how they perform output and does not mention the sentry
object.
27.6.2.4.2 Arithmetic [lib.ostream.inserters.arithmetic]
Inserters
operator<<(short val);
operator<<(unsigned short val);
operator<<(int val);
operator<<(unsigned int val);
operator<<(long val);
operator<<(unsigned long val);
operator<<(float val);
operator<<(double val);
operator<<(long double val);
operator<<(void* val);
Effects:
1 The classes num_get<> and num_put<> handle locale-dependent numeric
formatting and parsing. These inserter functions refers the imbued
locale value to utilize these numeric formatting functionality. The
formatting conversion occurs as if it performed the following code
fragment:
bool failed =
use_facet< num_put<charT,ostreambuf_iterator<charT,traits> > >(getloc()).
put(*this, *this, fill(), val). failed();
The first argument provides an object of the ostreambuf_iterator<>
class which is an iterator for class basic_ostream<>. It bypasses
ostreams and uses streambufs directly. Class locale relies on these
types as its interface to iostreams, since for flexibility it has been
abstracted away from direct dependence on ostream. The second parame
ter is a reference to the base subobject of type ios_base. It pro
vides formatting specifications such as field width, and a locale from
which to obtain other facets.
27.6.2.4.3 basic_ostream::operator<< [lib.ostream.inserters]
basic_ostream<charT,traits>& operator<<
(basic_ostream<charT,traits>& (*pf)(basic_ostream<charT,traits>&))
_________________________
28) withhout causing an ios::failure to be thrown.
Returns:
pf(*this).29)
basic_ostream<charT,traits>& operator<<
(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&))
Effects:
Calls pf(*this).
Returns:
*this.30)
basic_ostream<charT,traits>& operator<<
(ios_base& (*pf)(ios_base&))
Effects:
Calls pf(*this).
Returns:
*this.
basic_ostream<charT,traits>& operator<<(bool n);
1 Behaves as if:
use_facet<num_put<charT,istreambuf_iterator<charT,traits> >(getloc())
.put(*this, *this, fill(), n);
which writes out a 0 or 1, or the results of use_facet<numpunct<charT>
>(getloc()).truename() or falsename() (_lib.category.numeric_),
according as whether the boolalpha flag is set.
Returns:
*this.
basic_ostream<charT,traits>& operator<<
(basic_streambuf<charT,traits>* sb);
Effects:
If sb is null calls setstate(badbit) (which may throw
ios_base::failure).
2 Gets characters from sb and inserts them in *this. Characters are
read from sb and inserted until any of the following occurs:
--end-of-file occurs on the input sequence;
_________________________
29) See, for example, the function signature endl(basic_ostream&)
(_lib.ostream.manip_) .
30) See, for example, the function signature dec(ios_base&)
(_lib.basefield.manip_).
--inserting in the output sequence fails (in which case the character
to be inserted is not extracted);
--an exception occurs while getting a character from sb.
3 If the function inserts no characters, it calls setstate(failbit)
(which may throw ios_base::failure (_lib.iostate.flags_)). If an
exception was thrown while extracting a character, the function set
failbit in error state, and if failbit is on in exceptions() the
caught exception is rethrown.
Returns:
*this.
27.6.2.4.4 Character inserter [lib.ostream.inserters.character]
template functions
template<class charT, class traits>
basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out,
charT c);
template<class charT, class traits>
basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out,
char c);
// specialization
template<class traits>
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out,
char c);
// signed and unsigned
template<class traits>
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out,
signed char c);
template<class traits>
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out,
unsigned char c);
Effects:
Behaves like an formatted inserter (as described in
_lib.ostream.formatted.reqmts_) of out. After a sentry object is
constructed insert characters. In case c's type is (signed,
unsigned or plain) char the character to be inserted is widen(c);
otherwise the character is c31) Padding is determined as described
in _lib.facet.num.put.virtuals_. width(0) is called. The insertion
character and any required padding are inserted into out.
Returns:
out
_________________________
31) In case the insertion is into a char stream, widen(c) will usually
be c.
template<class charT, class traits>
basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out,
const charT* s);
template<class charT, class traits>
basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out,
const char* s);
template<class traits>
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out,
const char* s);
template<class traits>
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out,
const signed char* s);
template<class traits>
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out,
const unsigned char* s);
Requires:
s is non-null.
Effects:
Behaves like an formatted inserter (as described in
_lib.ostream.formatted.reqmts_) of out. After a sentry object is
constructed insert characters. The number of characters starting at
s to be inserted is traits::length(s). Padding is determined as
described in _lib.facet.num.put.virtuals_. The traits::length(s)
characters starting at s and any required padding is inserted into
out. Calls width(0).
Returns:
out
27.6.2.5 Unformatted output functions [lib.ostream.unformatted]
1 Each formatted output function begins execution by constructing an
object of class sentry. If this object returns true, while converting
to a value of type bool, the function endeavors to generate the
requested output. In any case, the formatted output function ends by
destroying the sentry object, then returning the value specified for
the formatted output function.
basic_ostream<charT,traits>& put(char_type c);
Effects:
Inserts the character c, if possible.32)
2 Otherwise, calls setstate(badbit) (which may throw ios_base::failure
(_lib.iostate.flags_)).
Returns:
*this.
_________________________
32) Note that this function is not overloaded on types signed char and
unsigned char.
basic_ostream& write(const char_type* s, streamsize n);
Effects:
Obtains characters to insert from successive locations of an array
whose first element is designated by s.33) Characters are inserted
until either of the following occurs:
--n characters are inserted;
--inserting in the output sequence fails (in which case the function
calls setstate(badbit), which may throw ios_base::failure
(_lib.iostate.flags_)).
Returns:
*this.
basic_ostream& flush();
3 If rdbuf() is not a null pointer, calls rdbuf()->pubsync(). If that
function returns -1 calls setstate(badbit) (which may throw
ios_base::failure (_lib.iostate.flags_)).
Returns:
*this.
27.6.2.6 Standard basic_ostream manipulators [lib.ostream.manip]
namespace std {
template <class charT, class traits>
basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);
}
Effects:
Calls os.put(traits::newline()), then os.flush().
Returns:
os.34)
namespace std {
template <class charT, class traits>
basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);
}
_________________________
33) Note that this function is not overloaded on types signed char and
unsigned char.
34) The effect of executing cout << endl is to insert a newline char
acter in the output sequence controlled by cout, then synchronize it
with any external file with which it might be associated.
Effects:
Inserts a null character into the output sequence: calls
os.put(traits::eos()).
Returns:
os.
namespace std {
template <class charT, class traits>
basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);
}
Effects:
Calls os.flush().
Returns:
os.
27.6.3 Standard manipulators [lib.std.manip]
1 The header <iomanip> defines a type and several related functions that
use this type to provide extractors and inserters that alter informa
tion maintained by class ios_base and its derived classes.
2 The type designated smanip in each of the following function descrip
tions is implementation-specified and may be different for each func
tion.
smanip resetiosflags(ios_base::fmtflags mask);
Returns:
An object s of implementation specified type such that if out is an
(instance of) basic_ostream then the expression out<<s behaves as if
f(s) were called. Where where f can be defined as:35)
template <class charT, class traits>
ios_base& f(ios_base& str, ios_base::fmtflags mask)
{ // reset specified flags
str.setf(ios_base::fmtflags(0), mask);
return str;
}
smanip setiosflags(ios_base::fmtflags mask);
_________________________
35) The expression cin >> resetiosflags(ios_base::skipws) clears
ios_base::skipws in the format flags stored in the istream object cin
(the same as cin >> noskipws), and the expression cout << resetios
flags(ios_base::showbase) clears ios_base::showbase in the format
flags stored in the ostream object cout (the same as cout << noshow
base).
Returns:
An object s of implementation specified type such that if out is an
(instance of) basic_ostream then the expression out<<s behaves as if
f(s) were called. Where where f can be defined as:
ios_base& f(ios_base& str, ios_base::fmtflags mask)
{ // set specified flags
str.setf(mask);
return str;
}
smanip setbase(int base);
Returns:
An object s of implementation specified type such that if out is an
(instance of) basic_ostream then the expression out<<s behaves as if
f(s) were called. Where where f can be defined as:
ios_base& f(ios_base& str, int base)
{ // set basefield
str.setf(n == 8 ? ios_base::oct :
n == 10 ? ios_base::dec :
n == 16 ? ios_base::hex :
ios_base::fmtflags(0), ios_base::basefield);
return str;
}
smanip setfill(int c);
Returns:
An object s of implementation specified type such that if out is (or
is derived from) basic_ostream<charT,traits> and c has type charT
then the expression out<<s behaves as if f(s) were called. Where
where f can be defined as:
ios_base& f(ios_base& str, int c)
{ // set fill character
str.fill(c);
return str;
}
smanip setprecision(int n);
Returns:
An object s of implementation specified type such that if out is an
(instance of) basic_ostream then the expression out<<s behaves as if
f(s) were called. Where where f can be defined as:
ios_base& f(ios_base& str, int n)
{ // set precision
str.precision(n);
return str;
}
smanip setw(int n);
Returns:
An object s of implementation specified type such that if out is an
(instance of) basic_ostream then the expression out<<s behaves as if
f(s) were called. Where where f can be defined as:
ios_base& f(ios_base& str, int n)
{ // set width
str.width(n);
return str;
}
27.7 String-based streams [lib.string.streams]
1 The header <sstream> defines four template classes, and six types,
that associate stream buffers with objects of class basic_string, as
described in subclause _lib.string.classes_.
Header <sstream> synopsis
namespace std {
template <class charT, class traits = char_traits<charT>,
class Allocator = allocator<charT> >
class basic_stringbuf;
typedef basic_stringbuf<char> stringbuf;
typedef basic_stringbuf<wchar_t> wstringbuf;
template <class charT, class traits = char_traits<charT>
class Allocator = allocator<charT> >
class basic_istringstream;
typedef basic_istringstream<char> istringstream;
typedef basic_istringstream<wchar_t> wistringstream;
template <class charT, class traits = char_traits<charT>
class Allocator = allocator<charT> >
class basic_ostringstream;
typedef basic_ostringstream<char> ostringstream;
typedef basic_ostringstream<wchar_t> wostringstream;
template <class charT, class traits = char_traits<charT>
class Allocator = allocator<charT> >
class basic_stringstream;
typedef basi
}
27.7.1 Template class basic_stringbuf [lib.stringbuf]
namespace std {
template <class charT, class traits = char_traits<charT>,
class Allocator = allocator<charT> >
class basic_stringbuf : public basic_streambuf<charT,traits> {
public:
// Types:
typedef charT char_type;
typedef typename traits::int_type int_type;
typedef typename traits::pos_type pos_type;
typedef typename traits::off_type off_type;
// _lib.stringbuf.cons_ Constructors:
explicit basic_stringbuf(ios_base::openmode which
= ios_base::in | ios_base::out);
explicit basic_stringbuf(
const basic_string<charT,traits,Allocator>& str, ios_base::openmode which
= ios_base::in | ios_base::out);
// _lib.stringbuf.members_ Get and set:
basic_string<charT,traits,Allocator> str() const;
void str(const basic_string<charT,traits,Allocator>&
s);
protected:
// _lib.stringbuf.virtuals_ Overridden virtual functions:
virtual int_type underflow();
virtual int_type pbackfail(int_type c = traits::eof());
virtual int_type overflow (int_type c = traits::eof());
virtual basic_streambuf<charT,traits>* setbuf(charT*, streamsize);
virtual pos_type seekoff(off_type off, ios_base::seekdir way,
ios_base::openmode which
= ios_base::in | ios_base::out);
virtual pos_type seekpos(pos_type sp,
ios_base::openmode which
= ios_base::in | ios_base::out);
private:
// ios_base::openmode mode; exposition only
};
}
1 The class basic_stringbuf is derived from basic_streambuf to associate
possibly the input sequence and possibly the output sequence with a
sequence of arbitrary characters. The sequence can be initialized
from, or made available as, an object of class basic_string.
2 For the sake of exposition, the maintained data is presented here as:
--ios_base::openmode mode, has in set if the input sequence can be
read, and out set if the output sequence can be written.
27.7.1.1 basic_stringbuf constructors [lib.stringbuf.cons]
explicit basic_stringbuf(ios_base::openmode which =
ios_base::in | ios_base::out);
Effects:
Constructs an object of class basic_stringbuf, initializing the base
class with basic_streambuf() (_lib.streambuf.cons_), and initializ
ing mode with which.
Notes:
The function allocates no array object.
explicit basic_stringbuf(const basic_string<char_type>& str,
ios_base::openmode which = ios_base::in | ios_base::out);
Effects:
Constructs an object of class basic_stringbuf, initializing the base
class with basic_streambuf() (_lib.streambuf.cons_), and initializ
ing mode with which. Then copies the content of str into the
basic_stringbuf underlying character sequence and initializes the
input and output sequences according to which. If which &
ios_base::out is true, initializes the output sequence with the
underlying sequence. If which & ios_base::in is true, initializes
the input sequence with the underlying sequence.
Postconditions:
str() == str.
27.7.1.2 Member functions [lib.stringbuf.members]
basic_string<char_type> str() const;
Returns:
A basic_string object whose content is equal to the basic_stringbuf
underlying character sequence. If the buffer is only created in
input mode, the underlying character sequence is equal to the input
sequence; otherwise, it is equal to the output sequence. In case of
an empty underlying character sequence, the function returns
basic_string<charT,traits,Allocator>().
void str(const basic_string<char_type>& s);
Effects:
If the basic_stringbuf's underlying character sequence is not empty,
deallocates it. Then copies the content of s into the basic_string
buf underlying character sequence and initializes the input and out
put sequences according to the mode stored when creating the
basic_stringbuf object. If (mode&ios_base::out) is true, then ini
tializes the output sequence with the underlying sequence. If
(mode&ios_base::in) is true, then initializes the input sequence
with the underlying sequence.
Postcondition:
str() == s.
27.7.1.3 Overridden virtual functions [lib.stringbuf.virtuals]
int_type underflow();
Returns:
If the input sequence has a read position available, returns
traits::to_int_type(*gptr()).
Otherwise, returns traits::eof().
int_type pbackfail(int_type c = traits::eof());
Effects:
Puts back the character designated by c to the input sequence, if
possible, in one of three ways:
--If traits::eq_int_type(c,traits::eof()) returns false and if the
input sequence has a putback position available, and if
traits::eq(to_char_type(c),gptr()[-1]) returns true, assigns gptr()
- 1 to gptr().
Returns: c.
--If traits::eq_int_type(c,traits::eof()) returns false and if the
input sequence has a putback position available, and if mode &
ios_base::out is nonzero, assigns c to *--gptr().
Returns: c.
--If traits::eq_int_type(c,traits::eof()) returns true and if the
input sequence has a putback position available, assigns gptr() - 1
to gptr().
Returns: traits::not_eof(c).
Returns:
traits::eof() to indicate failure.
Notes:
If the function can succeed in more than one of these ways, it is
unspecified which way is chosen.
int_type overflow(int_type c = traits::eof());
Effects:
Appends the character designated by c to the output sequence, if
possible, in one of two ways:
--If traits::eq_int_type(c,traits::eof()) returns false and if either
the output sequence has a write position available or the function
makes a write position available (as described below), the function
calls sputc(c).
Signals success by returning c.
--If traits::eq_int_type(c,traits::eof()) returns true, there is no
character to append.
Signals success by returning a value other than traits::eof().
Notes:
The function can alter the number of write positions available as a
result of any call.
Returns:
traits::eof() to indicate failure.
1 [Note: The function can make a write position available only if (mode
& ios_base::out) != 0. To make a write position available, the func
tion reallocates (or initially allocates) an array object with a suf
ficient number of elements to hold the current array object (if any),
plus one additional write position. If (mode & ios_base::in) != 0,
the function alters the read end pointer egptr() to point just past
the new write position (as does the write end pointer epptr()).
--end note]
pos_type seekoff(off_type off, ios_base::seekdir way,
ios_base::openmode which
= ios_base::in | ios_base::out);
+------- BEGIN BOX 13 -------+
Check vs. _lib.filebuf.virtuals_
+------- END BOX 13 -------+
Effects:
Alters the stream position within one of the controlled sequences,
if possible, as indicated in Table 9:
Table 9--seekoff positioning
+----------------------------------------------------------------------------------+
| Conditions Result |
+----------------------------------------------------------------------------------+
|(which & basic_ios::in) != 0 positions the input sequence |
+----------------------------------------------------------------------------------+
|(which & basic_ios::out) != 0 positions the output sequence |
+----------------------------------------------------------------------------------+
|(which & (basic_ios::in | ba positions both the input and the output sequences |
|sic_ios::out)) == (ba |
|sic_ios::in | ba |
|sic_ios::out)) |
|and way == either ba |
|sic_ios::beg or ba |
|sic_ios::end |
+----------------------------------------------------------------------------------+
|Otherwise the positioning operation fails. |
+----------------------------------------------------------------------------------+
2 For a sequence to be positioned, if its next pointer (either gptr() or
pptr()) is a null pointer, the positioning operation fails. Other
wise, the function determines newoff as indicated in Table 10:
Table 10--newoff values
+---------------------------------------------------------+
| Condition newoff Value |
+---------------------------------------------------------+
|way == basic_ios::beg 0 |
+---------------------------------------------------------+
|way == basic_ios::cur the next pointer minus the be |
| ginning pointer (xnext - xbeg). |
+---------------------------------------------------------+
|way == basic_ios::end the end pointer minus the be |
| ginning pointer (xend - xbeg) |
+---------------------------------------------------------+
|If (newoff + off) < 0, the positioning operation fails |
|or (xend - xbeg) < |
|(newoff + off) |
+---------------------------------------------------------+
3 Otherwise, the function assigns xbeg + newoff + off to the next
pointer xnext.
Returns:
pos_type(newoff), constructed from the resultant offset newoff (of
type off_type), that stores the resultant stream position, if possi
ble. If the positioning operation fails, or if the constructed
object cannot represent the resultant stream position, the object
stores an invalid stream position.
pos_type seekpos(pos_type sp, ios_base::openmode which
= ios_base::in | ios_base::out);
Effects:
Alters the stream position within the controlled sequences, if pos
sible, to correspond to the stream position stored in sp (as
described below).
--If (which & basic_ios::in) != 0, positions the input sequence.
--If (which & basic_ios::out) != 0, positions the output sequence.
--If sp is an invalid stream position, of if the function positions
neither sequence, the positioning operation fails. If sp has not
been obtained by a previous successful call to one of the position
ing functions( seekoff, seekpos, tellg, tellp ) the effect is unde
fined.
+------- BEGIN BOX 14 -------+
Change: The motion in Stockholm read "no validity is ensured". The
editor has changed this to "undefined".
+------- END BOX 14 -------+
Returns:
sp to indicate success, or pos_type(off_type(-1)) to indicate fail
ure.
basic_streambuf<charT,traits>* setbuf(charT* s, streamsize n);
setbuf(0,0) has no effect.
Returns:
this.
27.7.2 Template class basic_istringstream [lib.istringstream]
namespace std {
template <class charT, class traits = char_traits<charT>,
class Allocator = allocator<charT> >
class basic_istringstream : public basic_istream<charT,traits> {
public:
// Types:
typedef charT char_type;
typedef typename traits::int_type int_type;
typedef typename traits::pos_type pos_type;
typedef typename traits::off_type off_type;
// _lib.istringstream.cons_ Constructors:
explicit basic_istringstream(ios_base::openmode which = ios_base::in);
explicit basic_istringstream(const basic_string<charT>& str,
ios_base::openmode which = ios_base::in);
// _lib.istringstream.members_ Members:
basic_stringbuf<charT,traits>* rdbuf() const;
basic_string<charT> str() const;
void str(const basic_string<charT>& s);
private:
// basic_stringbuf<charT,traits,Allocator> sb; exposition only
};
}
1 The class basic_istringstream<charT,traits,Allocator> supports reading
objects of class basic_string<charT,traits,Allocator>. It uses a
basic_stringbuf<charT,traits,Allocator> object to control the associ
ated storage. For the sake of exposition, the maintained data is pre
sented here as:
--sb, the stringbuf object.
27.7.2.1 basic_istringstream [lib.istringstream.cons]
constructors
explicit basic_istringstream(ios_base::openmode which = ios_base::in);
Effects:
Constructs an object of class basic_istringstream<charT,traits>,
initializing the base class with basic_istream(&sb) and initializing
sb with basic_stringbuf<charT,traits>(which|ios_base::in))
(_lib.stringbuf.cons_).
explicit basic_istringstream(
const basic_string<charT,traits,allocator>& str,
ios_base::openmode which = ios_base::in);
Effects:
Constructs an object of class basic_istringstream<charT,traits>,
initializing the base class with basic_istream(&sb) and initializing
sb with basic_stringbuf<charT,traits,Allocator>(str, which |
ios_base::in)) (_lib.stringbuf.cons_).
27.7.2.2 Member functions [lib.istringstream.members]
basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
Returns:
(basic_stringbuf<charT,traits,Allocator>*)&sb.
basic_string<charT> str() const;
Returns:
rdbuf()->str().36)
void str(const basic_string<charT>& s);
Effects:
Calls rdbuf()->str(s).
27.7.2.3 Class basic_ostringstream [lib.ostringstream]
namespace std {
template <class charT, class traits = char_traits<charT>,
class Allocator = allocator<charT> >
class basic_ostringstream : public basic_ostream<charT,traits> {
public:
// Types:
typedef charT char_type;
typedef typename traits::int_type int_type;
typedef typename traits::pos_type pos_type;
typedef typename traits::off_type off_type;
_________________________
36) rdbuf() is never NULL because it always returns the private ob
ject.
// _lib.ostringstream.cons_ Constructors/destructor:
explicit basic_ostringstream(ios_base::openmode which = ios_base::out);
explicit basic_ostringstream(const basic_string<charT>& str,
ios_base::openmode which = ios_base::out);
virtual ~basic_ostringstream();
// _lib.ostringstream.members_ Members:
basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
basic_string<charT,traits,Allocator> str() const;
void str(const basic_string<charT,traits,Allocator>& s);
private:
// basic_stringbuf<charT,traits,Allocator> sb; exposition only
};
}
1 The class basic_ostringstream<charT,traits,Allocator> supports writing
objects of class basic_string<charT,traits,Allocator>. It uses a
basic_stringbuf object to control the associated storage. For the
sake of exposition, the maintained data is presented here as:
--sb, the stringbuf object.
27.7.2.4 basic_ostringstream [lib.ostringstream.cons]
constructors
explicit basic_ostringstream(ios_base::openmode which = ios_base::out);
Effects:
Constructs an object of class basic_ostringstream, initializing the
base class with basic_ostream(&sb) and initializing sb with
basic_stringbuf<charT,traits,Allocator>(which | ios_base::out))
(_lib.stringbuf.cons_).
explicit basic_ostringstream(
const basic_string<charT,traits,Allocator>& str,
ios_base::openmode which = ios_base::out);
Effects:
Constructs an object of class basic_ostringstream<charT,traits>,
initializing the base class with basic_ostream(&sb) and initializing
sb with basic_stringbuf<charT,traits>(str, which | ios_base::out))
(_lib.stringbuf.cons_).
27.7.2.5 Member functions [lib.ostringstream.members]
basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
Returns:
(basic_stringbuf<charT,traits,Allocator>*)&sb.
basic_string<charT,traits,Allocator> str() const;
Returns:
rdbuf()->str().37)
void str(const basic_string<charT,traits,Allocator>& s);
Effects:
Calls rdbuf()->str(s).
27.7.3 Template class basic_stringstream [lib.stringstream]
namespace std {
template <class charT, class traits=char_traits<charT> >
class basic_stringstream
: public basic_iostream<charT,traits> {
public:
// Types
typedef charT char_type;
typedef typename traits::int_type int_type;
typedef typename traits::pos_type pos_type;
typedef typename traits::off_type off_type;
// constructors/destructors
explicit basic_stringstream(
ios_base::openmode which = ios_base::out|ios_base::in);
explicit basic_stringstream(
const basic_string<charT>& str,
ios_base::openmode which = ios_base::out|ios_base::in);
// Members:
basic_stringbuf<charT,traits>* rdbuf() const;
basic_string<charT> strs() const;
void str(const basic_string<charT>& str);
private:
// basic_stringbuf<charT, traits> sb; exposition only
};
1 The template class basic_stringstream<charT,traits> supports reading
and writing from objects of class basic_string<charT,traits>. It uses
a basic_stringbuf<charT,traits> object to control the associated
sequence. For the sake of exposition, the maintained data is pre
sented here as
--sb, the stringbuf object.
27.7.4 basic_stringstream constructors [lib.stringstream.cons]
explicit basic_stringstream(
ios_base::openmode which = ios_base::out|iosbase::in);
_________________________
37) rdbuf() is never NULL because it always returns the private ob
ject.
Effects:
Constructs an object of class basic_stringstream<charT,traits>, ini
tializing the base class with basic_iostream(&sb) and initializing
sb with basic_stringbuf<charT,traits>(which).
explicit basic_stringstream(
const basic_string<charT>& str,
ios_base::openmode which = ios_base::out|iosbase::in);
Effects:
Constructs an object of class basic_stringstream<charT,traits>, ini
tializing the base class with basic_iostream(&sb) and initializing
sb with basic_stringbuf<charT,traits>(str,which).
27.7.5 Member [functions]
basic_stringbuf<charT,traits>* rdbuf() const;
Returns:
&sb
basic_string<charT> str() const;
Returns:
rdbuf()->str().38)
void str(const basic_string<charT>& str);
Effects:
Calls rdbuf()->str(str).
27.8 File-based streams [lib.file.streams]
27.8.1 File streams [lib.fstreams]
1 The header <fstream> defines four class templates, and six types, that
associate stream buffers with files and assist reading and writing
files.
Header <fstream> synopsis
_________________________
38) rdbuf() is never NULL because it always returns the private ob
ject.
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_filebuf;
typedef basic_filebuf<char> filebuf;
typedef basic_filebuf<wchar_t> wfilebuf;
template <class charT, class traits = char_traits<charT> >
class basic_ifstream;
typedef basic_ifstream<char> ifstream;
typedef basic_ifstream<wchar_t> wifstream;
template <class charT, class traits = char_traits<charT> >
class basic_ofstream;
typedef basic_ofstream<char> ofstream;
typedef basic_ofstream<wchar_t> wofstream;
}
+------- BEGIN BOX 15 -------+
Issue: basic_filebuf<charT,traits> should be specified so that it
treats a file as a sequence of charT. Except for filebuf and wfilebuf
that implies it treats the file as binary.
+------- END BOX 15 -------+
2 In this subclause, the type name FILE refers to the type FILE defined
in <cstdio> (_lib.c.files_).39)
--File A File provides an external source/sink stream whose underlaid
character type is char (byte).40)
--Multibyte character and Files A File provides byte sequences. So
the streambuf (or its derived classes) treats a file as the external
source/sink byte sequence. In a large character set environment,
multibyte character sequences are held in files. In order to pro
vide the contents of a file as wide character sequences, wide-ori
ented filebuf, namely wfilebuf should convert wide character
sequences.
27.8.1.1 Template class basic_filebuf [lib.filebuf]
_________________________
39) In C FILE must be a typedef. In C++ it may be a typedef or other
type name.
40) A File is a sequence of multibyte characters. In order to provide
the contents as a wide character sequence, filebuf should convert be
tween wide character sequences and multibyte character sequences.
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_filebuf : public basic_streambuf<charT,traits> {
public:
// Types:
typedef charT char_type;
typedef typename traits::int_type int_type;
typedef typename traits::pos_type pos_type;
typedef typename traits::off_type off_type;
// _lib.filebuf.cons_ Constructors/destructor:
basic_filebuf();
virtual ~basic_filebuf();
// _lib.filebuf.members_ Members:
bool is_open() const;
basic_filebuf<charT,traits>* open(const char* s, ios_base::openmode mode);
basic_filebuf<charT,traits>* close();
protected:
// _lib.filebuf.virtuals_ Overridden virtual functions:
virtual int showmanyc();
virtual int_type underflow();
virtual int_type uflow();
virtual int_type pbackfail(int_type c = traits::eof());
virtual int_type overflow (int_type c = traits::eof());
virtual basic_streambuf<charT,traits>*
setbuf(char_type* s, streamsize n);
virtual pos_type seekoff(off_type off, ios_base::seekdir way,
ios_base::openmode which
= ios_base::in | ios_base::out);
virtual pos_type seekpos(pos_type sp, ios_base::openmode which
= ios_base::in | ios_base::out);
virtual int sync();
virtual void imbue(const locale& loc);
};
}
1 The class basic_filebuf<charT,traits> associates both the input
sequence and the output sequence with a file.
2 The restrictions on reading and writing a sequence controlled by an
object of class basic_filebuf<charT,traits> are the same as for read
ing and writing with the Standard C library FILEs.
3 In particular:
--If the file is not open for reading the input sequence cannot be
read.
--If the file is not open for writing the output sequence cannot be
written.
--A joint file position is maintained for both the input sequence and
the output sequence.
4 An instance of basic_filebuf behaves as described in _lib.filebuf_
provided traits::pos_type is fpos<traits::state_type>. Otherwise the
behavior is undefined.
5 In order to support file I/O and multibyte/wide character conversion,
conversions are performed using members of a facet, referred to as
a_codecvt in following sections, obtained ``as if'' by
codecvt<charT,char,typename traits::state_type> a_codecvt =
use_facet<codecvt<charT,char,typename traits::state_type> >(getloc());
27.8.1.2 basic_filebuf constructors [lib.filebuf.cons]
basic_filebuf();
Effects:
Constructs an object of class basic_filebuf<charT,traits>, initial
izing the base class with basic_streambuf<charT,traits>()
(_lib.streambuf.cons_).
Postcondition:
is_open() == false.
virtual ~basic_filebuf();
Effects:
Destroys an object of class basic_filebuf<charT,traits>. Calls
close().
27.8.1.3 Member functions [lib.filebuf.members]
bool is_open() const;
Returns:
true if a previous call to open succeeded (returned a non-null
value) and there has been no intervening call to cloase.
basic_filebuf<charT,traits>* open(
const char* s,
ios_base::openmode mode );
Effects:
If is_open() != false, returns a null pointer. Otherwise, initial
izes the filebuf as required.
It then opens a file, if possible, whose name is the NTBS s (``as
if'' by calling ::fopen(s,modstr)).
The NTBS modstr is determined from mode & ~ios_base::ate as indi
cated in Table 11:
Table 11--File open modes
+---------------------------------------------------+
| ios_base Flag combination stdio equivalent |
|binary in out trunc app |
+---------------------------------------------------+
| + "w" |
+---------------------------------------------------+
| + + "a" |
+---------------------------------------------------+
| + + "w" |
+---------------------------------------------------+
| + "r" |
+---------------------------------------------------+
| + + "r+" |
+---------------------------------------------------+
| + + + "w+" |
+---------------------------------------------------+
| + + "wb" |
+---------------------------------------------------+
| + + + "ab" |
+---------------------------------------------------+
| + + + "wb" |
+---------------------------------------------------+
| + + "rb" |
+---------------------------------------------------+
| + + + "r+b" |
+---------------------------------------------------+
| + + + + "w+b" |
+---------------------------------------------------+
If mode is not some combination of flags shown in the table then the
open fails.
1 If the open operation succeeds and (mode & ios_base::ate) != 0, posi
tions the file to the end (``as if'' by calling
::fseek(file,0,SEEK_END)).41)
2 If the repositioning operation fails, calls close() and returns a null
pointer to indicate failure.
Returns:
this if successful, a null pointer otherwise.
basic_filebuf<charT,traits>* close();
_________________________
41) The macro SEEK_END is defined, and the function signatures
fopen(const char_type*, const char_type*) and fseek(FILE*, long, int)
are declared, in <cstdio> (_lib.c.files_).
Effects:
If is_open() == false, returns a null pointer. Otherwise, closes
the file (``as if'' by calling ::fclose(file)).42)
Returns:
this on success, a null pointer otherwise.
Postcondition:
is_open() == false.
27.8.1.4 Overridden virtual functions [lib.filebuf.virtuals]
int showmanyc();
Effects:
Behaves the same as basic_streambuf::showmanyc() (_lib.stream
buf.virtuals_).
Notes:
An implementation might well provide an overriding definition for
this function signature if it can determine that more characters can
be read from the input sequence.
int_type underflow();
Effects:
Behaves according to the description of basic_stream
buf<charT,traits>:: underflow(), with the specialization that a
sequence of characters is read from the input sequence ``as if'' by
reading from the associated file into an internal buffer (
extern_buf) and then ``as if'' doing
char extern_buf[XSIZE];
char* extern_end;
charT intern_buf[ISIZE];
charT* intern_end;
codecvt_base::result r =
a_codecvt.in(st,extern_buf,extern_buf+XSIZE,extern_end,
intern_buf, intern_buf+ISIZE, intern_end);
This must be done in such a way that the class can recover the posi
tion fpos_t) corresponding to each character between intern_buf and
intern_end. If the value of r indicates that a_codecvt.in() ran out
of space in intern_buf, retry with a larger intern_buf.
int_type uflow();
Effects:
Behaves according to the description of basic_stream
buf<charT,traits>:: uflow(), with the specialization that a sequence
of characters is read from the input with the same method as used by
_________________________
42) The function signature fclose(FILE*) is declared, in <cstdio>
(_lib.c.files_).
underflow.
int_type pbackfail(int_type c = traits::eof());
+------- BEGIN BOX 16 -------+
Check vs. _lib.streambuf.virtuals_.
+------- END BOX 16 -------+
Effects:
Puts back the character designated by c to the input sequence, if
possible, in one of three ways:
--If traits::eq_int_type(c,traits::eof()) returns false and if the
function makes a putback position available and if
traits::eq(to_char_type(c),gptr()[-1]) returns true, decrements the
next pointer for the input sequence, gptr().
Returns: c.
--If traits::eq_int_type(c,traits::eof()) returns false and if the
function makes a putback position available, and if the function is
permitted to assign to the putback position, decrements the next
pointer for the input sequence, and stores c there.
Returns: c.
--If traits::eq_int_type(c,traits::eof()) returns true and if either
the input sequence has a putback position available or the function
makes a putback position available, decrements the next pointer for
the input sequence, gptr().
Returns: traits::not_eof(c).
Returns:
traits::eof() to indicate failure.
Notes:
If is_open() == false, the function always fails.
The function does not put back a character directly to the input
sequence.
If the function can succeed in more than one of these ways, it is
unspecified which way is chosen. The function can alter the number
of putback positions available as a result of any call.
int_type overflow(int_type c = traits::eof());
Effects:
Behaves according to the description of basic_stream
buf<charT,traits>::overflow(c), except that the behavior of ``con
suming characters'' is performed by first coverting ``as if'' by:
charT* b = pbase();
charT* p = pptr();
charT* end;
char xbuf[XSIZE];
char* xbuf_end;
codecvt_base::result r = a_codecvt.out(st,b,p,end,xbuf,xbuf+XSIZE,xbuf_end);
and then
--If r == codecvt_base::error then fail.
--If r == codecvt_base::noconv then output characters from b upto (and
not including) p.
--If r == codecvt_base::partial then output to the file characters
from xbuf upto xbuf_end, and repeat using characters from end to p.
If output fails, fail (without repeating).
--Otherwise output from xbuf to xbuf_end, and fail if output fails.
At this point if b != p and b == end ( buf isn't large enough) then
increase BSIZE and repeat from the beginning.
Returns:
traits::not_eof(c) to indicate success, and traits::eof() to indi
cate failure. If is_open() == false, the function always fails.
basic_streambuf* setbuf(char_type* s, int n);
Effects:
If setbuf(0,0) is called on a stream before any I/O has occured on
that stream, the stream becomes unbuffered. Otherwise the results
are implementation-defined. "Unbuffered" means that pbase() and
pptr() always return null and output to the file should appear as
soon as possible.
+------- BEGIN BOX 17 -------+
Change: The definition of unbuffered has been modified slightly. "as
soon as possible" isn't really clear, but its taken from the C stan
dard.
+------- END BOX 17 -------+
pos_type seekoff(off_type off, ios_base::seekdir way,
ios_base::openmode which
= ios_base::in | ios_base::out);
Effects:
The current state is determined as follows: If the the last opera
tion was overflow(), the current state is obtained by combining the
shiftstate contained in st with the current position ( fpos_t) of
the file. If the last operation was underflow(), the shiftstate and
file position are determined (according to whatever means they were
saved by underflow()) as corresponding to pptr().
Then, alters the stream position within the controlled sequences, if
possible, as described below.
If is_open() == false, the positioning operation fails. Otherwise,
repositions within the associated file (``as if'' by calling
::fseek(file,off,whence).43)
Notes:
The function determines one of three values for the argument whence,
of type int, as indicated in Table 12:
Table 12--seekoff effects
+----------------------------------+
| way Value stdio Equivalent |
+----------------------------------+
|basic_ios::beg SEEK_SET |
|basic_ios::cur SEEK_CUR |
|basic_ios::end SEEK_END |
+----------------------------------+
The function extracts the conversion state from off by means of
get_offstate() to reset the rdstate() member.
+------- BEGIN BOX 18 -------+
Issue: The previous sentence contradict earlier paragraph. And it
makes no sense as conversion states are not embedded in offsets. And
there is no get_offstate function.
+------- END BOX 18 -------+
Returns:
a newly constructed pos_type object that stores the resultant stream
position, if possible. If the positioning operation fails, or if
the object cannot represent the resultant stream position, returns
an invalid stream position (_lib.iostreams.pos.t_).
pos_type seekpos(pos_type sp, ios_base::openmode which
= ios_base::in | ios_base::out);
Effects:
Alters the file position, if possible, to correspond to the position
stored in sp (as described below).
--if (which&ios_base::in)!=0, set the file position to sp, then update
the input sequence
--if (which&ios_base::out)!=0, set the file position to sp, then
update the output sequence
_________________________
43) The macros SEEK_SET, SEEK_CUR, and SEEK_END are defined, and the
function signature fseek(FILE*, long, int) is declared, in <cstdio>
(_lib.c.files_).
1 If sp is an invalid stream position, or if the function positions nei
ther sequence, the positioning operation fails. If sp has not been
obtained by a previous successful call to one of the positioning func
tions ( seekoff or seekpos) on the same file the effects are unde
fined.
+------- BEGIN BOX 19 -------+
Change: The words describing the undefined case are modified from the
Stockholm motion. That motion did not require the position to have
been the result of a positioning operation on the same file, and it
said "no validity is ensured" rather than "undefined behavior".
+------- END BOX 19 -------+
int sync();
void imbue(const locale& loc);
27.8.1.5 Template class basic_ifstream [lib.ifstream]
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_ifstream : public basic_istream<charT,traits> {
public:
// Types:
typedef charT char_type;
typedef typename traits::int_type int_type;
typedef typename traits::pos_type pos_type;
typedef typename traits::off_type off_type;
// _lib.ifstream.cons_ Constructors:
basic_ifstream();
explicit basic_ifstream(const char* s,
ios_base::openmode mode = ios_base::in);
// _lib.ifstream.members_ Members:
basic_filebuf<charT,traits>* rdbuf() const;
bool is_open();
void open(const char* s, openmode mode = in);
void close();
private:
// basic_filebuf<charT,traits> sb; exposition only
};
}
1 The class basic_ifstream<charT,traits> supports reading from named
files. It uses a basic_filebuf<charT,traits> object to control the
associated sequence. For the sake of exposition, the maintained data
is presented here as:
--sb, the filebuf object.
27.8.1.6 basic_ifstream constructors [lib.ifstream.cons]
basic_ifstream();
Effects:
Constructs an object of class basic_ifstream<charT,traits>, initial
izing the base class with basic_istream(&sb) and initializing sb
with basic_filebuf<charT,traits>()) (_lib.istream.cons_, _lib.file
buf.cons_).
explicit basic_ifstream(const char* s, openmode mode = in);
Effects:
Constructs an object of class basic_ifstream, initializing the base
class with basic_istream(&sb) and initializing sb with basic_file
buf<charT,traits>()) (_lib.istream.cons_, _lib.filebuf.cons_), then
calls rdbuf()->open(s,mode|in).44)
27.8.1.7 Member functions [lib.ifstream.members]
basic_filebuf<charT,traits>* rdbuf() const;
Returns:
(basic_filebuf<charT,traits>*)&sb.
bool is_open();
Returns:
rdbuf()->is_open().45)
void open(const char* s, openmode mode = in);
Effects:
Calls rdbuf()->open(s,mode|in). If that function returns a null
pointer , calls setstate(failbit) (which may throw ios_base::failure
(_lib.iostate.flags_)).
void close();
_________________________
44) rdbuf() is never NULL because it always returns the private ob
ject. If that function returns a null pointer, calls setsate(fail
bit), (which may throw ios_base::failure).
45) rdbuf() is never NULL because it always returns the private ob
ject.
Effects:
Calls rdbuf()->close() and, if that function returns false, calls
setstate(failbit) (which may throw ios_base::failure
(_lib.iostate.flags_)).
27.8.1.8 Template class basic_ofstream [lib.ofstream]
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_ofstream : public basic_ostream<charT,traits> {
public:
// Types:
typedef charT char_type;
typedef typename traits::int_type int_type;
typedef typename traits::pos_type pos_type;
typedef typename traits::off_type off_type;
// _lib.ofstream.cons_ Constructors:
basic_ofstream();
explicit basic_ofstream(const char* s,
ios_base::openmode mode
= ios_base::out | ios_base::trunc);
// _lib.ofstream.members_ Members:
basic_filebuf<charT,traits>* rdbuf() const;
bool is_open();
void open(const char* s, ios_base::openmode mode = out | trunc);
void close();
private:
// basic_filebuf<charT,traits> sb; exposition only
};
}
1 The class basic_ofstream<charT,traits> supports writing to named
files. It uses a basic_filebuf<charT,traits> object to control the
associated sequence. For the sake of exposition, the maintained data
is presented here as:
--sb, the filebuf object.
27.8.1.9 basic_ofstream constructors [lib.ofstream.cons]
basic_ofstream();
Effects:
Constructs an object of class basic_ofstream<charT,traits>, initial
izing the base class with basic_ostream(&sb) and initializing sb
with basic_filebuf<charT,traits>()) (_lib.ostream.cons_, _lib.file
buf.cons_).
explicit basic_ofstream(const char* s, openmode mode = out);
Effects:
Constructs an object of class basic_ofstream<charT,traits>,
initializing the base class with basic_ostream(&sb) and initializing
sb with basic_filebuf<charT,traits>()) (_lib.ostream.cons_,
_lib.filebuf.cons_), then calls rdbuf()->open(s, mode|out).46) If
that function returns a null pointer, calls setate(failbit), (which
may throw ios_base::failure).
27.8.1.10 Member functions [lib.ofstream.members]
basic_filebuf<charT,traits>* rdbuf() const;
Returns:
(basic_filebuf<charT,traits>*)&sb.
bool is_open();
Returns:
rdbuf()->is_open().
void open(const char* s, openmode mode = out);
Effects:
Calls rdbuf()->open(s,mode|out). If that function returns a null
pointer, calls setstate(failbit) (which may throw ios_base::failure
(_lib.iostate.flags_)).
void close();
Effects:
Calls rdbuf()->close() and, if that function fails (returns a null
pointer), calls setstate(failbit) (which may throw ios_base::failure
(_lib.iostate.flags_)).
27.8.1.11 Template class basic_fstream [lib.fstream]
namespace std {
template <class charT, class traits=ios_ytraits<charT> >
class basic_fstream
: public basic_iostream<charT,traits> {
public:
// Types
typedef charT char_type;
typedef typename traits::int_type ins_type;
typedef typename traits::pos_type pos_type;
typedef typename traits::off_type off_type;
_________________________
46) rdbuf() is never NULL because it always returns the private file
buf object.
// constructors/destructor
basic_fstream();
explicit basic_fstream(
const char* s,
ios_base::openmode mode = ios_base::in|ios_base::out);
// Members:
basic_filebuf<charT,traits>* rdbuf() const;
bool is_open();
void open(
const char* s,
ios_base::openmode mode = ios_base::in|ios_base::out);
void close();
private:
// basic_filebuf<charT,traits> sb; exposition only
};
1 The template class basic_fstream<charT,traits> supports reading and
writing from named files. It uses a basic_filebuf<charT,traits>object
For the sake of exposition, the maintained data is presented here as:
--sb, the basic_filebuf object.
27.8.1.12 basic_fstream constructors [lib.fstream.cons]
basic_fstream();
Effects:
Constructs an object of class basic_fstream<charT,traits>, initial
izing the base class with basic_iostream(&sb) and initializing sb
with basic_filebuf<charT,traits>().
explicit basic_fstream(const char* s, ios_base::openmode mode);
Effects:
Construcs an object of class basic_fstream<charT,traits>, initializ
ing the base class with basic_iostream(&sb) and initializing sb with
basic_filebuf<charT,traits>(). Then calls rdbuf()->open(s,mode).
If that function returns a null pointer, calls setsate(failbit),
(which may throw ios_base::failure).
27.8.1.13 Member functions [lib.fstream.members]
basic_filebuf<charT,traits>*( rdbuf() const;
Returns:
&sb
bool is_open();
Returns:
rdbuf()->is_open().
void open(const char* s, ios_base::openmode mode);
Effects:
Calls rdbuf()->open(s,mode), If that function returns a null
pointer, calls setsate(failbit), (which may throw ios_base::fail
ure). (_lib.iostate.flags_) )
void close();
Effects:
Calls rdbuf()->close() and, if that function returns false, calls
setstate(failbit)(_lib.iostate.flags_) (which may throw
ios_base::failure).
27.8.2 C Library files [lib.c.files]
1 Table 13 describes header <cstdio>.
Table 13--Header <cstdio> synopsis
+-------------------------------------------------------------------------------+
| Type Name(s) |
+-------------------------------------------------------------------------------+
|Macros: |
|BUFSIZ L_tmpnam SEEK_SET TMP_MAX |
|EOF NULL <cstdio> stderr _IOFBF |
|FILENAME_MAX SEEK_CUR stdin _IOLBF |
|FOPEN_MAX SEEK_END stdout _IONBF |
+-------------------------------------------------------------------------------+
|Types: FILE fpos_t size_t <cstdio> |
+-------------------------------------------------------------------------------+
|Functions: |
|clearerr fgets fscanf gets rewind |
|fclose fopen fseek perror scanf tmpnam |
|feof fprintf fsetpos printf setbuf ungetc |
|ferror fputc ftell putc setvbuf vprintf |
|fflush fputs fwrite puts sprintf vfprintf |
|fgetc fread getc remove sscanf vsprintf |
|fgetpos freopen getchar putchar rename tmpfile |
+-------------------------------------------------------------------------------+
SEE ALSO: ISO C subclause 7.9, Amendment 1 subclause 4.6.2.