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 summarized in Table 82:
| Table 82---Input/output library summary |
_ _____________________________________________ _ Subclause Header(s) _ _____________________________________________ _____________________________________________ _ 27.1 Requirements _____________________________________________ _ 27.2 Forward declarations <iosfwd> _____________________________________________ _ 27.3 Standard iostream objects <iostream> _____________________________________________ _ 27.4 Iostreams base classes <ios> _____________________________________________ _ 27.5 Stream buffers <streambuf> _____________________________________________ <istream> 27.6 Formatting and manipulators <ostream> _ <iomanip> _____________________________________________ 27.7 String streams <sstream> _ <cstdlib> _____________________________________________ <fstream> 27.8 File streams <cstdio> _ <cwchar> _____________________________________________ |
namespace std {
template<class charT> class char_traits;
template<> class char_traits<char>;
template<> class char_traits<wchar_t>;
template<class T> class allocator;
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;
class Allocator = allocator<charT> >
template <class charT, class traits = char_traits<charT>,class basic_stringbuf;
class Allocator = allocator<charT> >
template <class charT, class traits = char_traits<charT>,class basic_istringstream;
class Allocator = allocator<charT> >
template <class charT, class traits = char_traits<charT>,class basic_ostringstream;
class Allocator = allocator<charT> >
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 istreambuf_iterator;
typedef basic_ios<char> ios; typedef basic_ios<wchar_t> wios; typedef basic_streambuf<char> streambuf; typedef basic_istream<char> istream; typedef basic_ostream<char> ostream; typedef basic_iostream<char> iostream;class ostreambuf_iterator;
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_iostream<wchar_t> wiostream; 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;
}
1 Default template arguments are described as appearing both in <iosfwd> and in the synopsis of other headers but it is well-formed to include both <iosfwd> and one or more of the other headers.263)
2 [Note: 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.
3 The template class basic_streambuf<charT,traits> serves as a base class for template classes basic_stringbuf and basic_filebuf.
4 The template class basic_istream serves as a base class for template classes basic_istringstream and basic_ifstream
5 The template class basic_ostream serves as a base class for template classes basic_ostringstream and basic_ofstream
6 The template class basic_iostream serves as a base class for template classes basic_stringstream and basic_fstream.
7 Other typedefs define instances of template classes specialized for char or wchar_t types.
8 The template class fpos<charT> is a class used for specifying file position information.
9 The types streampos and wstreampos are used for positioning streams specialized on char and wchar_t respectively.
10 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;
// ...
}
263) It is the implementation's responsibility to implement headers so that including <iosfwd> and other headers does not violate the rules about multiple occurences of default arguments. [back to text]
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> (27.8.2).
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 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, and in any case before the body of main begins execution.264) The objects are not destroyed during program execution.265)
264) If it is possible for them to do so, implementations are encouraged to initialize the objects earlier than required. [back to text]265) Constructors and destructors for static objects can access these objects to read input from stdin or write output to stdout or stderr. [back to text]
istream cin;
1 The object cin controls input from a stream buffer associated with the object stdin, declared in <cstdio>.
2 After the object cin is initialized, cin.tie() returns &cout. Its state is otherwise the same as required for ios_base::init (27.4.4.1).
ostream cout;
3 The object cout controls output to a stream buffer associated with the object stdout, declared in <cstdio> (27.8.2).
ostream cerr;
4 The object cerr controls output to a stream buffer associated with the object stderr, declared in <cstdio> (27.8.2).
5 After the object cerr is initialized, cerr.flags() & unitbuf is nonzero. Its state is otherwise the same as required for ios_base::init (27.4.4.1).
ostream clog;
6 The object clog controls output to a stream buffer associated with the object stderr, declared in <cstdio> (27.8.2).
wistream wcin;
1 The object wcin controls input from a stream buffer associated with the object stdin, declared in <cstdio>.
2 After the object wcin is initialized, wcin.tie() returns &wcout. Its state is otherwise the same as required for ios_base::init (27.4.4.1).
wostream wcout;
3 The object wcout controls output to a stream buffer associated with the object stdout, declared in <cstdio> (27.8.2).
wostream wcerr;
4 The object wcerr controls output to a stream buffer associated with the object stderr, declared in <cstdio> (27.8.2).
5 After the object wcerr is initialized, wcerr.flags() & unitbuf is nonzero. Its state is otherwise the same as required for ios_base::init (27.4.4.1).
wostream wclog;
6 The object wclog controls output to a stream buffer associated with the object stderr, declared in <cstdio> (27.8.2).
#include <iosfwd>
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;
// 27.4.5, 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);
// 27.4.5.2 adjustfield:
ios_base& internal (ios_base& str);
ios_base& left (ios_base& str);
ios_base& right (ios_base& str);
// 27.4.5.3 basefield:
ios_base& dec (ios_base& str);
ios_base& hex (ios_base& str);
ios_base& oct (ios_base& str);
// 27.4.5.4 floatfield:
ios_base& fixed (ios_base& str);
ios_base& scientific (ios_base& str);
}
typedef OFF_T streamoff;
1 The type streamoff is an implementation-defined type that satisfies the requirements of 27.4.3.2.
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.266)
266) 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). [back to text]
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;
// 27.4.2.2 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);
// 27.4.2.3 locales:
locale imbue(const locale& loc);
locale getloc() const;
// 27.4.2.5 storage:
static int xalloc();
long& iword(int index);
void*& pword(int index);
// destructor
virtual ~ios_base();
// 27.4.2.6 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);
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:
2 It maintains several kinds of data:
3 [Note: For the sake of exposition, the maintained data is presented here as:
namespace std {
class ios_base::failure : public exception {
public:
explicit failure(const string& msg);
virtual ~failure();
virtual const char* what() const throw();
};
}
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);
2 Effects: Constructs an object of class failure, initializing the base class with exception(msg).
3 Postcondition: strcmp(what(), msg.c_str()) == 0
const char* what() const;
4 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 (17.3.2.1.2). Setting its elements has the effects indicated in Table 83:
| Table 83---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
identical to right if no such point is designated;
left adds fill characters on the right (final positions) of certain generated output;
oct converts integer input or generates integer output in octal base;
right adds fill characters on the left (initial positions) 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 unconditionally in generated floating-point
output;
showpos generates a + sign in non-negative generated numeric output;
skipws skips leading white space before certain input 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 84:
| Table 84---fmtflags constants |
_ ___________________________________________ _ Constant Allowable values _ ___________________________________________ ___________________________________________ adjustfield left | right | internal basefield dec | oct | hex _ floatfield scientific | fixed ___________________________________________ |
typedef T2 iostate;
1 The type iostate is a bitmask type (17.3.2.1.2) that contains the elements indicated in Table 85:
| Table 85---iostate effects |
_ _______________________________________________________________________________ _ Element Effect(s) if set _ _______________________________________________________________________________ _______________________________________________________________________________ badbit indicates a loss of integrity in an input or output sequence (such as an irrecover able 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 _ output operation failed to generate the desired characters. _______________________________________________________________________________ |
2 Type iostate also defines the constant:
typedef T3 openmode;
1 The type openmode is a bitmask type (17.3.2.1.2). It contains the elements indicated in Table 86:
| Table 86---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 _______________________________________________________________________ |
typedef T4 seekdir;
1 The type seekdir is an enumerated type (17.3.2.1.1) that contains the elements indicated in Table 87:
| Table 87---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 ________________________________________________________________________________ |
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 construction of the eight objects declared in <iostream> (27.3) that associate file stream buffers with the standard C streams provided for by the functions declared in <cstdio> (27.8.2).
2 For the sake of exposition, the maintained data is presented here as:
Init();
3 Effects: Constructs an object of class Init. If init_cnt is zero, the function stores the value one in
init_cnt, then constructs and initializes the objects cin, cout, cerr, clog (27.3.1), wcin, wcout, wcerr, and wclog (27.3.2). In any case, the function then adds one to the value stored in init_cnt. ~Init();
4 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().
fmtflags flags() const;
1 Returns: The format control information for both input and output.
fmtflags flags(fmtflags fmtfl);
2 Postcondition: fmtfl == flags().
3 Returns: The previous value of flags().
fmtflags setf(fmtflags fmtfl);
4 Effects: Sets fmtfl in flags().
5 Returns: The previous value of flags().
fmtflags setf(fmtflags fmtfl, fmtflags mask);
6 Effects: Clears mask in flags(), sets fmtfl & mask in flags().
7 Returns: The previous value of flags().
void unsetf(fmtflags mask);
8 Effects: Clears mask in flags().
streamsize precision() const;
9 Returns: The precision (number of digits after the decimal point) to generate on certain output conversions.
streamsize precision(streamsize prec);
10 Postcondition: prec == precision().
11 Returns: The previous value of precision().
streamsize width() const;
12 Returns: The minimum field width (number of characters) to generate on certain output conversions.
streamsize width(streamsize wide);
13 Postcondition: wide == width().
14 Returns: The previous value of width().
locale imbue(const locale loc);
1 Effects: Calls each registered callback pair (fn,index) (27.4.2.6) 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.
2 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
3 Postcondition: loc == getloc().
locale getloc() const;
4 Returns: The previous value of getloc().
bool sync_with_stdio(bool sync = true);
1 Returns: true if the standard iostream objects (27.3) are synchronized and otherwise returns false. The first time it is called, the function returns true.
2 Effects: If any input or output operation has occurred using the standard streams prior to the call, the effect is implementation-defined. Otherwise, called with a false argument, it allows the standard streams to operate independently of the standard C streams.
static int xalloc();
1 Returns: index ++.
long& iword(int idx);
2 Effects: If iarray is a null pointer, allocates an array of long of unspecified 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 different index, after a call to its copyfmt member, or when the object is destroyed.267) If the function fails268) it sets badbit, which may throw an exception.
3 Returns: On success iarray[idx]. On failure, a valid long& initialized to 0.
void* & pword(int idx);
4 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 reference returned may become invalid after another call to the object's pword member with a different index, after call to its copyfmt member, or when the object is destroyed. If the function fails269) it sets badbit, which may throw an exception.
5 Returns: On success parray[idx]. On failure a valid void*& initialized to 0.
6 Notes: After a subsequent call to pword(int) for the same object, the earlier return value may no longer be valid.
267) 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. [back to text]268) for example, because it cannot allocate space. [back to text]
269) for example, because it cannot allocate space. [back to text]
void register_callback(event_callback fn, int index);
1 Effects: Registers the pair (fn,index) such that during calls to imbue() (27.4.2.3), copyfmt(), or
called when an event occurs, in opposite order of registration. Functions registered while a callback function is active are not called until the next event.~ios_base() (27.4.2.7), the function fn is called with argument index. Functions registered are
2 Requires: The function fn shall not throw exceptions.
3 Notes: Identical pairs are not merged. A function registered twice will be called twice.
ios_base();
1 Effects: Each ios_base member has an indeterminate value after construction.
~ios_base()
2 Effects: Destroys an object of class ios_base. Calls each registered callback pair (fn,index) (27.4.2.6) as (*fn)(erase_event,*this,index) at such time that any ios_base member function called from within fn has well defined results.
namespace std {
template <class stateT> class fpos {
public:
// 27.4.3.1 Members
stateT state() const;
void state(stateT);
private;
stateT st; // exposition only
};
}
void state(stateT s);
1 Effects: Assign s to st.
stateT state();
2 Returns: Current value of st.
1 Operations specified in Table 88 are permitted. In that table,
| Table 88---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) fpos converts from
_ offset
________________________________________________________________________________
O(p) OFF_T converts to P(O(p)) == p
_ offset
________________________________________________________________________________
_ p == q convertible to bool == is an equivalence relation
________________________________________________________________________________
_ p != q convertible to bool !(p==q)
________________________________________________________________________________
q = p + o fpos + offset q-o == p
_ p += o
________________________________________________________________________________
q = p - o fpos - offset q+o == p
_ p -= o
________________________________________________________________________________
_ o = p - q OFF_T distance q+o == p
________________________________________________________________________________
streamsize(o) streamsize converts streamsize(O(sz)) == sz
_ O(sz) OFF_T converts streamsize(O(sz)) == sz
________________________________________________________________________________
|
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.
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);
// 27.4.4.1 Constructor/destructor:
explicit basic_ios(basic_streambuf<charT,traits>* sb);
virtual ~basic_ios();
// 27.4.4.2 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);
// 27.4.2.3 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);
private:
basic_ios(const basic_ios& ); // not defined
basic_ios& operator=(const basic_ios&); // not defined
};
}
explicit basic_ios(basic_streambuf<charT,traits>* sb);
1 Effects: Constructs an object of class basic_ios, assigning initial values to its member objects by calling init(sb).
basic_ios();
2 Effects: Constructs an object of class basic_ios (27.4.2.7) leaving 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);
3 Postconditions: The postconditions of this function are indicated in Table 89:
| Table 89---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() widen(' ');
getloc() a copy of the value returned by locale()
iarray a null pointer
_ parray a null pointer
__________________________________________________________________
|
basic_ostream<charT,traits>* tie() const;
1 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);
2 Postcondition: tiestr == tie().
3 Returns: The previous value of tie().
basic_streambuf<charT,traits>* rdbuf() const;
4 Returns: A pointer to the streambuf associated with the stream.
basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb);
5 Postcondition: sb == rdbuf().
6 Effects: Calls clear().
7 Returns: The previous value of rdbuf().
// 27.4.2.3 locales: locale imbue(const locale& loc);
8 Effects: Calls ios_base::imbue(loc) (27.4.2.3) and if rdbuf()!=0 then rdbuf()- >pubimbue(loc) (27.5.2.2.1).
9 Returns: The prior value of ios_base::imbue().
char narrow(char_type c, char dfault) const;
10 Returns: use_facet< ctype<char_type> >(getloc()).narrow(c,dfault)
char_type widen(char c) const;
11 Returns: use_facet< ctype<char_type> >(getloc()).widen(c)
char_type fill() const
12 Returns: The character used to pad (fill) an output conversion to the specified field width.
char_type fill(char_type fillch);
13 Postcondition: fillch == fill()
14 Returns: The previous value of fill().
basic_ios& copyfmt(const basic_ios& rhs);
15 Effects: Assigns to the member objects of *this the corresponding member objects of rhs, except that:
16 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.
17 Before copying any parts of rhs, calls each registered callback pair (fn,index) as (*fn)(erase_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).
18 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.
19 Returns: *this.
270) This suggests an infinite amount of copying, but the implementation can keep track of the maximum element of the arrays that is non-zero. [back to text]
operator void*() const
1 Returns: If fail() then a null pointer; otherwise some non-null pointer to indicate success.
bool operator!() const
2 Returns: fail().
iostate rdstate() const;
3 Returns: The error state of the stream buffer.
void clear(iostate state = goodbit);
4 Postcondition: If rdbuf()!=0 then state == rdstate(); otherwise
rdstate()==state|ios_base::badbit.
5 Effects: If (rdstate() & exceptions()) == 0, returns. Otherwise, the function throws an object fail of class basic_ios::failure (27.4.2.1.1), constructed with implementation-defined argument values.
void setstate(iostate state);
6 Effects: Calls clear(rdstate() | state) (which may throw basic_ios::failure (27.4.2.1.1)).
bool good() const;
7 Returns: rdstate() == 0
bool eof() const;
8 Returns: true if eofbit is set in rdstate().
bool fail() const;
9 Returns: true if failbit or badbit is set in rdstate().271)
bool bad() const;
10 Returns: true if badbit is set in rdstate().
iostate exceptions() const;
11 Returns: A mask that determines what elements set in rdstate() cause exceptions to be thrown.
void exceptions(iostate except);
12 Postcondition: except == exceptions().
13 Effects: Calls clear(rdstate()).
271) Checking badbit also for fail() is historical practice. [back to text]
ios_base& boolalpha(ios_base& str);
1 Effects: Calls str.setf(ios_base::boolalpha).
2 Returns: str.
ios_base& noboolalpha(ios_base& str);
3 Effects: Calls str.unsetf(ios_base::boolalpha).
4 Returns: str.
ios_base& showbase(ios_base& str);
5 Effects: Calls str.setf(ios_base::showbase).
6 Returns: str.
ios_base& noshowbase(ios_base& str);
7 Effects: Calls str.unsetf(ios_base::showbase).
8 Returns: str.
ios_base& showpoint(ios_base& str);
9 Effects: Calls str.setf(ios_base::showpoint).
10 Returns: str.
ios_base& noshowpoint(ios_base& str);
11 Effects: Calls str.unsetf(ios_base::showpoint).
12 Returns: str.
ios_base& showpos(ios_base& str);
13 Effects: Calls str.setf(ios_base::showpos).
14 Returns: str.
ios_base& noshowpos(ios_base& str);
15 Effects: Calls str.unsetf(ios_base::showpos).
16 Returns: str.
ios_base& skipws(ios_base& str);
17 Effects: Calls str.setf(ios_base::skipws).
18 Returns: str.
ios_base& noskipws(ios_base& str);
19 Effects: Calls str.unsetf(ios_base::skipws).
20 Returns: str.
ios_base& uppercase(ios_base& str);
21 Effects: Calls str.setf(ios_base::uppercase).
22 Returns: str.
ios_base& nouppercase(ios_base& str);
23 Effects: Calls str.unsetf(ios_base::uppercase).
24 Returns: str.
ios_base& unitbuf(ios_base& str);
25 Effects: Calls str.setf(ios_base::unitbuf).
26 Returns: str.
ios_base& nounitbuf(ios_base& str);
27 Effects: Calls str.unsetf(ios_base::unitbuf).
28 Returns: str.
ios_base& internal(ios_base& str);
1 Effects: Calls str.setf(ios_base::internal, ios_base::adjustfield).
2 Returns: str.
ios_base& left(ios_base& str);
3 Effects: Calls str.setf(ios_base::left, ios_base::adjustfield).
4 Returns: str.
ios_base& right(ios_base& str);
5 Effects: Calls str.setf(ios_base::right, ios_base::adjustfield).
6 Returns: str.
ios_base& dec(ios_base& str);
1 Effects: Calls str.setf(ios_base::dec, ios_base::basefield).
2 Returns: str.
ios_base& hex(ios_base& str);
3 Effects: Calls str.setf(ios_base::hex, ios_base::basefield).
4 Returns: str.
ios_base& oct(ios_base& str);
5 Effects: Calls str.setf(ios_base::oct, ios_base::basefield).
6 Returns: str.
ios_base& fixed(ios_base& str);
1 Effects: Calls str.setf(ios_base::fixed, ios_base::floatfield).
2 Returns: str.
ios_base& scientific(ios_base& str);
3 Effects: Calls str.setf(ios_base::scientific, ios_base::floatfield).
4 Returns: str.
namespace std {
template <class charT, class traits = char_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 output to character sequences.
1 Stream buffers can impose various constraints on the sequences they control. Some constraints are:
2 Each sequence is characterized by three pointers which, if non-null, all point into the same charT array object. The array object represents, 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:
3 The following semantic constraints shall always apply for any set of three pointers for a sequence, using the pointer names given immediately above:
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();
pos_type pubseekoff(off_type off, ios_base::seekdir way,pubsetbuf(char_type* s, streamsize n);
ios_base::openmode which =
ios_base::in | ios_base::out);
ios_base::openmode which =
ios_base::in | ios_base::out);
basic_streambuf();
// 27.5.2.3.1 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);
// 27.5.2.3.2 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);
// 27.5.2.4 virtual functions:
// 27.5.2.4.1 Locales:
virtual void imbue(const locale &loc);
// 27.5.2.4.2 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();
// 27.5.2.4.3 Get area:
virtual int showmanyc();
virtual streamsize xsgetn(char_type* s, streamsize n);
virtual int_type underflow();
virtual int_type uflow();
// 27.5.2.4.4 Putback:
virtual int_type pbackfail(int_type c = traits::eof());
// 27.5.2.4.5 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:
2 The class streambuf is a specialization of the template class basic_streambuf specialized for the type char.
3 The class wstreambuf is a specialization of the template class basic_streambuf specialized for the type wchar_t.
basic_streambuf();
1 Effects: Constructs an object of class basic_streambuf<charT,traits> and initializes:273)
2 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.
272) 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. [back to text]273) The default constructor is protected for class basic_streambuf to assure that only objects for classes derived from this class may be constructed. [back to text]
locale pubimbue(const locale& loc);
1 Postcondition: loc == getloc().
2 Effects: Calls imbue(loc).
3 Returns: Previous value of getloc().
locale getloc() const;
4 Returns: If pubimbue() has ever been called, then the last value of loc supplied, otherwise the current global locale, locale(), in effect at the time of construction. 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.
basic_streambuf<char_type,traits>* pubsetbuf(char_type* s, streamsize n);
1 Returns: setbuf(s,n).
pos_type pubseekoff(off_type off, ios_base::seekdir way,
ios_base::openmode which = ios_base::in | ios_base::out);
2 Returns: seekoff(off,way,which).
pos_type pubseekpos(pos_type sp,
ios_base::openmode which = ios_base::in | ios_base::out);
3 Returns: seekpos(sp,which).
int pubsync();
4 Returns: sync().
streamsize in_avail();
1 Returns: If a read position is available, returns egptr() - gptr(). Otherwise returns
showmanyc() (27.5.2.4.3). int_type snextc();
2 Effects: Calls sbumpc().
3 Returns: if that function returns traits::eof(), returns traits::eof(). Otherwise, returns
sgetc(). int_type sbumpc();
4 Returns: If the input sequence read position is not available, returns uflow(). Otherwise, returns
traits::to_int_type(*gptr()) and increments the next pointer for the input sequence. int_type sgetc();
5 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);
6 Returns: xsgetn(s,n).
int_type sputbackc(char_type c);
1 Returns: If the input sequence putback position is not available, or if traits::eq(c,gptr()[-1]) is false, returns pbackfail(traits::to_int_type(c)). Otherwise, decrements the next pointer for the input sequence and returns traits::to_int_type(*gptr()).
int_type sungetc();
2 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()).
int_type sputc(char_type c);
1 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);
2 Returns: xsputn(s,n).
char_type* eback() const;
1 Returns: The beginning pointer for the input sequence.
char_type* gptr() const;
2 Returns: The next pointer for the input sequence.
char_type* egptr() const;
3 Returns: The end pointer for the input sequence.
void gbump(int n);
4 Effects: Advances the next pointer for the input sequence by n.
void setg(char_type* gbeg, char_type* gnext, char_type* gend);
5 Postconditions: gbeg == eback(), gnext == gptr(), and gend == egptr().
char_type* pbase() const;
1 Returns: The beginning pointer for the output sequence.
char_type* pptr() const;
2 Returns: The next pointer for the output sequence.
char_type* epptr() const;
3 Returns: The end pointer for the output sequence.
void pbump(int n);
4 Effects: Advances the next pointer for the output sequence by n.
void setp(char_type* pbeg, char_type* pend);
5 Postconditions: pbeg == pbase(), pbeg == pptr(), and pend == epptr().
void imbue(const locale&)
1 Effects: Change any translations based on locale.
2 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.
3 Default behavior: Does nothing.
basic_streambuf* setbuf(char_type* s, streamsize n);
1 Effects: Performs an operation that is defined separately for each class derived from basic_streambuf in this clause (27.7.1.3, 27.8.1.4).
2 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);
3 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 (27.7.1.3, 27.8.1.4).
4 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);
5 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 (27.7.1, 27.8.1.1).
6 Default behavior: Returns an object of class pos_type that stores an invalid stream position.
int sync();
7 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.
8 Returns: -1 on failure. What constitutes failure is determined by each derived class (27.8.1.4).
9 Default behavior: Returns zero.
streamsize showmanyc();274)
1 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.275)
2 Default behavior: Returns zero.
3 Notes: Uses traits::eof().
streamsize xsgetn(char_type* s, streamsize n);
4 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().
5 Returns: The number of characters assigned.276)
6 Notes: Uses traits::eof().
int_type underflow();
7 Notes: The public members of basic_streambuf call this virtual function only if gptr() is null or gptr() >= egptr()
8 Returns: traits::to_int_type(c), where c is the first character of the pending sequence, without moving the input sequence position past it. If the pending sequence is null then the function returns traits::eof() to indicate failure.
9 The pending sequence of characters is defined as the concatenation of: a) If gptr() is non- NULL, then the egptr() - gptr() characters starting at gptr(), otherwise the empty sequence. b) Some sequence (possibly empty) of characters read from the input sequence.
10 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.
11 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().
12 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 b) If the pending sequence is empty, either gptr() is null or gptr() and egptr() are set to the same non-NULL pointer.
13 If eback() and gptr() are non-null then the function is not constrained as to their contents, but the ``usual backup condition'' is that either: a) If the backup sequence contains at least gptr() - eback() characters, then the gptr() -
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)eback() characters starting at eback() agree with the last gptr() - eback() characters of the
14 Default behavior: Returns traits::eof().
int_type uflow();
15 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.
16 Default behavior: Calls underflow(). If underflow() returns traits::eof(), returns
increment the value of the next pointer for the input sequence.traits::eof(). Otherwise, returns the value of traits::to_int_type(*gptr()) and
17 Returns: traits::eof() to indicate failure.
274) The morphemes of showmanyc are "es-how-many-see", not "show-manic". [back to text]275) 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.'' [back to text]
276) Classes derived from basic_streambuf can provide more efficient ways to implement xsgetn() and xsputn() by overriding these definitions from the base class. [back to text]
int_type pbackfail(int_type c = traits::eof());
1 Notes: The public functions of basic_streambuf call this virtual function only when gptr() is null,
false. Other calls shall also satisfy that constraint. The pending sequence is defined as for underflow(), with the modifications thatgptr() == eback(), or traits::eq(*gptr(),traits::to_char_type(c)) returns
2 Postcondition: On return, the constraints of gptr(), eback(), and pptr() are the same as for
underflow().
3 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.
Returns some value other than traits::eof() to indicate success.pbackfail() is called only when put back has really failed.
4 Default behavior: Returns traits::eof().
streamsize xsputn(const char_type* s, streamsize n);
1 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 designated by s. Writing stops when either n characters have been written or a call to sputc(c) would return traits::eof().
2 Returns: The number of characters written.
int_type overflow(int_type c = traits::eof());
3 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.
4 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.
5 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 specified277) 2) Let r be the number of characters in the pending sequence not consumed. If r is non-zero then
ing at pbase() are the associated output stream. In case r is zero (all characters 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.pbase() and pptr() must be set so that: pptr() - pbase() == r and the r characters start
6 Returns: traits::eof() or throws an exception if the function fails. Otherwise, returns some value other than traits::eof() to indicate success.278)
7 Default behavior: Returns traits::eof().
277) That is, for each class derived from an instance of basic_streambuf in this clause (27.7.1, 27.8.1.1), a specification of how consuming a character effects the associated output sequence is given. There is no requirement on a program-defined class. [back to text]278) 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). [back to text]
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 = char_traits<charT> >
class basic_iostream;
typedef basic_iostream<char> iostream;
typedef basic_iostream<wchar_t> wiostream;
template <class charT, class traits>
basic_istream<charT,traits>& ws(basic_istream<charT,traits>& is);
}
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);
}
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);
template<charT> T4 setfill(charT c);
T5 setprecision(int n);
T6 setw(int n);
}
1 The header <istream> defines two types and a function signature that control input from a stream buffer.
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_istream : virtual public basic_ios<charT,traits> {
public:
// Types (inherited from basic_ios (27.4.4)):
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;
// 27.6.1.1.1 Constructor/destructor:
explicit basic_istream(basic_streambuf<charT,traits>* sb);
virtual ~basic_istream();
// 27.6.1.1.2 Prefix/suffix:
class sentry;
// 27.6.1.2 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);
// 27.6.1.3 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);
basic_istream<charT,traits>& get(char_type* s, streamsize n,
char_type delim);
basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb);
basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb,
char_type delim);
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);
};
// 27.6.1.2.3 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<char,traits>&,
unsigned char*);
template<class traits>
basic_istream<char,traits>& operator>>(basic_istream<char,traits>&,
signed char*);
}
1 The class basic_istream defines a number of member function signatures that assist in reading and interpreting input from sequences controlled 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::failure (27.4.4.3), 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.
explicit basic_istream(basic_streambuf<charT,traits>* sb);
1 Effects: Constructs an object of class basic_istream, assigning initial values to the base class by calling basic_ios::init(sb) (27.4.4.1).
2 Postcondition: gcount() == 0
virtual ~basic_istream();
3 Effects: Destroys an object of class basic_istream.
4 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() const { return ok_; }
private:
sentry(const sentry&); // not defined
sentry& operator=(const sentry&); // not defined
};
}
1 The class sentry defines a class that is responsible for doing exception safe prefix and suffix operations.
explicit sentry(basic_istream<charT,traits>& is, bool noskipws = false);
2 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 associated external C stream. Except that this call can be suppressed if the put area of is.tie() is empty. Further an implementation is allowed to defer the call to flush until a call of is->rdbuf()-
may be eliminated entirely279) 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.>underflow occurs. If no such call occurs before the sentry object is destroyed, the call to flush
3 Notes: The constructor explicit sentry(basic_istream<charT,traits>& is, bool
character is whitespace or not.noskipws = false) uses the currently imbued locale in is , to determine whether the next input
4 To decide if the character c is a whitespace character, the constructor 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.
5 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 (27.4.4.3))280)
6 [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;
}
}
...
}
~sentry();
7 Effects: None.
operator bool() const;
8 Effects: Returns ok_.
279) This will be possible only in functions that are part of the library. The semantics of the constructor used in user code is as specified. [back to text]
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 on281) in *this's error state. If (exception()&badbit)!= 0 then the exception is rethrown. In any case, the formatted input function destroys the sentry object. If no exception has been thrown, it returns *this.
280) The sentry constructor and destructor can also perform additional implementation-dependent operations. [back to text]281) This is done without causing an ios::failure to be thrown. [back to text]
As in the case of the inserters, these extractors depend on the locale's num_get<> (22.2.2.1) object to perform parsing the input stream data. The conversion occurs as if performed by the following code fragment: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);
In the above fragment, loc stands for the private member of the 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. ---end note] Class locale relies on this type as its interface to istream, so that it does not need to depend directly on istream. 27.6.1.2.3 basic_istream::operator>> [lib.istream::extractors]typedef num_get< charT,istreambuf_iterator<charT,traits> > numget; iostate err = 0; use_facet< numget >(loc).get(*this, 0, *this, err, val); setstate(err);
basic_istream<charT,traits>& operator>>
(basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&))
1 Returns: pf(*this).282)
basic_istream<charT,traits>& operator>>
(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&));
2 Effects: Calls pf(*this).
3 Returns: *this.
basic_istream<charT,traits>& operator>>
(ios_base& (*pf)(ios_base&));
4 Effects: Calls pf(*this).283)
5 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);
6 Effects: Behaves like a formatted input member (as described in 27.6.1.2.1) 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.
7 Characters are extracted and stored until any of the following occurs:
8 If the function extracted no characters, it calls setstate(failbit), which may throw ios_base::failure (27.4.4.3).
9 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);
10 Effects: Behaves like a formatted input member (as described in 27.6.1.2.1) 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(failbit).
11 Returns: in.
basic_istream<charT,traits>& operator>>
(basic_streambuf<charT,traits>* sb);
12 Effects: If sb is null, calls setstate(failbit), which may throw ios_base::failure (27.4.4.3). 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:
13 If the function inserts no characters, it calls setstate(failbit), which may throw
ing characters from sb and failbit is on in exceptions() (27.4.4.3), then the caught exception is rethrown.ios_base::failure (27.4.4.3). If failure was due to catching an exception thrown while extract
14 Returns: *this.
282) See, for example, the function signature ws(basic_istream&) (27.6.1.4). [back to text]283) See, for example, the function signature dec(ios_base&) (27.4.5.3). [back to text]
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 on284) 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.
streamsize gcount() const;
2 Returns: The number of characters extracted by the last unformatted input member function called for the object. int_type get();
3 Effects: Extracts a character c, if one is available. Otherwise, the function calls setstate(failbit), which may throw ios_base::failure (27.4.4.3),
4 Returns: c if available, otherwise traits::eof(). basic_istream<charT,traits>& get(char_type& c);
5 Effects: Extracts a character, if one is available, and assigns it to c.285) Otherwise, the function calls setstate(failbit) (which may throw ios_base::failure (27.4.4.3)).
6 Returns: *this. basic_istream<charT,traits>& get(char_type* s, streamsize n,
char_type delim );
7 Effects: Extracts characters and stores them into successive locations of an array whose first element is designated by s.286) Characters are extracted and stored until any of the following occurs:
8 If the function stores no characters, it calls setstate(failbit) (which may throw ios_base::failure (27.4.4.3)). In any case, it then stores a null character into the next successive location of the array.
9 Returns: *this.
basic_istream<charT,traits>& get(char_type* s, streamsize n)
10 Effects: Calls get(s,n,widen('\n'))
11 Returns: Value returned by the call.
basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb,
char_type delim );
12 Effects: Extracts characters and inserts them in the output sequence controlled by sb. Characters are extracted and inserted until any of the following occurs:
13 If the function inserts no characters, it calls setstate(failbit), which may throw ios_base::failure (27.4.4.3).
14 Returns: *this.
basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb);
15 Effects: Calls get(s,n,widen('\n'))
16 Returns: Value returned by the call.
basic_istream<charT,traits>& getline(char_type* s, streamsize n,
char_type delim);
17 Effects: Extracts characters and stores them into successive locations of an array whose first element is designated by s.287) 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);288) 3) n - 1 characters are stored (in which case the function calls setstate(failbit)).
18 These conditions are tested in the order shown.289)
19 If the function extracts no characters, it calls setstate(failbit) (which may throw ios_base::failure (27.4.4.3)).290)
20 In any case, it then stores a null character (using charT()) into the next successive location of the array.
21 Returns: *this.
22 [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 newline in count
cout << "Line " << ++line_number;
}
cout << " (" << count << " chars): " << buffer << endl;
}
}
basic_istream<charT,traits>& getline(char_type* s, streamsize n);
23 Returns: getline(s,n,widen('\n'))
basic_istream<charT,traits>&
ignore(int n = 1, int_type delim = traits::eof());
24 Effects: Extracts characters and discards them. Characters are extracted until any of the following occurs:
25 Notes: The last condition will never occur if delim == traits::eof().
26 Returns: *this.
int_type peek();
27 Returns: traits::eof() if good() is false. Otherwise, returns rdbuf()->sgetc().
basic_istream<charT,traits>& read(char_type* s, streamsize n);
28 Effects: If !good() calls setstate(failbit) which may throw an exception, and return. Otherwise extracts characters and stores them into successive locations of an array whose first element is designated by s.291) Characters are extracted and stored until either of the following occurs:
29 Returns: *this.
streamsize readsome(char_type* s, streamsize n);
30 Effects: If !good() calls setstate(failbit) which may throw an exception, and return. Otherwise extracts characters and stores them into successive 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 (27.4.4.3)), and extracts no characters;
31 Returns: The number of characters extracted.
basic_istream<charT,traits>& putback(char_type c);
32 Effects: If !good() calls setstate(failbit) which may throw an exception, and return. If
returns traits::eof(), calls setstate(badbit) (which may throw ios_base::failure (27.4.4.3)).rdbuf() is not null, calls rdbuf->sputbackc(). If rdbuf() is null, or if sputback()
33 Returns: *this.
basic_istream<charT,traits>& unget();
34 Effects: If !good() calls setstate(failbit) which may throw an exception, and return. If
(27.4.4.3)).rdbuf() is not null, calls rdbuf()->sungetc(). If rdbuf() is null, or if sungetc() returns traits::eof(), calls setstate(badbit) (which may throw ios_base::failure
35 Returns: *this. int sync();
36 Effects: If rdbuf() is a null pointer, returns -1 . Otherwise, calls rdbuf()->pubsync() and, if that function returns -1 calls setstate(badbit) (which may throw ios_base::failure (27.4.4.3), and returns traits::eof(). Otherwise, returns zero. pos_type tellg();
37 Returns: if fail() != false, returns pos_type(-1) to indicate failure. Otherwise, returns rdbuf()->pubseekoff(0, cur, in). basic_istream<charT,traits>& seekg(pos_type pos);
38 Effects: If fail() != true, executes rdbuf()->pubseekpos(pos).
39 Returns: *this. basic_istream<charT,traits>& seekg(off_type& off, ios_base::seekdir dir);
40 Effects: If fail() != true, executes rdbuf()->pubseekoff(off, dir).
41 Returns: *this.
284) This is done without causing an ios::failure to be thrown. [back to text]285) Note that this function is not overloaded on types signed charand unsigned char. [back to text]
286) Note that this function is not overloaded on types signed char and unsigned char. [back to text]
287) Note that this function is not overloaded on types signed char and unsigned char. [back to text]
288) Since the final input character is ``extracted,'' it is counted in the gcount(), even though it is not stored. [back to text]
289) This allows an input line which exactly fills the buffer, without setting failbit. This is different behavior than the historical AT&T implementation. [back to text]
290) This implies an empty input line will not cause failbit to be set. [back to text]
291) Note that this function is not overloaded on types signed char and unsigned char. [back to text]
namespace std {
template <class charT, class traits>
basic_istream<charT,traits>& ws(basic_istream<charT,traits>& is);
}
1 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 (27.6.1.1.2). If ws stops extracting characters because there are no more available it sets eofbit, but not failbit.
2 Returns: is.
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.
explicit basic_iostream(basic_streambuf<charT,traits>* sb);
1 Effects Constructs an object of class basic_iostream, assigning initial values to the base classes by calling basic_istream<charT,traits>(sb) (27.6.1.1) and basic_ostream<charT,traits>(sb) (27.6.2.1)
2 Postcondition: rdbuf()==sb and gcount()==0.
virtual ~basic_iostream();
1 Effects: Destroys an object of class basic_iostream.
2 Notes: Does not perform any operations on rdbuf().
1 The header <ostream> defines a type and several function signatures that control output to a stream buffer.
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_ostream : virtual public basic_ios<charT,traits> {
public:
// Types (inherited from basic_ios (27.4.4)):
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;
// 27.6.2.2 Constructor/destructor:
explicit basic_ostream(basic_streambuf<char_type,traits>* sb);
virtual ~basic_ostream();
// 27.6.2.3 Prefix/suffix:
class sentry;
// 27.6.2.5 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<<(const void* p);
basic_ostream<charT,traits>& operator<<
(basic_streambuf<char_type,traits>* sb);
// 27.6.2.6 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();
// 27.6.2.4 seeks:
pos_type tellp();
basic_ostream<charT,traits>& seekp(pos_type);
basic_ostream<charT,traits>& seekp(off_type, ios_base::seekdir);
};
// 27.6.2.5.4 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 controlled 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) output 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.
explicit basic_ostream(basic_streambuf<charT,traits>* sb);
1 Effects: Constructs an object of class basic_ostream, assigning initial values to the base class by calling basic_ios<charT,traits>::init(sb) (27.4.4.1).
2 Postcondition: rdbuf() == sb.
virtual ~basic_ostream();
3 Effects: Destroys an object of class basic_ostream.
4 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() const { return ok_; }
private
sentry(const sentry&); // not defined
sentry& operator=(const sentry&); // not defined
};
}
1 The class sentry defines a class that is responsible for doing exception 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().292)
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 (27.4.4.3))293)
~sentry();
4 If ((os.flags() & ios_base::unitbuf) && !uncaught_exception()) is true, calls os.flush().
operator bool();
5 Effects: Returns ok_.
292) The call os.tie()->flush() does not necessarily occur if the function can determine that no synchronization is necessary. [back to text]293) The sentry constructor and destructor can also perform additional implementation-dependent operations. [back to text]
pos_type tellp();
1 Returns: if fail() != false, returns pos_type(-1) to indicate failure. Otherwise, returns
rdbuf()->pubseekoff(0, cur, out). basic_ostream<charT,traits>& seekp(pos_type& pos);
2 Effects: If fail() != true, executes rdbuf()->pubseekpos(pos).
3 Returns: *this.
basic_ostream<charT,traits>& seekp(off_type& off, ios_base::seekdir dir);
4 Effects: If fail() != true, executes rdbuf()->pubseekoff(off, dir).
5 Returns: *this.
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::failbit), which might throw an exception. If an exception is thrown during output, then ios::badbit is turned on294) 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 exception is thrown, the result of the formattted output function is *this.
2 The descriptions of the individual formatted output operations describe how they perform output and do not mention the sentry object.
294) without causing an ios::failure to be thrown. [back to text]
operator<<(bool val); 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<<(const void* val);
1 Effects: The classes num_get<> and num_put<> handle locale-dependent numeric formatting and parsing. These inserter functions use the imbued locale value to perform numeric formatting. 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();
2 Returns: *this.
(basic_ostream<charT,traits>& (*pf)(basic_ostream<charT,traits>&))
1 Returns: pf(*this).295) basic_ostream<charT,traits>& operator<<
(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&))
2 Effects: Calls pf(*this).
3 Returns: *this.296) basic_ostream<charT,traits>& operator<<
(ios_base& (*pf)(ios_base&))
4 Effects: Calls pf(*this).
5 Returns: *this. basic_ostream<charT,traits>& operator<<
(basic_streambuf<charT,traits>* sb);
6 Effects: If sb is null calls setstate(badbit) (which may throw ios_base::failure).
7 Gets characters from sb and inserts them in *this. Characters are read from sb and inserted until any of the following occurs:
8 If the function inserts no characters, it calls setstate(failbit) (which may throw ios_base::failure (27.4.4.3)). 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.
9 Returns: *this.
295) See, for example, the function signature endl(basic_ostream&) (27.6.2.7) . [back to text]296) See, for example, the function signature dec(ios_base&) (27.4.5.3). [back to text]
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);
1 Effects: Behaves like an formatted inserter (as described in 27.6.2.5.1) of out. After a sentry object is constructed it inserts characters. In case c has type char and the character type of the stream is not
determined as described in 22.2.2.2.2. width(0) is called. The insertion character and any required padding are inserted into out.char, then the character to be inserted is out.widen(c); otherwise the character is c297) Padding is
2 Returns: out
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);
3 Requires: s is non-null.
4 Effects: Behaves like an formatted inserter (as described in 27.6.2.5.1) of out. After a sentry object is constructed it inserts characters. The number of characters starting at s to be inserted is
widened characters and any required padding are inserted into out. Calls width(0).traits::length(s). Padding is determined as described in 22.2.2.2.2. The traits::length(s) characters starting at s are widened using out.widen (27.4.4.2). The
5 Returns: out
297) In case the insertion is into a char stream, widen(c) will usually be c. [back to text]
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 unformatted 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);
2 Effects: Inserts the character c, if possible.298)
3 Otherwise, calls setstate(badbit) (which may throw ios_base::failure (27.4.4.3)).
4 Returns: *this.
basic_ostream& write(const char_type* s, streamsize n);
5 Effects: Obtains characters to insert from successive locations of an array whose first element is designated by s.299) Characters are inserted until either of the following occurs:
6 Returns: *this.
basic_ostream& flush();
7 If rdbuf() is not a null pointer, calls rdbuf()->pubsync(). If that function returns -1 calls setstate(badbit) (which may throw ios_base::failure (27.4.4.3)).
8 Returns: *this.
298) Note that this function is not overloaded on types signed char and unsigned char. [back to text]299) Note that this function is not overloaded on types signed char and unsigned char. [back to text]
namespace std {
template <class charT, class traits>
basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);
}
1 Effects: Calls os.put(os.widen('\n') ), then os.flush().
2 Returns: os.300)
namespace std {
template <class charT, class traits>
basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);
}
3 Effects: Inserts a null character into the output sequence: calls os.put(charT()).
4 Returns: os.
namespace std {
template <class charT, class traits>
basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);
}
5 Effects: Calls os.flush().
6 Returns: os.
300) The effect of executing cout << endl is to insert a newline character in the output sequence controlled by cout, then synchronize it with any external file with which it might be associated. [back to text]
1 The header <iomanip> defines a type and several related functions that use this type to provide extractors and inserters that alter information maintained by class ios_base and its derived classes.
2 The type designated smanip in each of the following function descriptions is implementation-specified and may be different for each function. smanip resetiosflags(ios_base::fmtflags mask);
3 Returns: An object s of unspecified type such that if out is an (instance of) basic_ostream then the expression out<<s behaves as if f(s) were called, and if in is an (instance of) basic_istream then the expression in>>s behaves as if f(s) were called. Where f can be defined as:301)
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);istream& and value in.
4 Returns: An object s of unspecified type such that if out is an (instance of) basic_ostream then the expression out<<s behaves as if f(s) were called, in is an (instance of) basic_istream then the expression in>>s behaves as if f(s) were called. 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);istream& and value in.
5 Returns: An object s of unspecified type such that if out is an (instance of) basic_ostream then the expression out<<s behaves as if f(s) were called, in is an (instance of) basic_istream then the expression in>>s behaves as if f(s) were called. 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(char_type c);istream& and value in.
6 Returns: An object s of unspecified 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 f can be defined as:
template<class charT, class traits>
basic_ios<charT,traits>& f(basic_ios<charT,traits>& str, charT c)
{
// set fill character
str.fill(c);
return str;
}
7 Returns: An object s of unspecified type such that if out is an (instance of) basic_ostream then the expression out<<s behaves as if f(s) were called, in is an (instance of) basic_istream then the expression in>>s behaves as if f(s) were called. Where f can be defined as:
ios_base& f(ios_base& str, int n)
{
// set precision
str.precision(n);
return str;
}
8 Returns: An object s of unspecified type such that if out is an (instance of) basic_ostream then the expression out<<s behaves as if f(s) were called, in is an (instance of) basic_istream then the expression in>>s behaves as if f(s) were called. Where f can be defined as:
ios_base& f(ios_base& str, int n)
{
// set width
str.width(n);
return str;
}
301) 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 << resetiosflags(ios_base::showbase) clears ios_base::showbase in the format flags stored in the ostream object cout (the same as cout << noshowbase). [back to text]
1 The header <sstream> defines four template classes, and six types, that associate stream buffers with objects of class basic_string, as described in 21.2. 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 basic_stringstream<char> stringstream;
typedef basic_stringstream<wchar_t> wstringstream;
}
namespace std {
template <class charT, class traits = char_traits<charT>,
class Allocator = allocator<charT> >
class basic_stringbuf : public basic_streambuf<charT,traits> {
public:
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;
// 27.7.1.1 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);
// 27.7.1.2 Get and set:
basic_string<charT,traits,Allocator> str() const;
void str(const basic_string<charT,traits,Allocator>& s);
protected:
// 27.7.1.3 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:
explicit basic_stringbuf(ios_base::openmode which =
ios_base::in | ios_base::out);
1 Effects: Constructs an object of class basic_stringbuf, initializing the base class with
basic_streambuf() (27.5.2.1), and initializing mode with which.
2 Notes: The function allocates no array object.
explicit basic_stringbuf(const basic_string<charT,traits,Allocator>& str,
ios_base::openmode which = ios_base::in | ios_base::out);
3 Effects: Constructs an object of class basic_stringbuf, initializing the base class with
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.basic_streambuf() (27.5.2.1), and initializing mode with which. Then copies the content of str
4 Postconditions: str() == str.
basic_string<charT,traits,Allocator> str() const;
1 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<charT,traits,Allocator>& s);
2 Effects: If the basic_stringbuf's underlying character sequence is not empty, deallocates it. Then copies the content of s into the basic_stringbuf underlying character sequence and initializes the input and output sequences according to the mode stored when creating the basic_stringbuf object. If (mode&ios_base::out) is true, then initializes the output sequence with the underlying sequence. If (mode&ios_base::in) is true, then initializes the input sequence with the underlying sequence.
3 Postcondition: str() == s.
1 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());
2 Effects: Puts back the character designated by c to the input sequence, if possible, in one of three ways:
3 Returns: traits::eof() to indicate failure.
4 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());
5 Effects: Appends the character designated by c to the output sequence, if possible, in one of two ways:
6 Notes: The function can alter the number of write positions available as a result of any call.
7 Returns: traits::eof() to indicate failure.
8 9 Notes: The function can make a write position available only if (mode & ios_base::out) != 0. To make a write position available, the function reallocates (or initially allocates) an array object with a sufficient 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()).
pos_type seekoff(off_type off, ios_base::seekdir way,
ios_base::openmode which
= ios_base::in | ios_base::out);
10 Effects: Alters the stream position within one of the controlled sequences, if possible, as indicated in Table 90:
| Table 90---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 | positions both the input and the output sequences basic_ios::out)) == (basic_ios::in | basic_ios::out)) and way == either basic_ios::beg or _ basic_ios::end _______________________________________________________________________________ _ Otherwise the positioning operation fails. _______________________________________________________________________________ |
11 For a sequence to be positioned, if its next pointer (either gptr() or pptr()) is a null pointer, the positioning operation fails. Otherwise, the function determines newoff as indicated in Table 91:
| Table 91---newoff values |
_ ________________________________________________________ _ Condition newoff Value _ ________________________________________________________ ________________________________________________________ _ way == basic_ios::beg 0 ________________________________________________________ way == basic_ios::cur the next pointer minus the begin_ ning pointer (xnext - xbeg). ________________________________________________________ way == basic_ios::end the end pointer minus the begin_ ning pointer (xend - xbeg) ________________________________________________________ |
12 _ If (newoff + off) < 0, or (xend - xbeg) < (newoff + off), the positioning operation fails. Otherwise, the function assigns xbeg + newoff + off to the next pointer xnext.
13 Returns: pos_type(newoff), constructed from the resultant offset newoff (of type off_type), that stores the resultant stream position, if possible. 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);
14 Effects: Alters the stream position within the controlled sequences, if possible, to correspond to the stream position stored in sp (as described below).
15 Returns: sp to indicate success, or pos_type(off_type(-1)) to indicate failure.
basic_streambuf<charT,traits>* setbuf(charT* s, streamsize n);
16 Effects: implementation-defined, except that setbuf(0,0) has no effect.
17 Returns: this.
namespace std {
template <class charT, class traits = char_traits<charT>,
class Allocator = allocator<charT> >
class basic_istringstream : public basic_istream<charT,traits> {
public:
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;
// 27.7.2.1 Constructors:
explicit basic_istringstream(ios_base::openmode which = ios_base::in);
explicit basic_istringstream(
const basic_string<charT,traits,Allocator>& str,
ios_base::openmode which = ios_base::in);
// 27.7.2.2 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_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 associated storage. For the sake of exposition, the maintained data is presented here as:
explicit basic_istringstream(ios_base::openmode which = ios_base::in);
1 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>(which|ios_base::in)) (27.7.1.1). explicit basic_istringstream( const basic_string<charT,traits,allocator>& str, ios_base::openmode which = ios_base::in);
2 Effects: Constructs an object of class basic_istringstream<charT,traits>, initializing the base class with basic_istream(&sb) and initializing sb with
(27.7.1.1).basic_stringbuf<charT,traits,Allocator>(str, which | ios_base::in))
basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
1 Returns: (basic_stringbuf<charT,traits,Allocator>*)&sb.
basic_string<charT,traits,Allocator> str() const;
2 Returns: rdbuf()->str().302)
void str(const basic_string<charT,traits,Allocator>& s);
3 Effects: Calls rdbuf()->str(s).
302) rdbuf() is never NULL because it always returns the private object. [back to text]
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;
// 27.7.3.1 Constructors/destructor:
explicit basic_ostringstream(ios_base::openmode which = ios_base::out);
explicit basic_ostringstream(
const basic_string<charT,traits,Allocator>& str,
ios_base::openmode which = ios_base::out);
// 27.7.3.2 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:
explicit basic_ostringstream(ios_base::openmode which = ios_base::out);
1 Effects: Constructs an object of class basic_ostringstream, initializing the base class with
(27.7.1.1).basic_ostream(&sb) and initializing sb with basic_stringbuf<charT,traits,Allocator>(which | ios_base::out))
explicit basic_ostringstream(
const basic_string<charT,traits,Allocator>& str,
ios_base::openmode which = ios_base::out);
2 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,Allocator>(str, which | ios_base::out)) (27.7.1.1).
basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
1 Returns: (basic_stringbuf<charT,traits,Allocator>*)&sb.
basic_string<charT,traits,Allocator> str() const;
2 Returns: rdbuf()->str().303)
void str(const basic_string<charT,traits,Allocator>& s);
3 Effects: Calls rdbuf()->str(s).
303) rdbuf() is never NULL because it always returns the private object. [back to text]
namespace std {
template <class charT, class traits = char_traits<charT>,
class Allocator = allocator<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,traits,Allocator>& str,
ios_base::openmode which = ios_base::out|ios_base::in);
// Members:
basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
basic_string<charT,traits,Allocator> str() const;
void str(const basic_string<charT,traits,Allocator>& 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,Allocator>. It uses a basic_stringbuf<charT,traits,Allocator> object to control the associated sequence. For the sake of exposition, the maintained data is presented here as
explicit basic_stringstream(
ios_base::openmode which = ios_base::out|iosbase::in);
1 Effects: Constructs an object of class basic_stringstream<charT,traits>, initializing the base class with basic_iostream(&sb) and initializing sb with
basic_stringbuf<charT,traits,Allocator>(which).
explicit basic_stringstream(
const basic_string<charT,traits,Allocator>& str,
ios_base::openmode which = ios_base::out|iosbase::in);
2 Effects: Constructs an object of class basic_stringstream<charT,traits>, initializing the base class with basic_iostream(&sb) and initializing sb with
basic_stringbuf<charT,traits,Allocator>(str,which).
basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
1 Returns: &sb
basic_string<charT,traits,Allocator> str() const;
2 Returns: rdbuf()->str().304)
void str(const basic_string<charT,traits,Allocator>& str);
3 Effects: Calls rdbuf()->str(str).
304) rdbuf() is never NULL because it always returns the private object. [back to text]
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
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;
template <class charT, class traits = char_traits<charT> >
class basic_fstream;
typedef basic_fstream<char> fstream;
typedef basic_fstream<wchar_t> wfstream;
}
2 In this subclause, the type name FILE refers to the type FILE defined in <cstdio> (27.8.2).305)
305) In C FILE must be a typedef. In C++ it may be a typedef or other type name. [back to text]306) A File is a sequence of multibyte characters. In order to provide the contents as a wide character sequence, filebuf should convert between wide character sequences and multibyte character sequences. [back to text]
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_filebuf : public basic_streambuf<charT,traits> {
public:
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;
// 27.8.1.2 Constructors/destructor:
basic_filebuf();
virtual ~basic_filebuf();
// 27.8.1.3 Members:
bool is_open() const;
basic_filebuf<charT,traits>* open
(const char* s, ios_base::openmode mode);
basic_filebuf<charT,traits>* close();
protected:
// 27.8.1.4 Overridden virtual functions:
virtual streamsize 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 reading and writing with the Standard C library FILEs.
3 In particular:
4 An instance of basic_filebuf behaves as described in 27.8.1.1 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());
basic_filebuf();
1 Effects: Constructs an object of class basic_filebuf<charT,traits>, initializing the base class with basic_streambuf<charT,traits>() (27.5.2.1).
2 Postcondition: is_open() == false.
virtual ~basic_filebuf();
3 Effects: Destroys an object of class basic_filebuf<charT,traits>. Calls close().
bool is_open() const;
1 Returns: true if a previous call to open succeeded (returned a non-null value) and there has been no intervening call to close.
basic_filebuf<charT,traits>* open(
const char* s,
ios_base::openmode mode );
2 Effects: If is_open() != false, returns a null pointer. Otherwise, initializes the filebuf as required. It then opens a file, if possible, whose name is the NTBS s (``as if'' by calling std::fopen(s,modstr)). The NTBS modstr is determined from mode & ~ios_base::ate as indicated in Table 92:
| Table 92---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"
________________________________________________
|
3 If the open operation succeeds and (mode & ios_base::ate) != 0, positions the file to the end (``as if'' by calling std::fseek(file,0,SEEK_END)).307)
4 If the repositioning operation fails, calls close() and returns a null pointer to indicate failure.
5 Returns: this if successful, a null pointer otherwise.
basic_filebuf<charT,traits>* close();
6 Effects: If is_open() == false, returns a null pointer. If a put area exists, calls overflow(EOF) to flush characters. If the last virtual member function called on *this (between underflow, overflow, seekoff, and seekpos) was overflow then calls a_codecvt.unshift (possibly several times) to determine a termination sequence, inserts those characters and calls overflow(EOF) again. Finally it closes the file (``as if'' by calling std::fclose(file)).308) If any of the calls to overflow or std::fclose fails then close fails.
7 Returns: this on success, a null pointer otherwise.
8 Postcondition: is_open() == false.
307) 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> (27.8.2). [back to text]308) The function signature fclose(FILE*) is declared in <cstdio> (27.8.2). [back to text]
streamsize showmanyc();
1 Effects: Behaves the same as basic_streambuf::showmanyc() (27.5.2.4).
2 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();
3 Effects: Behaves according to the description of basic_streambuf<charT,traits>::
``as if'' by reading from the associated file into an internal buffer ( extern_buf) and then ``as if'' doingunderflow(), with the specialization that a sequence of characters is read from the input sequence
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);
a_codecvt.in() ran out of space in intern_buf, retry with a larger intern_buf. int_type uflow();
4 Effects: Behaves according to the description of basic_streambuf<charT,traits>::
method as used by underflow.uflow(), with the specialization that a sequence of characters is read from the input with the same
int_type pbackfail(int_type c = traits::eof());
5 Effects: Puts back the character designated by c to the input sequence, if possible, in one of three ways:
6 Returns: traits::eof() to indicate failure.
7 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());
8 Effects: Behaves according to the description of basic_streambuf<charT,traits>::overflow(c), except that the behavior of ``consuming 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);
9 Returns: traits::not_eof(c) to indicate success, and traits::eof() to indicate failure. If
is_open() == false, the function always fails. basic_streambuf* setbuf(char_type* s, int n);
10 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.
pos_type seekoff(off_type off, ios_base::seekdir way,
ios_base::openmode
= ios_base::in | ios_base::out);
11 Effects: Let width denote a_codecvt.encoding(). If is_open() == false, or off != 0
sequence. Next, seek to the new position: if width > 0, call std::fseek(file, width *&& width <= 0, then the positioning operation fails. Otherwise, if way != basic_ios::cur or off != 0, and if the last operation was output, then update the output sequence and write any unshift
off, whence), otherwise call std::fseek(file, 0, whence).
12 Notes: ``The last operation was output'' means either the last virtual operation was overflow or the put buffer is non-empty. ``Write any unshift sequence'' means, if width if less than zero then call
unshift sequence. The function determines one of three values for the argument whence, of type int, as indicated in Table 93:a_codecvt.unshift(st, xbuf, xbuf+XSIZE, xbuf_end) and output the resulting
| Table 93---seekoff effects |
_ _____________________________________ _ way Value stdio Equivalent _ _____________________________________ _____________________________________ basic_ios::beg SEEK_SET basic_ios::cur SEEK_CUR _ basic_ios::end SEEK_END _____________________________________ |
13 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 (27.4.3).
pos_type seekpos(pos_type sp, ios_base::openmode
= ios_base::in | ios_base::out);
14 If sp is an invalid stream position, or 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 positioning functions (seekoff or seekpos) on the same file the effects are undefined.
15 Returns: sp on success. Otherwise returns an invalid stream position (_lib.iostreams.definitions_).
int sync();
16 Effects: If a put area exists, calls filebuf::overflow to write the characters to the file. If a get area exists, the effect is implementation-defined.
void imbue(const locale& loc);
17 Precondition: If the file is not positioned at its beginning and the encoding of the current locale as determined by a_codecvt.encoding() is state-dependent (22.2.1.5.2) then that facet is the same as the corresponding facet of loc.
18 Effects: Causes characters inserted or extracted after this call to be converted according to loc until another call of imbue.
19 Note: This may require reconversion of previously converted characters. This in turn may require the implementation to be able to reconstruct the original contents of the file.
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_ifstream : public basic_istream<charT,traits> {
public:
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;
// 27.8.1.6 Constructors:
basic_ifstream();
explicit basic_ifstream(const char* s,
ios_base::openmode mode = ios_base::in);
// 27.8.1.7 Members:
basic_filebuf<charT,traits>* rdbuf() const;
bool is_open();
void open(const char* s, ios_base::openmode mode = ios_base::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:
basic_ifstream();
1 Effects: Constructs an object of class basic_ifstream<charT,traits>, initializing the base class with basic_istream(&sb) and initializing sb with basic_filebuf<charT,traits>()) (27.6.1.1.1, 27.8.1.2).
explicit basic_ifstream
(const char* s, ios_base::openmode mode = ios_base::in);
2 Effects: Constructs an object of class basic_ifstream, initializing the base class with
(27.6.1.1.1, 27.8.1.2), then calls rdbuf()->open(s,mode|in).309) If that function returns a null pointer, calls setstate(failbit), (which may throw ios_base::failure).basic_istream(&sb) and initializing sb with basic_filebuf<charT,traits>())
309) rdbuf() is never NULL because it always returns the private object. [back to text]
basic_filebuf<charT,traits>* rdbuf() const;
1 Returns: (basic_filebuf<charT,traits>*)&sb.
bool is_open();
2 Returns: rdbuf()->is_open().310)
void open(const char* s, ios_base::openmode mode = ios_base::in);
3 Effects: Calls rdbuf()->open(s,mode|in). If that function returns a null pointer, calls
setstate(failbit) (which may throw ios_base::failure (27.4.4.3)). void close();
4 Effects: Calls rdbuf()->close() and, if that function returns false, calls setstate(failbit) (which may throw ios_base::failure (27.4.4.3)).
310) rdbuf() is never NULL because it always returns the private object. [back to text]
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_ofstream : public basic_ostream<charT,traits> {
public:
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;
// 27.8.1.9 Constructors:
basic_ofstream();
explicit basic_ofstream(const char* s,
ios_base::openmode mode
= ios_base::out);
// 27.8.1.10 Members:
basic_filebuf<charT,traits>* rdbuf() const;
bool is_open();
void open(const char* s, ios_base::openmode mode = ios_base::out);
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:
basic_ofstream();
1 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>()) (27.6.2.2, 27.8.1.2).
explicit basic_ofstream
(const char* s, ios_base::openmode mode = ios_base::out);
2 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>()) (27.6.2.2, 27.8.1.2), then calls rdbuf()->open(s, mode|out).311) If that function returns a null pointer, calls setstate(failbit), (which may throw ios_base::failure).
311) rdbuf() is never NULL because it always returns the private filebuf object. [back to text]
basic_filebuf<charT,traits>* rdbuf() const;
1 Returns: (basic_filebuf<charT,traits>*)&sb.
bool is_open();
2 Returns: rdbuf()->is_open().
void open(const char* s, ios_base::openmode mode = ios_base::out);
3 Effects: Calls rdbuf()->open(s,mode|out). If that function returns a null pointer, calls
setstate(failbit) (which may throw ios_base::failure (27.4.4.3)). void close();
4 Effects: Calls rdbuf()->close() and, if that function fails (returns a null pointer), calls
setstate(failbit) (which may throw ios_base::failure (27.4.4.3)).
namespace std {
template <class charT, class traits=char_traits<charT> >
class basic_fstream
: public basic_iostream<charT,traits> {
public:
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;
// 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 to control the associated sequences. For the sake of exposition, the maintained data is presented here as:
basic_fstream();
1 Effects: Constructs an object of class basic_fstream<charT,traits>, initializing 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);
2 Effects: Constructs an object of class basic_fstream<charT,traits>, initializing 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 setstate(failbit) (which may throw ios_base::failure).
basic_filebuf<charT,traits>* rdbuf() const;
1 Returns: &sb
bool is_open();
2 Returns: rdbuf()->is_open().
void open(const char* s, ios_base::openmode mode);
3 Effects: Calls rdbuf()->open(s,mode), If that function returns a null pointer, calls setstate(failbit), (which may throw ios_base::failure). (27.4.4.3) )
void close();
4 Effects: Calls rdbuf()->close() and, if that function returns false, calls setstate(failbit)(27.4.4.3) (which may throw ios_base::failure).
1 Table 94 describes header <cstdio>.
| Table 94---Header <cstdio> synopsis |
_ _____________________________________________________________________________________ _ Type Name(s) _____________________________________________________________________________________ Macros: BUFSIZ FOPEN_MAX SEEK_CUR TMP_MAX _IONBF stdout EOF L_tmpnam SEEK_END _IOFBF stderr _ FILENAME_MAX NULL <cstdio> SEEK_SET _IOLBF stdin _____________________________________________________________________________________ _ Types: FILE fpos_t size_t <cstdio> _____________________________________________________________________________________ Functions: clearerr fgets fscanf gets rename tmpfile fclose fopen fseek perror rewind tmpnam feof fprintf fsetpos printf scanf ungetc ferror fputc ftell putc setbuf vfprintf fflush fputs fwrite putchar setvbuf vprintf fgetc fread getc puts sprintf vsprintf _ fgetpos freopen getchar remove sscanf _____________________________________________________________________________________ SEE ALSO: ISO C subclause 7.9, Amendment 1 subclause 4.6.2. |