______________________________________________________________________
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 Additional definitions:
--character In this clause, the term ``character'' means any unit ele
ment which, treated sequentially, can represent text. The term does
not only mean char and wchar_t type objects, but any value which can
be represented by a type which provides the definitions specified in
(_lib.string.char.traits_).
--character container type Character container type is a class or a
type used to represent a character. It is used for one of the tem
plate parameter of the iostream class templates.
--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 Type requirements [lib.iostreams.type.reqmts]
1 There are several types and functions needed for implementing the
iostream class templates. Some of these types and functions depend on
the definition of the character container type. The collection of
these functions describes the behavior which the implementation of the
iostream class templates expects to the character container class.
27.1.2.1 Type CHAR_T [lib.iostreams.char.t]
1 Those C++ programs that provide a character container type as the tem
plate parameter have to provide all of these functions as well as the
container class itself. The collection of these functions can be
regarded as the collection of the common definitions for the implemen
tation of the character container class.
2 No special definition/declaration is provided here. The base class
(or struct), string_char_traits provides the definitions common
between the string class templates and the iostream class templates.
3 Convertible to type INT_T.
27.1.2.2 Type INT_T [lib.iostreams.int.t]
1 Another character container type which can also hold an end-of-file
value. It is used as the return type of some of the iostream class
member functions. If CHAR_T is either char or wchar_t, INT_T shall be
int or wint_t, respectively.
27.1.2.3 Type OFF_T [lib.iostreams.off.t]
1 A type that can represent offsets to positional information.1) It is
used to represent:
--a signed displacement, measured in characters, from a specified
position within a sequence.
--an absolute position within a sequence.
2 The value OFF_T(-1) can be used as an error indicator.
3 The effect of passing to any function defined in this clause an OFF_T
value not obtained from a function defined in this clause (for exam
ple, assigned an arbitrary integer), is undefined, except where other
wise noted.
4 Convertible to type POS_T.2) But no validity of the resulting POS_T
value is ensured, whether or not the OFF_T value is valid.
27.1.2.4 Type POS_T [lib.iostreams.pos.t]
1 An implementation-defined type for seek operations which describes an
object that can store all the information necessary to reposition to
the position.
2 The type POS_T describes an object that can store all the information
necessary to restore an arbitrary sequence to a previous stream posi
tion and conversion state.3)
3 With a stream buffer for a repositional stream (but not an arbitrary-
positional stream), a C++ program can either obtain the current posi
tion of the stream buffer or specify the previous position previously
_________________________
1) It is usually a synonym for one if the signed basic integral types
whose representation at least as many bits as type long.
2) An implementation may use the same type for both OFF_T and POS_T.
3) The conversion state is used for sequences that translate between
wide-character and generalized multibyte encoding, as described in
Amendment 1 to the C Standard.
obtained
4 A class or built-in type P satisfies the requirements of a position
type, and a class or built-in type O satisfies the requirements of an
offset type if the following expressions are valid, as shown in Table
2.
5 In the following table,
--P refers to type POS_T,
--p and q refer to an values of type POS_T,
--O refers to type OFF_T,
--o refers to a value of type OFF_T, and
--i refers to a value of type int.
Table 2--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 |
+-----------------------------------------------------------------------------------------+
6 The behavior of the stream after restoring the position with a POS_T
value modified using any other arithmetic operations is undefined.
7 The stream operations whose return type is POS_T may return
POS_T(OFF_T(-1)) as an invalid POS_T value to signal an error.
8 The conversion POS_T(OFF_T(-1)) constructs the invalid POS_T value,
which is available only for comparing to the return value of such mem
ber functions.
27.2 Forward declarations [lib.iostream.forward]
Header <iosfwd> synopsis
namespace std {
template<class charT> class basic_ios;
template<class charT> class basic_istream;
template<class charT> class basic_ostream;
typedef basic_ios<char> ios;
typedef basic_ios<wchar_t> wios;
typedef basic_istream<char> istream;
typedef basic_istream<wchar_t> wistream;
typedef basic_ostream<char> ostream;
typedef basic_ostream<wchar_t> wostream;
}
1 The template class basic_ios<charT,traits> serves as a base class for
the classes basic_istream<charT,traits> and
basic_ostream<charT,traits>.
2 The class ios is an instance of the template class basic_ios, special
ized by the type char.
3 The class wios is a version of the template class basic_ios special
ized by the type wchar_t.
27.3 Standard iostream objects [lib.iostream.objects]
Header <iostream> synopsis
#include <fstream>
namespace std {
extern istream cin;
extern ostream cout;
extern ostream cerr;
extern ostream clog;
extern wistream win;
extern wostream wout;
extern wostream werr;
extern wostream wlog;
}
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. The objects are con
structed, and the associations are established, the first time an
object of class basic_ios<charT,traits>::Init is constructed. The
objects are not destroyed during program execution.4)
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;
6 The object clog controls output to a stream buffer associated with the
object stderr, declared in <cstdio> (_lib.c.files_).
_________________________
4) Constructors and destructors for static objects can access these
objects to read input from stdin or write output to stdout or stderr.
27.3.2 Wide stream objects [lib.wide.stream.objects]
wistream win;
1 The object win controls input from an unbuffered stream buffer associ
ated with the object stdin, declared in <cstdio>.
2 After the object win is initialized, win.tie() returns wout.
wostream wout;
3 The object wout controls output to an unbuffered stream buffer associ
ated with the object stdout, declared in <cstdio> (_lib.c.files_).
wostream werr;
4 The object werr controls output to an unbuffered stream buffer associ
ated with the object stderr, declared in <cstdio> (_lib.c.files_).
5 After the object werr is initialized, werr.flags() & unitbuf is
nonzero.
wostream wlog;
6 The object wlog 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
#include <stdexcept> // for exception
namespace std {
typedef OFF_T streamoff;
typedef OFF_T wstreamoff;
typedef INT_T streamsize;
template <class charT> struct ios_traits<charT>;
struct ios_traits<char>;
struct ios_traits<wchar_t>;
class ios_base;
template<class charT, class traits = ios_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 type OFF_T (_lib.iostreams.off.t_).
typedef OFF_T wstreamoff;
2 The type wstreamoff is an implementation-defined type that satisfies
the requirements of type OFF_T (_lib.iostreams.off.t_).
typedef POS_T streampos;
3 The type streampos is an implementation-defined type that satisfies
the requirements of type POS_T (_lib.iostreams.pos.t_).
typedef POS_T wstreampos;
4 The type wstreampos is an implementation-defined type that satisfies
the requirements of type POS_T (_lib.iostreams.pos.t_).
typedef INT_T streamsize;
5 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.5)
27.4.2 Template struct ios_traits [lib.ios.traits]
namespace std {
template <class charT> struct ios_traits<charT> {
// _lib.ios.traits.types_ Types:
typedef charT char_type;
typedef INT_T int_type;
typedef POS_T pos_type;
typedef OFF_T off_type;
typedef To be specified state_type;
// _lib.ios.traits.values_ values:
static char_type eos();
static int_type eof();
static int_type not_eof(char_type c);
static char_type newline();
static size_t length(const char_type* s);
// _lib.ios.traits.tests_ tests:
static bool eq_char_type(char_type, char_type);
static bool eq_int_type (int_type, int_type);
static bool is_eof(int_type);
static bool is_whitespace(const ctype<char_type> ctype&, char_type c);
_________________________
5) 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).
// _lib.ios.traits.convert_ conversions:
static char_type to_char_type(int_type);
static int_type to_int_type (char_type);
static char_type* copy(char_type* dst, const char_type* src, size_t n) ;
static state_type get_state(pos_type pos);
static pos_type get_pos (streampos fpos, state_type state);
};
}
1 The template struct ios_traits<charT> is a traits class which main
tains the definitions of the types and functions necessary to imple
ment the iostream class templates. The template parameter charT rep
resents the character container type and each specialized version pro
vides the default definitions corresponding to the specialized charac
ter container type.
2 An implementation shall provide the following two instantiations of
ios_traits:
struct ios_traits<char>;
struct ios_traits<wchar_t>;
27.4.2.1 ios_traits types [lib.ios.traits.types]
state_type is an implementation-defined value-oriented type. It holds
the conversion state, and is compatible with the function
locale::codecvt().
27.4.2.2 ios_traits value functions [lib.ios.traits.values]
char_type eos();
Returns:
The null character which is used for the terminator of null termi
nated character strings. The default constructor for the character
container type provides the value.
int_type eof();
Returns:
an int_type value which represents the end-of-file. It is returned
by several functions to indicate end-of-file state (no more input
from an input sequence or no more output permitted to an output
sequence), or to indicate an invalid return value.
int_type not_eof(char_type c);
Returns:
a value other than the end-of-file, even if c==eof().
Notes:
It is used in basic_streambuf<charT,traits>::overflow().
Returns:
int_type(c) if c!=eof().
char_type newline();
Returns:
a character value which represent the newline character of the basic
character set.
Notes:
It appears as the default parameter of
basic_istream<charT,traits>::getline().
size_t length(const char_type* s);
Effects:
Determines the length of a null terminated character string pointed
to by s.
27.4.2.3 ios_traits test functions [lib.ios.traits.tests]
bool eq_char_type(char_type c1, char_type c2);
Returns:
true if c1 and c2 represent the same character.
bool eq_int_type(int_type c1, int_type c2);
Returns:
true if c1 and c2 represent the same character.
bool is_eof(int_type c);
Returns:
true if c represents the end-of-file.
bool is_whitespace(char_type c, const ctype<char_type>& ctype);
Returns:
true if c represents a whitespace character. The default definition
is as if it returns ctype.isspace(c). (See also
_lib.istream.prefix_)
1 An implementation of the iostream class templates may use all of the
above static member functions in addition to the following three func
tions provided from the base struct string_char_traits<CHAR_T>.
27.4.2.4 ios_traits conversion [lib.ios.traits.convert]
functions
char_type to_char_type(int_type c);
Effects:
Converts a valid character value represented in the int_type to the
corresponding char_type value. If c is the end-of-file value, the
return value is unspecified.
int_type to_int_type(char_type c);
Effects:
Converts a valid character value represented in the char_type to the
corresponding int_type value.
char_type* copy(char_type* dest, const char_type* src, size_t n);
Effects:
Copies n characters from the object pointed to by src into the
object pointed to by dest. If copying takes place between objects
that overlap, the behavior is undefined.
state_type get_state(pos_type pos);
Returns:
0.
pos_type get_pos(streampos fpos, state_type state);
Returns:
pos_type(pos).
27.4.3 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;
typedef T4 seekdir;
static const seekdir beg;
static const seekdir cur;
static const seekdir end;
class Init;
// _lib.iostate.flags_ iostate flags:
iostate exceptions() const;
void exceptions(iostate except);
// _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);
int_type fill() const;
int_type fill(int_type ch);
int precision() const;
int precision(int prec);
int width() const;
int width(int 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);
protected:
ios_base();
private:
// static int index; exposition only
// int* 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;
--int* iarray, points to the first element of an arbitrary-length
integer 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.3.1 Types [lib.ios.types]
27.4.3.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.3.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 3:
Table 3--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; |
|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 4:
Table 4--fmtflags constants
+--------------------------------------+
| Constant Allowable values |
+--------------------------------------+
|adjustfield left | right | internal |
|basefield dec | oct | hex |
|floatfield scientific | fixed |
+--------------------------------------+
27.4.3.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 5:
Table 5--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.3.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 6:
Table 6--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.3.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 7:
Table 7--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.3.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_).
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.narrow.stream.objects_), win, wout, werr, and wlog
(_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(), and clog.flush().
27.4.3.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().
int_type fill() const;
Returns:
The character to use to pad (fill) an output conversion to the spec
ified field width (_lib.ostream.formatted_).
int_type fill(int_type fillch);
Postcondition:
&fillch == fill().
Returns:
The previous value of fill().
int precision() const;
Returns:
The precision (number of digits after the decimal point) to generate
on certain output conversions.
int precision(int prec);
Postcondition:
prec == precision().
Returns:
The previous value of precision().
int width() const;
Returns:
The field width (number of characters) to generate on certain output
conversions.
int width(int wide);
Postcondition:
wide == width().
Returns:
The previous value of width().
27.4.3.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;
Returns:
The classic "C" locale if no locale has been imbued. Otherwise,
returns the locale in which to perform locale-dependent input and
output operations.
27.4.3.4 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 int 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.
Returns:
iarray[idx].
Notes:
After a subsequent call to iword(int) for the same object, the ear
lier return value may no longer be valid.6)
_________________________
6) An implementation is free to implement both the integer array
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.
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.3.5 ios_base constructors [lib.ios.base.cons]
ios_base();
Effects:
Constructs an object of class ios_base, assigning initial values to
its member objects. The postconditions of this function are indi
cated in Table 8:
Table 8--ios_base() effects
+------------------------------------------------+
| Element Value |
+------------------------------------------------+
|rdstate() goodbit if sb is not a null |
| pointer, otherwise badbit. |
|exceptions() goodbit |
|flags() skipws | dec |
|width() zero |
|precision() 6 |
|fill() the space character |
|getloc() locale::classic() |
|index ??? |
|iarray a null pointer |
|parray a null pointer |
+------------------------------------------------+
_________________________
pointed at by iarray and the pointer array pointed at by parray as
sparse data structures, possibly with a one-element cache for each.
27.4.4 Template class basic_ios [lib.ios]
namespace std {
template<class charT, class traits = ios_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;
operator bool() 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;
// _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);
// _lib.ios.base.locales_ locales:
locale imbue(const locale& loc);
protected:
basic_ios();
void init(basic_streambuf<charT,traits>* sb);
};
}
27.4.4.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_),
void init(basic_streambuf<charT,traits>* sb);
27.4.4.2 Member functions [lib.basic.ios.members]
basic_ostream<charT,traits>* tie() const;
Returns:
An output sequence that is tied to (synchronized with) an input
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().
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
rdbuf()->pubimbue(loc) (_lib.streambuf.locales_).
basic_ios& copyfmt(const basic_ios& rhs);
Effects:
Assigns to the member objects of *this the corresponding member
objects of rhs, except that:
--rdstate() is 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.7)
_________________________
7) This suggests an infinite amount of copying, but the implementation
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.
Returns:
*this.
27.4.4.3 basic_ios iostate flags functions [lib.iostate.flags]
operator bool() const
Returns:
!fail().
bool operator!() const
Returns:
fail().
iostate rdstate() const;
Returns:
The control state of the stream buffer.
void clear(iostate state = goodbit) throw(failure);
Postcondition:
state == rdstate().
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) throw(failure);
Effects:
Calls clear(rdstate() | state) (which may throw basic_ios::failure
(_lib.ios::failure_)).
bool good() const;
Returns:
rdstate() == 0
_________________________
can keep track of the maximum element of the arrays that is non-zero.
bool eof() const;
Returns:
true if eofbit is set in rdstate().
bool fail() const;
Returns:
true if failbit or badbit is set in rdstate().8)
bool bad() const;
Returns:
true if badbit is set in rdstate().
iostate exceptions() const;
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.5 ios_base manipulators [lib.std.ios.manip]
27.4.5.1 fmtflags manipulators [lib.fmtflags.manip]
ios_base& boolalpha(ios_base& str);
Effects:
Calls str.setf(ios_base::boolalpha).
Returns:
str.9)
ios_base& noboolalpha(ios_base& str);
Effects:
Calls str.unsetf(ios_base::boolalpha).
_________________________
8) Checking badbit also for fail() is historical practice.
Returns:
str.
ios_base& showbase(ios_base& str);
Effects:
Calls str.setf(ios_base::showbase).
Returns:
str.
Notes:
Does not affect any extractors.
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.
27.4.5.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.5.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.5.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).
_________________________
9) The function signature dec(ios_base&) can be called by the function
signature basic_ostream& stream::operator<<(basic_ostream& (*)(ba
sic_ostream&)) to permit expressions of the form cout << dec to change
the format flags stored in cout.
Returns:
str.
27.5 Stream buffers [lib.stream.buffers]
Header <streambuf> synopsis
#include <ios> // for ios_traits
namespace std {
template<class charT, class traits = ios_traits<charT> >
class basic_streambuf;
typedef basic_streambuf<char> streambuf;
typedef basic_streambuf<wchar_t> wstreambuf;
}
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
candidate 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.
--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 = ios_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;
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:
int in_avail();
int_type snextc();
int_type sbumpc();
int_type sgetc();
int sgetn(char_type* s, streamsize n);
// _lib.streambuf.pub.pback_ Putback:
int_type sputbackc(char_type c);
int sungetc();
// _lib.streambuf.pub.put_ Put area:
int sputc(char_type c);
int_type 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
control 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:10)
--all its pointer member objects to null pointers,
--the getloc() member to the return value of locale::classic().
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;
_________________________
10) The default constructor is protected for class basic_streambuf to
assure that only objects for classes derived from this class may be
constructed.
Returns:
If pubimbue() has ever been called, then the last value of loc sup
plied, otherwise classic "C" locale locale::classic(). 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);
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]
int in_avail();
Returns:
If a read position is available, returns gend() - gnext(). 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().
Notes:
Uses traits::eof().
int_type sbumpc();
Returns:
If the input sequence read position is not available, returns
uflow(). Otherwise, returns char_type(*gptr()) and increments the
next pointer for the input sequence.
int_type sgetc();
Returns:
If the input sequence read position is not available, returns under
flow(). Otherwise, returns char_type(*gptr()).
int 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 c !=
gptr()[-1], returns pbackfail(c). Otherwise, decrements the next
pointer for the input sequence and returns *gptr().
int sungetc();
Returns:
If the input sequence putback position is not available, returns
pbackfail(). Otherwise, decrements the next pointer for the input
sequence and returns *gptr().
27.5.2.2.5 Put area [lib.streambuf.pub.put]
int sputc(char_type c);
Returns:
If the output sequence write position is not available, returns
overflow(c). Otherwise, stores c at the next pointer for the output
sequence, increments the pointer, and returns *pptr().
int_type 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 output 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.
Note:
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.virtuals_, _lib.filebuf.virtuals_).
Default behavior:
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::seekpos_,
_lib.filebuf::seekpos_).
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, and if gptr() is non-null, the
characters between gptr() and egptr() are restored to the input
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();11)
Returns:
a guaranteed lower bound on the number of characters that can be
read from the input sequence before a call to uflow() or underflow()
returns traits::eof(). A positive return value of indicates that
the next such call will not return traits::eof().12)
Default behavior:
Returns zero.
Notes:
Uses traits::eof().
_________________________
11) The morphemes of showmany are "es-how-many-see", not "show-manic".
12) The next such call might fail by throwing an exception. The in
tention is that the next call will return ``immediately.''
streamsize xsgetn(char_type* s, streamsize n);
Effects:
Assigns up to n characters to successive elements of the array whose
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.13)
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:
the first character of the pending sequence, if possible, without
moving the input sequence position past it. If the pending sequence
is null then the function fails.
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:
_________________________
13) Classes derived from basic_streambuf can provide more efficient
ways to implement xsgetn() and xsputn() by overriding these defini
tions from the base class.
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
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)
Returns:
traits::eof() to indicate failure.
Default behavior:
Returns traits::eof().
int_type uflow();
Requires:
The constraints are the same as for underflow(), except that the
result character is transfered from the pending sequence to the
backup sequence, and the pending sequence may not be empty before
the transfer.
Default behavior:
Calls underflow(traits::eof()). If underflow() returns
traits::eof(), returns traits::eof(). Otherwise, does gbump(-1) and
returns *gptr().
Returns:
traits::not_eof(c).
Notes:
Uses traits::eof().
27.5.2.4.4 Putback [lib.streambuf.virt.pback]
int_type pbackfail(int c = traits::eof());
Notes:
The public functions of basic_streambuf call this virtual function
only when gptr() is null, gptr() == eback(), or *gptr() != c. Other
calls shall also satisfy that constraint.
The pending sequence is defined as for underflow(), with the modifi
cations that
--If c == traits::eof() then the input sequence is backed up one char
acter before the pending sequence is determined.
--If c != traits::eof() 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 successive elements of the array whose first element is desig
nated by s. Writing stops when either n characters have been writ
ten 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 c == traits::eof() 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 specified14)
_________________________
14) That is, for each class derived from an instance of ba
sic_streambuf in this clause (_lib.stringbuf_, _lib.filebuf_), a spec
ification of how consuming a character effects the associated output
2)Let r be the number of characters in the pending sequence not con
sumed. 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.15)
Default behavior:
Returns traits::eof().
27.6 Formatting and manipulators [lib.iostream.format]
Header <istream> synopsis
#include <ios> // for ios_traits
namespace std {
template <class charT, class traits = ios_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
_________________________
sequence is given. There is no requirement on a program-defined
class.
15) Typically, overflow returns c to indicate success.
#include <ios> // for ios_traits
namespace std {
template <class charT, class traits = ioc_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
#include <istream>
#include <ostream>
namespace std {
typedef ? smanip;
smanip resetiosflags(ios_base::fmtflags mask);
smanip setiosflags (ios_base::fmtflags mask);
smanip setbase(int base);
smanip setfill(int c);
smanip setprecision(int n);
smanip setw(int n);
}
27.6.1 Input streams [lib.input.streams]
1 The header <istream> defines a type and a function signature that con
trol input from a stream buffer.
27.6.1.1 Template class basic_istream [lib.istream]
namespace std {
template <class charT, class traits = ios_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;
// _lib.istream.cons_ Constructor/destructor:
explicit basic_istream(basic_streambuf<charT,traits>* sb);
virtual ~basic_istream();
// _lib.istream.prefix_ Prefix/suffix:
bool ipfx(bool noskipws = false);
void isfx();
// _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>>(char_type* s);
basic_istream<charT,traits>& operator>>(char_type& c);
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,
char_type delim = traits::newline());
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);
};
}
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 except
that they do not invoke any virtual members of rdbuf() except uflow().
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::failure (_lib.iostate.flags_), before returning.
4 If one of these called functions throws an exception, then unless
explicitly noted otherwise the input function calls setstate(badbit)
and if badbit is on in exception() rethrows the exception without com
pleting its actions.
27.6.1.1.1 basic_istream constructors [lib.basic.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 basic_istream prefix and suffix [lib.istream.prefix]
bool ipfx(bool noskipws = false);
Effects:
If good() is true, prepares for formatted or unformatted input.
First, if tie() is not a null pointer, the function calls
tie()->flush() to synchronize the output sequence with any associ
ated external C stream.16) If noskipws is zero and flags() & skipws
is nonzero, the function extracts and discards each character as
long as the next available input character c is a whitespace charac
ter.
Notes:
The function basic_istream<charT,traits>::ipfx() uses the function
bool traits::is_whitespace(charT, const locale*) in the traits
structure to determine whether the next input character is
_________________________
16) The call tie()->flush() does not necessarily occur if the function
can determine that no synchronization is necessary.
whitespace or not.
1 To decide if the character c is a whitespace character, the function
performs ``as if'' it executes the following code fragment:
ctype<charT> ctype = getloc().use<ctype<charT> >();
if (traits::is_whitespace (c, ctype)!=0)
// c is a whitespace character.
Returns:
If, after any preparation is completed, good() is true, returns
true. Otherwise, it calls setstate(failbit) (which may throw
ios_base::failure (_lib.iostate.flags_)) and returns false.17)
2 [Example: A typical implementation of the ipfx() function may be as
follows:
template <class charT, class traits = ios_traits<charT> >
int basic_istream<charT,traits>::ipfx() {
...
// skipping whitespace according to a constraint function,
// is_whitespace
intT c;
typedef ctype<charT> ctype_type;
ctype_type& ctype = getloc().use<ctype_type>();
while ((c = rdbuf()->snextc()) != traits::eof()) {
if (!traits::is_whitespace (c,ctype)==0) {
rdbuf()->sputbackc (c);
break;
}
}
...
}
--end example]
3 When using ios_traits<char> or ios_traits<wchar_t>, the behavior of
the function traits::is_whitespace() is ``as if'' it invokes:
ctype = getloc().use<ctype<charT> >().is(ctype<charT>::space, c);
(see _lib.ios.traits.tests_); otherwise, the behavior of the function
traits::is_whitespace() is unspecified.
4 [Example: Those C++ programs that want to use locale-independent
whitespace predicate can specify their definition of is_whitespace in
their new ios_traits as follows:
struct my_traits : public ios_traits<char> {
typedef my_char_traits char_traits;
};
struct my_char_traits : public ios_traits<char> {
static bool is_whitespace (char c, const ctype<charT>& ctype) {
....(my own implementation)...
}
};
_________________________
17) The functions ipfx(int) and isfx() can also perform additional im
plementation-dependent operations.
--end example]
void isfx();
Effects:
None.
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 calling ipfx(). If
that function returns true, the function endeavors to obtain the
requested input. In any case, the formatted input function ends by
calling isfx(), then returns *this
2 Some formatted input functions endeavor to obtain the requested input
by parsing characters extracted from the input sequence, converting
the result to a value of some scalar data type, and storing the con
verted value in an object of that scalar data type.
3 The numeric conversion behaviors of the following extractors are
locale-dependent.
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);
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'' it performed
the following code fragment:
HOLDTYPE tmp;
num_get<charT>& fmt = loc.use< num_get<charT> >();
fmt.get (*this, 0, *this, loc, tmp);
if ((TYPE)tmp != tmp) { // set fail bit...
} else val = (TYPE)tmp;
In the above fragment, loc stands for the private member of the
basic_ios class, TYPE stands for the type of the argument of the
extractor, and HOLDTYPE is as follows;
--for short, int and long, HOLDTYPE is long;
--for unsigned short, unsigned int and unsigned long, HOLDTYPE is
unsigned long.
--for float, double, HOLDTYPE is double.
--for long double, HOLDTYPE is long double.
4 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 locale relies on this type as its
interface to istream, since the flexibility it has been abstracted
away from direct dependence on istream.
5 In case the converting result is a value of either an integral type (
short, unsigned short, int, unsigned int, long, unsigned long) or a
float type ( float, double, long double), performing to parse and con
vert the result depend on the imbued locale object. So the behavior
of the above type extractors are locale-dependent. The imbued locale
object uses an istreambuf_iterator to access the input character
sequence.
6 The behavior of such functions is described in terms of the conversion
specification ``as if'' for an equivalent call to the function
::fscanf()18) operating with the global locale set to getloc(), with
the following alterations:
--The formatted input function extracts characters from a stream
buffer, rather than reading them from an input file.19)
--If (flags() & skipws) == 0, the function does not skip any leading
white space. In that case, if the next input character is white
space, the scan fails.
--If the converted data value cannot be represented as a value of the
specified scalar data type, a scan failure occurs.
7 [Note: For conversion to an integral type other than a character type,
the function determines the integral conversion specifier as indicated
in Table 9:
_________________________
18) The signature fscanf(FILE*, const char*, ...) is declared in
<cstdio> (_lib.c.files_)
19) The stream buffer can, of course, be associated with an input
file, but it need not be.
Table 9--Integer conversions
+------------------------------------------------+
| State stdio equivalent |
+------------------------------------------------+
|(flags() & basefield) == oct %o |
+------------------------------------------------+
|(flags() & basefield) == hex %x |
|(flags() & uppercase) != 0 %X |
+------------------------------------------------+
|(flags() & basefield) == 0 %i |
+------------------------------------------------+
|Otherwise, |
+------------------------------------------------+
|signed integral type %d |
+------------------------------------------------+
|unsigned integral type %u |
+------------------------------------------------+
--end note]
8 If the scan fails for any reason, the formatted input function calls
setstate(failbit), which may throw ios_base::failure
(_lib.iostate.flags_).
27.6.1.2.2 basic_istream::operator>> [lib.istream::extractors]
basic_istream<charT,traits>& operator>>
(basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&))
Returns:
pf(*this).20)
basic_istream<charT,traits>& operator>>
(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&));
Effects:
Calls pf(*this), then returns *this.21)
basic_istream<charT,traits>& operator>>(char_type* s);
_________________________
20) See, for example, the function signature ws(basic_istream&)
(_lib.istream.manip_).
21) See, for example, the function signature
dec(basic_ios<charT,traits>&) (_lib.basefield.manip_).
Effects:
Extracts characters and stores them into successive locations of an
array whose first element is designated by s.22) If width() is
greater than zero, the maximum number of characters stored n is
width(); otherwise it is numeric_limits<int>::max() (_lib.limits_).
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;
--traits::is_whitespace(c,ctype) is true for the next available input
character c. In the above code fragment, the argument ctype is
acquired by getloc().use<ctype<charT> >().
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 location of
the array and calls width(0).
Returns:
*this.
Notes:
Uses traits::eos().
basic_istream<charT,traits>& operator>>(char_type& c);
Effects:
Extracts a character, if one is available, and stores it in c. Oth
erwise, the function calls setstate(failbit).
Returns:
*this.
basic_istream<charT,traits>& operator>>(bool& n);
Effects:
Converts a boolean value, if one is available, and stores it in x.
Returns:
*this.
Notes:
Behaves as if:
getloc().use<num_get<charT,istreambuf_iterator<charT,traits> >().
get(*this, 0, *this, getloc(), n);
[Note: num_get<>::get() just sets the iostate flags, without check
ing whether failure() should be thrown; so operator>>() needs to
check that. --end note]
_________________________
22) Note that this function is not overloaded on types signed char and
unsigned char.
3 If flags.flag() & ios_base::boolalpha is false, num_get<>::get()
(_lib.category.numeric_) tries to read an integer value, which if
found must be 0 or 1; if the boolalpha flag is true, it reads charac
ters until it determines whether the numpunct<>::truename() or false
name() sequence23) is present. In either case if an exact match is
not found calls setstate(failbit).
basic_istream<charT,traits>& operator>>(short& n);
Effects:
Converts a signed short integer, if one is available, and stores it
in n.
Returns:
*this.
basic_istream<charT,traits>& operator>>(unsigned short& n);
Effects:
Converts an unsigned short integer, if one is available, and stores
it in n.
Returns:
*this.
basic_istream<charT,traits>& operator>>(int& n);
Effects:
Converts a signed integer, if one is available, and stores it in n.
Returns:
*this.
basic_istream<charT,traits>& operator>>(unsigned int& n);
Effects:
Converts an unsigned integer, if one is available, and stores it in
n.
Returns:
*this.
basic_istream<charT,traits>& operator>>(long& n);
Effects:
Converts a signed long integer, if one is available, and stores it
in n.
_________________________
23) The boolean value names for the default classic C" locale are
false" and true".
Returns:
*this.
basic_istream<charT,traits>& operator>>(unsigned long& n);
Effects:
Converts an unsigned long integer, if one is available, and stores
it in n.
Returns:
*this.
basic_istream<charT,traits>& operator>>(float& f);
Effects:
Converts a float, if one is available, and stores it in f.
Returns:
*this.
basic_istream<charT,traits>& operator>>(double& f);
Effects:
Converts a double, if one is available, and stores it in f.
Returns:
*this.
basic_istream<charT,traits>& operator>>(long double& f);
Effects:
Converts a long double, if one is available, and stores it in f.
Returns:
*this.
basic_istream<charT,traits>& operator>>(void*& p);
Effects:
Converts a pointer to void, if one is available, and stores it in p.
Returns:
*this.
basic_istream<charT,traits>& operator>>
(basic_streambuf<charT,traits>* sb);
Requires:
sb shall be non-null.
Effects:
If sb is null, calls setstate(badbit), 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). set
state(badbit) is not called
4 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 calling ipfx(1).
If that function returns nonzero, the function endeavors to extract
the requested input. It also counts the number of characters
extracted. In any case, the unformatted input function ends by stor
ing the count in a member object and calling isfx(), then returning
the value specified for the unformatted input function.
streamsize gcount() const;
Returns:
The number of characters extracted by the last unformatted input
member function called for the object.
int_type get();
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.24)
_________________________
24) Note that this function is not overloaded on types signed charand
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.25) 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 con
trolled by rdbuf(). 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).
_________________________
unsigned char.
25) Note that this function is not overloaded on types signed char and
unsigned char.
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 = traits::newline());
Effects:
Extracts characters and stores them into successive locations of an
array whose first element is designated by s.26) 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);27)
3)n - 1 characters are stored (in which case the function calls set
state(failbit)).
4 These conditions are tested in the order shown.28)
5 If the function extracts no characters, it calls setstate(failbit)
(which may throw ios_base::failure (_lib.iostate.flags_)).29)
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:
_________________________
26) Note that this function is not overloaded on types signed char and
unsigned char.
27) Since the final input character is ``extracted,'' it is counted in
the gcount(), even though it is not stored.
28) This allows an input line which exactly fills the buffer, without
setting failbit. This is different behavior than the historical AT&T
implementation.
29) This implies an empty input line will not cause failbit to be set.
#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) || 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>&
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.30) 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:
Extracts characters and stores them into successive locations of an
array whose first element is designated by s.
Returns:
A value based on in_avail():
--If in_avail() < 0, calls setstate(eofbit) (which may throw
ios_base::failure (_lib.iostate.flags_)), and returns zero;
--If in_avail() == 0, returns zero;
--If in_avail() > 0, returns read(s, min(in_avail(),n)).
basic_istream<charT,traits>& putback(char_type c);
Effects:
Calls rdbuf->sputbackc(c). If that function returns traits::eof(),
calls setstate(badbit) (which may throw ios_base::failure
(_lib.iostate.flags_)).
Returns:
*this.
basic_istream<charT,traits>& unget();
Effects:
Calls rdbuf->sungetc(). If that function returns traits::eof(),
calls setstate(badbit) (which may throw ios_base::failure
(_lib.iostate.flags_)).
_________________________
30) Note that this function is not overloaded on types signed char and
unsigned char.
Returns:
*this.
int sync();
Effects:
If rdbuf() is a null pointer, returns traits::eof(). Otherwise,
calls rdbuf()->pubsync() and, if that function returns
traits::eof(), calls setstate(badbit) (which may throw
ios_base::failure (_lib.iostate.flags_), and returns traits::eof().
Otherwise, returns zero.
Notes:
Uses traits::eof().
pos_type tellg();
Returns:
if fail() == true, returns streampos(-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:
Skips any whitespace in the input sequence: saves a copy of
is.fmtflags, then clears is.skipws in is.flags(). Then calls
is.ipfx(), then is.isfx(), then restores is.flags() to its saved
value.
Returns:
is.
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 = ioc_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.prefix_ Prefix/suffix:
bool opfx();
void osfx();
// _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<<(const char_type* s);
basic_ostream<charT,traits>& operator<<(char_type c);
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);
};
}
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).
They may use other public members of basic_ostream except that they do
not invoke any virtual members of rdbuf() except overflow(). If the
called function throws an exception, the output function calls set
state(badbit), which may throw ios_base::failure
(_lib.iostate.flags_), and if badbit is on in exceptions() rethrows
the exception.
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 basic_ostream prefix and suffix [lib.ostream.prefix]
functions
bool opfx();
1 If good() is nonzero, prepares for formatted or unformatted output.
If tie() is not a null pointer, calls tie()->flush().31)
Returns:
good().32)
void osfx();
_________________________
31) The call tie()->flush() does not necessarily occur if the function
can determine that no synchronization is necessary.
32) The function signatures opfx() and osfx() can also perform addi
tional implementation-dependent operations.
2 If (flags() & unitbuf) != 0, calls flush().
pos_type tellp();
Returns:
if fail() == true, returns streampos(-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 calling opfx(). If
that function returns nonzero, the function endeavors to generate the
requested output. In any case, the formatted output function ends by
calling osfx(), then returning the value specified for the formatted
output function.
2 The numeric conversion behaviors of the following inserters are
locale-dependent (_lib.category.numeric_):
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);
3 The classes num_get<> and num_put<> handle locale-dependent numeric
formatting and parsing. The above 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:
num_put<charT>& fmt = loc.use< num_put<charT> >();
fmt.put (ostreambuf_iterator(*this), *this, loc, val);
In the above fragment, loc stands for the private member of the
basic_ios class which maintains the imbued localeobj