1972 lines
68 KiB
Plaintext
1972 lines
68 KiB
Plaintext
\input texinfo @c -*-Texinfo-*-
|
|
@c Copyright (c) 1993 Free Software Foundation, Inc.
|
|
|
|
@c %**start of header
|
|
@setfilename iostream.info
|
|
@settitle The GNU C++ Iostream Library
|
|
@setchapternewpage odd
|
|
@c %**end of header
|
|
|
|
@ifinfo
|
|
@format
|
|
START-INFO-DIR-ENTRY
|
|
* iostream: (iostream). The C++ input/output facility.
|
|
END-INFO-DIR-ENTRY
|
|
@end format
|
|
|
|
This file describes libio, the GNU library for C++ iostreams and C stdio.
|
|
|
|
libio includes software developed by the University of California,
|
|
Berkeley.
|
|
|
|
Copyright (C) 1993 Free Software Foundation, Inc.
|
|
|
|
Permission is granted to make and distribute verbatim copies of
|
|
this manual provided the copyright notice and this permission notice
|
|
are preserved on all copies.
|
|
|
|
@ignore
|
|
Permission is granted to process this file through TeX and print the
|
|
results, provided the printed document carries copying permission
|
|
notice identical to this one except for the removal of this paragraph
|
|
(this paragraph not being relevant to the printed manual).
|
|
|
|
@end ignore
|
|
Permission is granted to copy and distribute modified versions of this
|
|
manual under the conditions for verbatim copying, provided also that the
|
|
entire resulting derived work is distributed under the terms of a
|
|
permission notice identical to this one.
|
|
|
|
Permission is granted to copy and distribute translations of this manual
|
|
into another language, under the above conditions for modified versions.
|
|
@end ifinfo
|
|
|
|
@finalout
|
|
@syncodeindex fn cp
|
|
@syncodeindex vr cp
|
|
|
|
@titlepage
|
|
@title The GNU C++ Iostream Library
|
|
@subtitle Reference Manual for @code{libio} Version 0.64
|
|
@sp 3
|
|
@author Per Bothner @hfill @code{bothner@@cygnus.com}
|
|
@author Cygnus Support @hfill @code{doc@@cygnus.com}
|
|
@page
|
|
|
|
@vskip 0pt plus 1filll
|
|
Copyright @copyright{} 1993 Free Software Foundation, Inc.
|
|
|
|
@code{libio} includes software developed by the University of
|
|
California, Berkeley.
|
|
|
|
@code{libio} uses floating-point software written by David M. Gay, which
|
|
includes the following notice:
|
|
|
|
@quotation
|
|
The author of this software is David M. Gay.
|
|
|
|
Copyright (c) 1991 by AT&T.
|
|
|
|
Permission to use, copy, modify, and distribute this software for any
|
|
purpose without fee is hereby granted, provided that this entire notice
|
|
is included in all copies of any software which is or includes a copy
|
|
or modification of this software and in all copies of the supporting
|
|
documentation for such software.
|
|
|
|
THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
|
|
WARRANTY. IN PARTICULAR, NEITHER THE AUTHOR NOR AT&T MAKES ANY
|
|
REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
|
|
OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
|
|
@end quotation
|
|
|
|
Permission is granted to make and distribute verbatim copies of
|
|
this manual provided the copyright notice and this permission notice
|
|
are preserved on all copies.
|
|
|
|
Permission is granted to copy and distribute modified versions of this
|
|
manual under the conditions for verbatim copying, provided also that the
|
|
entire resulting derived work is distributed under the terms of a
|
|
permission notice identical to this one.
|
|
|
|
Permission is granted to copy and distribute translations of this manual
|
|
into another language, under the above conditions for modified versions.
|
|
@end titlepage
|
|
|
|
@ifinfo
|
|
@node Top
|
|
@top The GNU C++ Iostream Library
|
|
|
|
This file provides reference information on the GNU C++ iostream library
|
|
(@code{libio}), version 0.64.
|
|
|
|
@menu
|
|
* Introduction::
|
|
* Operators:: Operators and default streams.
|
|
* Streams:: Stream classes.
|
|
* Files and Strings:: Classes for files and strings.
|
|
* Streambuf:: Using the streambuf layer.
|
|
* Stdio:: C input and output.
|
|
* Index::
|
|
@end menu
|
|
@end ifinfo
|
|
|
|
@node Introduction
|
|
@chapter Introduction
|
|
|
|
The iostream classes implement most of the features of AT&T version 2.0
|
|
iostream library classes, and most of the features of the ANSI X3J16
|
|
library draft (which is based on the AT&T design).
|
|
|
|
This manual is meant as a reference; for tutorial material on iostreams,
|
|
see the corresponding section of any recent popular introduction to C++.
|
|
|
|
@menu
|
|
* Copying:: Special GNU licensing terms for libio.
|
|
* Acknowledgements:: Contributors to GNU iostream.
|
|
@end menu
|
|
|
|
@node Copying
|
|
@section Licensing terms for @code{libio}
|
|
|
|
Since the @code{iostream} classes are so fundamental to standard C++,
|
|
the Free Software Foundation has agreed to a special exception to its
|
|
standard license, when you link programs with @code{libio.a}:
|
|
|
|
@quotation
|
|
As a special exception, if you link this library with files
|
|
compiled with a GNU compiler to produce an executable, this does not cause
|
|
the resulting executable to be covered by the GNU General Public License.
|
|
This exception does not however invalidate any other reasons why
|
|
the executable file might be covered by the GNU General Public License.
|
|
@end quotation
|
|
|
|
The code is under the @sc{gnu} General Public License (version 2) for
|
|
all other purposes than linking with this library; that means that you
|
|
can modify and redistribute the code as usual, but remember that if you
|
|
do, your modifications, and anything you link with the modified code,
|
|
must be available to others on the same terms.
|
|
|
|
These functions are also available as part of the @code{libg++}
|
|
library; if you link with that library instead of @code{libio}, the
|
|
@sc{gnu} Library General Public License applies.
|
|
|
|
@node Acknowledgements
|
|
@section Acknowledgements
|
|
|
|
Per Bothner wrote most of the @code{iostream} library, but some portions
|
|
have their origins elsewhere in the free software community. Heinz
|
|
Seidl wrote the IO manipulators. The floating-point conversion software
|
|
is by David M. Gay of AT&T. Some code was derived from parts of BSD
|
|
4.4, which was written at the University of California, Berkeley.
|
|
|
|
The iostream classes are found in the @code{libio} library. An early
|
|
version was originally distributed in @code{libg++}, and they are still
|
|
included there as well, for convenience if you need other @code{libg++}
|
|
classes. Doug Lea was the original author of @code{libg++}, and some of
|
|
the file-management code still in @code{libio} is his.
|
|
|
|
Various people found bugs or offered suggestions. Hongjiu Lu worked
|
|
hard to use the library as the default stdio implementation for Linux,
|
|
and has provided much stress-testing of the library.
|
|
|
|
@node Operators
|
|
@chapter Operators and Default Streams
|
|
|
|
The @sc{gnu} iostream library, @file{libio}, implements the standard
|
|
input and output facilities for C++. These facilities are roughly
|
|
analogous (in their purpose and ubiquity, at least) with those defined
|
|
by the C @file{stdio} functions.
|
|
|
|
Although these definitions come from a library, rather than being part
|
|
of the ``core language'', they are sufficiently central to be specified
|
|
in the latest working papers for C++.
|
|
|
|
You can use two operators defined in this library for basic input and
|
|
output operations. They are familiar from any C++ introductory
|
|
textbook: @code{<<} for output, and @code{>>} for input. (Think of data
|
|
flowing in the direction of the ``arrows''.)
|
|
|
|
These operators are often used in conjunction with three streams that
|
|
are open by default:
|
|
|
|
@deftypevar ostream cout
|
|
The standard output stream, analogous to the C @code{stdout}.
|
|
@end deftypevar
|
|
|
|
@deftypevar istream cin
|
|
The standard input stream, analogous to the C @code{stdin}.
|
|
@end deftypevar
|
|
|
|
@deftypevar ostream cerr
|
|
An alternative output stream for errors, analogous to the C
|
|
@code{stderr}.
|
|
@end deftypevar
|
|
|
|
@noindent
|
|
For example, this bare-bones C++ version of the traditional ``hello''
|
|
program uses @code{<<} and @code{cout}:
|
|
|
|
@example
|
|
#include <iostream.h>
|
|
|
|
int main(int argc, char **argv)
|
|
@{
|
|
cout << "Well, hi there.\n";
|
|
return 0;
|
|
@}
|
|
@end example
|
|
|
|
Casual use of these operators may be seductive, but---other than in
|
|
writing throwaway code for your own use---it is not necessarily simpler
|
|
than managing input and output in any other language. For example,
|
|
robust code should check the state of the input and output streams
|
|
between operations (for example, using the method @code{good}).
|
|
@xref{States,,Checking the state of a stream}. You may also need to
|
|
adjust maximum input or output field widths, using manipulators like
|
|
@code{setw} or @code{setprecision}.
|
|
|
|
@defop Operator ostream <<
|
|
Write output to an open output stream of class @code{ostream}.
|
|
Defined by this library on any @var{object} of a C++ primitive type, and
|
|
on other classes of the library. You can overload the definition for any
|
|
of your own applications' classes.
|
|
|
|
Returns a reference to the implied argument @code{*this} (the open stream it
|
|
writes on), permitting statements like
|
|
@example
|
|
cout << "The value of i is " << i << "\n";
|
|
@end example
|
|
@end defop
|
|
|
|
@defop Operator istream >>
|
|
Read input from an open input stream of class @code{istream}. Defined
|
|
by this library on primitive numeric, pointer, and string types; you can
|
|
extend the definition for any of your own applications' classes.
|
|
|
|
Returns a reference to the implied argument @code{*this} (the open stream
|
|
it reads), permitting multiple inputs in one statement.
|
|
@end defop
|
|
|
|
@node Streams
|
|
@chapter Stream Classes
|
|
|
|
The previous chapter referred in passing to the classes @code{ostream}
|
|
and @code{istream}, for output and input respectively. These classes
|
|
share certain properties, captured in their base class @code{ios}.
|
|
|
|
@menu
|
|
* Ios:: Shared properties.
|
|
* Ostream:: Managing output streams.
|
|
* Istream:: Managing input streams.
|
|
* Iostream:: Input and output together.
|
|
@end menu
|
|
|
|
@node Ios
|
|
@section Shared properties: class @code{ios}
|
|
|
|
The base class @code{ios} provides methods to test and manage the state
|
|
of input or output streams.
|
|
|
|
@code{ios} delegates the job of actually reading and writing bytes to
|
|
the abstract class @code{streambuf}, which is designed to provide
|
|
buffered streams (compatible with C, in the @sc{gnu} implementation).
|
|
@xref{Streambuf,,Using the @code{streambuf} layer}, for information on
|
|
the facilities available at the @code{streambuf} level.
|
|
|
|
@deftypefn Constructor {} ios::ios ([streambuf* @var{sb} @w{[, ostream*} @var{tie}])
|
|
The @code{ios} constructor by default initializes a new @code{ios}, and
|
|
if you supply a @code{streambuf} @var{sb} to associate with it, sets the
|
|
state @code{good} in the new @code{ios} object. It also sets the
|
|
default properties of the new object.
|
|
|
|
@ignore
|
|
@c FIXME--future: this (a) doesn't work, (b) is controversial at ANSI
|
|
An @code{ios} without a @code{streambuf} has the state @code{bad} until
|
|
you supply a @code{streambuf}; you can do that by assigning a new value
|
|
to the @code{ios} with @samp{=}.
|
|
@end ignore
|
|
|
|
You can also supply an optional second argument @var{tie} to the
|
|
constructor: if present, it is an initial value for @code{ios::tie}, to
|
|
associate the new @code{ios} object with another stream.
|
|
@end deftypefn
|
|
|
|
@deftypefn Destructor {} ios::~ios ()
|
|
The @code{ios} destructor is virtual, permitting application-specific
|
|
behavior when a stream is closed---typically, the destructor frees any
|
|
storage associated with the stream and releases any other associated
|
|
objects.
|
|
@end deftypefn
|
|
|
|
@c FIXME-future: Is @deftypefn really the best way of displaying these?
|
|
|
|
@c FIXME-future: Undocumented: ios::_throw_failure, ios::exceptions; things
|
|
@c controlled by _STREAM_COMPAT; ios::Init; ios::_IO_fix_vtable.
|
|
|
|
@menu
|
|
* States:: Checking the state of a stream.
|
|
* Format Control:: Choices in formatting.
|
|
* Manipulators:: Convenient ways of changing stream properties.
|
|
* Extending:: Extended data fields.
|
|
* Synchronization:: Synchronizing related streams.
|
|
* Streambuf from Ios:: Reaching the underlying streambuf.
|
|
@end menu
|
|
|
|
@node States
|
|
@subsection Checking the state of a stream
|
|
|
|
Use this collection of methods to test for (or signal) errors and other
|
|
exceptional conditions of streams:
|
|
|
|
@deftypefn Method {ios::operator void*} () const
|
|
You can do a quick check on the state of the most recent operation on a
|
|
stream by examining a pointer to the stream itself. The pointer is
|
|
arbitrary except for its truth value; it is true if no failures have
|
|
occurred (@code{ios::fail} is not true). For example, you might ask for
|
|
input on @code{cin} only if all prior output operations succeeded:
|
|
|
|
@example
|
|
if (cout)
|
|
@{
|
|
// Everything OK so far
|
|
cin >> new_value;
|
|
@dots{}
|
|
@}
|
|
@end example
|
|
@end deftypefn
|
|
|
|
@deftypefn Method {ios::operator !} () const
|
|
In case it is more convenient to check whether something has failed, the
|
|
operator @code{!} returns true if @code{ios::fail} is true (an operation
|
|
has failed). For example,
|
|
you might issue an error message if input failed:
|
|
|
|
@example
|
|
if (!cin)
|
|
@{
|
|
// Oops
|
|
cerr << "Eh?\n";
|
|
@}
|
|
@end example
|
|
@end deftypefn
|
|
|
|
@deftypefn Method iostate ios::rdstate () const
|
|
Return the state flags for this stream. The value is from the
|
|
enumeration @code{iostate}. You can test for any combination of
|
|
|
|
@vtable @code
|
|
@item goodbit
|
|
There are no indications of exceptional states on this stream.
|
|
|
|
@item eofbit
|
|
End of file.
|
|
|
|
@item failbit
|
|
An operation has failed on this stream; this usually indicates bad
|
|
format of input.
|
|
|
|
@item badbit
|
|
The stream is unusable.
|
|
@end vtable
|
|
@end deftypefn
|
|
|
|
@deftypefn Method void ios::setstate (iostate @var{state})
|
|
@findex ios::set
|
|
Set the state flag for this stream to @var{state} @emph{in addition to}
|
|
any state flags already set. Synonym (for upward compatibility):
|
|
@code{ios::set}.
|
|
|
|
See @code{ios::clear} to set the stream state without regard to existing
|
|
state flags. See @code{ios::good}, @code{ios::eof}, @code{ios::fail},
|
|
and @code{ios::bad}, to test the state.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int ios::good () const
|
|
Test the state flags associated with this stream; true if no error
|
|
indicators are set.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int ios::bad () const
|
|
Test whether a stream is marked as unusable. (Whether
|
|
@code{ios::badbit} is set.)
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int ios::eof () const
|
|
True if end of file was reached on this stream. (If @code{ios::eofbit}
|
|
is set.)
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int ios::fail () const
|
|
Test for any kind of failure on this stream: @emph{either} some
|
|
operation failed, @emph{or} the stream is marked as bad. (If either
|
|
@code{ios::failbit} or @code{ios::badbit} is set.)
|
|
@end deftypefn
|
|
|
|
@deftypefn Method void ios::clear (iostate @var{state})
|
|
@c FIXME-future: There is some complication to do with buffering and _throw_failure
|
|
Set the state indication for this stream to the argument @var{state}.
|
|
You may call @code{ios::clear} with no argument, in which case the state
|
|
is set to @code{good} (no errors pending).
|
|
|
|
See @code{ios::good}, @code{ios::eof}, @code{ios::fail}, and
|
|
@code{ios::bad}, to test the state; see @code{ios::set} or
|
|
@code{ios::setstate} for an alternative way of setting the state.
|
|
@end deftypefn
|
|
|
|
@node Format Control
|
|
@subsection Choices in formatting
|
|
|
|
These methods control (or report on) settings for some details of
|
|
controlling streams, primarily to do with formatting output:
|
|
|
|
@deftypefn Method char ios::fill () const
|
|
Report on the padding character in use.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method char ios::fill (char @var{padding})
|
|
Set the padding character. You can also use the manipulator
|
|
@code{setfill}. @xref{Manipulators,,Changing stream properties in
|
|
expressions}.
|
|
|
|
Default: blank.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int ios::precision () const
|
|
Report the number of significant digits currently in use for output of
|
|
floating point numbers.
|
|
|
|
Default: @code{6}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int ios::precision (int @var{signif})
|
|
Set the number of significant digits (for input and output numeric
|
|
conversions) to @var{signif}.
|
|
|
|
@findex setprecision
|
|
@cindex setting @code{ios::precision}
|
|
You can also use the manipulator @code{setprecision} for this purpose.
|
|
@xref{Manipulators,,Changing stream properties using manipulators}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int ios::width () const
|
|
Report the current output field width setting (the number of
|
|
characters to write on the next @samp{<<} output operation).
|
|
|
|
Default: @code{0}, which means to use as many characters as necessary.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int ios::width (int @var{num})
|
|
Set the input field width setting to @var{num}. Return the
|
|
@emph{previous} value for this stream.
|
|
|
|
@findex setw
|
|
@cindex setting @code{ios::width}
|
|
This value resets to zero (the default) every time you use @samp{<<}; it is
|
|
essentially an additional implicit argument to that operator. You can
|
|
also use the manipulator @code{setw} for this purpose.
|
|
@xref{Manipulators,,Changing stream properties using manipulators}.
|
|
@end deftypefn
|
|
|
|
@need 2000
|
|
@deftypefn Method fmtflags ios::flags () const
|
|
Return the current value of the complete collection of flags controlling
|
|
the format state. These are the flags and their meanings when set:
|
|
|
|
@vtable @code
|
|
@item ios::dec
|
|
@itemx ios::oct
|
|
@itemx ios::hex
|
|
What numeric base to use in converting integers from internal to display
|
|
representation, or vice versa: decimal, octal, or hexadecimal,
|
|
respectively. (You can change the base using the manipulator
|
|
@code{setbase}, or any of the manipulators @code{dec}, @code{oct}, or
|
|
@code{hex}; @pxref{Manipulators,,Changing stream properties in
|
|
expressions}.)
|
|
|
|
On input, if none of these flags is set, read numeric constants
|
|
according to the prefix: decimal if no prefix (or a @samp{.} suffix),
|
|
octal if a @samp{0} prefix is present, hexadecimal if a @samp{0x} prefix
|
|
is present.
|
|
|
|
Default: @code{dec}.
|
|
|
|
@item ios::fixed
|
|
Avoid scientific notation, and always show a fixed number of digits after
|
|
the decimal point, according to the output precision in effect.
|
|
Use @code{ios::precision} to set precision.
|
|
|
|
@item ios::left
|
|
@itemx ios::right
|
|
@itemx ios::internal
|
|
Where output is to appear in a fixed-width field; left-justified,
|
|
right-justified, or with padding in the middle (e.g. between a numeric
|
|
sign and the associated value), respectively.
|
|
|
|
@item ios::scientific
|
|
Use scientific (exponential) notation to display numbers.
|
|
|
|
@item ios::showbase
|
|
Display the conventional prefix as a visual indicator of the conversion
|
|
base: no prefix for decimal, @samp{0} for octal, @samp{0x} for hexadecimal.
|
|
|
|
@item ios::showpoint
|
|
Display a decimal point and trailing zeros after it to fill out numeric
|
|
fields, even when redundant.
|
|
|
|
@item ios::showpos
|
|
Display a positive sign on display of positive numbers.
|
|
|
|
@item ios::skipws
|
|
Skip white space. (On by default).
|
|
|
|
@item ios::stdio
|
|
Flush the C @code{stdio} streams @code{stdout} and @code{stderr} after
|
|
each output operation (for programs that mix C and C++ output conventions).
|
|
|
|
@item ios::unitbuf
|
|
Flush after each output operation.
|
|
|
|
@item ios::uppercase
|
|
Use upper-case characters for the non-numeral elements in numeric
|
|
displays; for instance, @samp{0X7A} rather than @samp{0x7a}, or
|
|
@samp{3.14E+09} rather than @samp{3.14e+09}.
|
|
@end vtable
|
|
@end deftypefn
|
|
|
|
@deftypefn Method fmtflags ios::flags (fmtflags @var{value})
|
|
Set @var{value} as the complete collection of flags controlling the
|
|
format state. The flag values are described under @samp{ios::flags ()}.
|
|
|
|
Use @code{ios::setf} or @code{ios::unsetf} to change one property at a
|
|
time.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method fmtflags ios::setf (fmtflags @var{flag})
|
|
Set one particular flag (of those described for @samp{ios::flags ()};
|
|
return the complete collection of flags @emph{previously} in effect.
|
|
(Use @code{ios::unsetf} to cancel.)
|
|
@end deftypefn
|
|
|
|
@deftypefn Method fmtflags ios::setf (fmtflags @var{flag}, fmtflags @var{mask})
|
|
Clear the flag values indicated by @var{mask}, then set any of them that
|
|
are also in @var{flag}. (Flag values are described for @samp{ios::flags
|
|
()}.) Return the complete collection of flags @emph{previously} in
|
|
effect. (See @code{ios::unsetf} for another way of clearing flags.)
|
|
@end deftypefn
|
|
|
|
@deftypefn Method fmtflags ios::unsetf (fmtflags @var{flag})
|
|
Make certain @var{flag} (a combination of flag values described for
|
|
@samp{ios::flags ()}) is not set for this stream; converse of
|
|
@code{ios::setf}. Returns the old values of those flags.
|
|
@c FIXME-future: should probably be fixed to give same result as setf.
|
|
@end deftypefn
|
|
|
|
@node Manipulators
|
|
@subsection Changing stream properties using manipulators
|
|
|
|
For convenience, @var{manipulators} provide a way to change certain
|
|
properties of streams, or otherwise affect them, in the middle of
|
|
expressions involving @samp{<<} or @samp{>>}. For example, you might
|
|
write
|
|
|
|
@example
|
|
cout << "|" << setfill('*') << setw(5) << 234 << "|";
|
|
@end example
|
|
|
|
@noindent
|
|
to produce @samp{|**234|} as output.
|
|
|
|
@deftypefn Manipulator {} ws
|
|
Skip whitespace.
|
|
@end deftypefn
|
|
|
|
@deftypefn Manipulator {} flush
|
|
Flush an output stream. For example, @samp{cout << @dots{} <<flush;}
|
|
has the same effect as @samp{cout << @dots{}; cout.flush();}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Manipulator {} endl
|
|
Write an end of line character @samp{\n}, then flushes the output stream.
|
|
@end deftypefn
|
|
|
|
@deftypefn Manipulator {} ends
|
|
Write @samp{\0} (the string terminator character).
|
|
@end deftypefn
|
|
|
|
@deftypefn Manipulator {} setprecision (int @var{signif})
|
|
You can change the value of @code{ios::precision} in @samp{<<}
|
|
expressions with the manipulator @samp{setprecision(@var{signif})}; for
|
|
example,
|
|
|
|
@example
|
|
cout << setprecision(2) << 4.567;
|
|
@end example
|
|
|
|
@noindent
|
|
prints @samp{4.6}. Requires @file{#include <iomanip.h>}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Manipulator {} setw (int @var{n})
|
|
You can change the value of @code{ios::width} in @samp{<<} expressions
|
|
with the manipulator @samp{setw(@var{n})}; for example,
|
|
|
|
@example
|
|
cout << setw(5) << 234;
|
|
@end example
|
|
|
|
@noindent
|
|
prints @w{@samp{ 234}} with two leading blanks. Requires @file{#include
|
|
<iomanip.h>}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Manipulator {} setbase (int @var{base})
|
|
Where @var{base} is one of @code{10} (decimal), @code{8} (octal), or
|
|
@code{16} (hexadecimal), change the base value for numeric
|
|
representations. Requires @file{#include <iomanip.h>}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Manipulator {} dec
|
|
Select decimal base; equivalent to @samp{setbase(10)}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Manipulator {} hex
|
|
Select hexadecimal base; equivalent to @samp{setbase(16)}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Manipulator {} oct
|
|
Select octal base; equivalent to @samp{setbase(8)}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Manipulator {} setfill (char @var{padding})
|
|
Set the padding character, in the same way as @code{ios::fill}.
|
|
Requires @file{#include <iomanip.h>}.
|
|
@end deftypefn
|
|
|
|
@node Extending
|
|
@subsection Extended data fields
|
|
|
|
A related collection of methods allows you to extend this collection of
|
|
flags and parameters for your own applications, without risk of conflict
|
|
between them:
|
|
|
|
@deftypefn Method {static fmtflags} ios::bitalloc ()
|
|
Reserve a bit (the single bit on in the result) to use as a flag. Using
|
|
@code{bitalloc} guards against conflict between two packages that use
|
|
@code{ios} objects for different purposes.
|
|
|
|
This method is available for upward compatibility, but is not in the
|
|
@sc{ansi} working paper. The number of bits available is limited; a
|
|
return value of @code{0} means no bit is available.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method {static int} ios::xalloc ()
|
|
Reserve space for a long integer or pointer parameter. The result is a
|
|
unique nonnegative integer. You can use it as an index to
|
|
@code{ios::iword} or @code{ios::pword}. Use @code{xalloc} to arrange
|
|
for arbitrary special-purpose data in your @code{ios} objects, without
|
|
risk of conflict between packages designed for different purposes.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method long& ios::iword (int @var{index})
|
|
Return a reference to arbitrary data, of long integer type, stored in an
|
|
@code{ios} instance. @var{index}, conventionally returned from
|
|
@code{ios::xalloc}, identifies what particular data you need.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method long ios::iword (int @var{index}) const
|
|
Return the actual value of a long integer stored in an @code{ios}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method void*& ios::pword (int @var{index})
|
|
Return a reference to an arbitrary pointer, stored in an @code{ios}
|
|
instance. @var{index}, originally returned from @code{ios::xalloc},
|
|
identifies what particular pointer you need.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method void* ios::pword (int @var{index}) const
|
|
Return the actual value of a pointer stored in an @code{ios}.
|
|
@end deftypefn
|
|
|
|
@node Synchronization
|
|
@subsection Synchronizing related streams
|
|
|
|
You can use these methods to synchronize related streams with
|
|
one another:
|
|
|
|
@deftypefn Method ostream* ios::tie () const
|
|
Report on what output stream, if any, is to be flushed before accessing
|
|
this one. A pointer value of @code{0} means no stream is tied.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method ostream* ios::tie (ostream* @var{assoc})
|
|
Declare that output stream @var{assoc} must be flushed before accessing
|
|
this stream.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int ios::sync_with_stdio ([int @var{switch}])
|
|
Unless iostreams and C @code{stdio} are designed to work together, you
|
|
may have to choose between efficient C++ streams output and output
|
|
compatible with C @code{stdio}. Use @samp{ios::sync_with_stdio()} to
|
|
select C compatibility.
|
|
|
|
The argument @var{switch} is a @sc{gnu} extension; use @code{0} as the
|
|
argument to choose output that is not necessarily compatible with C
|
|
@code{stdio}. The default value for @var{switch} is @code{1}.
|
|
|
|
If you install the @code{stdio} implementation that comes with @sc{gnu}
|
|
@code{libio}, there are compatible input/output facilities for both C
|
|
and C++. In that situation, this method is unnecessary---but you may
|
|
still want to write programs that call it, for portability.
|
|
@end deftypefn
|
|
|
|
@node Streambuf from Ios
|
|
@subsection Reaching the underlying @code{streambuf}
|
|
|
|
Finally, you can use this method to access the underlying object:
|
|
|
|
@deftypefn Method streambuf* ios::rdbuf () const
|
|
Return a pointer to the @code{streambuf} object that underlies this
|
|
@code{ios}.
|
|
@end deftypefn
|
|
|
|
@node Ostream
|
|
@section Managing output streams: class @code{ostream}
|
|
|
|
Objects of class @code{ostream} inherit the generic methods from
|
|
@code{ios}, and in addition have the following methods available.
|
|
Declarations for this class come from @file{iostream.h}.
|
|
|
|
@deftypefn Constructor {} ostream::ostream ()
|
|
The simplest form of the constructor for an @code{ostream} simply
|
|
allocates a new @code{ios} object.
|
|
@end deftypefn
|
|
|
|
@deftypefn Constructor {} ostream::ostream (streambuf* @var{sb} @w{[, ostream} @var{tie}])
|
|
This alternative constructor requires a first argument @var{sb} of type
|
|
@code{streambuf*}, to use an existing open stream for output. It also
|
|
accepts an optional second argument @var{tie}, to specify a related
|
|
@code{ostream*} as the initial value for @code{ios::tie}.
|
|
|
|
If you give the @code{ostream} a @code{streambuf} explicitly, using
|
|
this constructor, the @var{sb} is @emph{not} destroyed (or deleted or
|
|
closed) when the @code{ostream} is destroyed.
|
|
@end deftypefn
|
|
|
|
@menu
|
|
* Writing:: Writing on an ostream.
|
|
* Output Position:: Repositioning an ostream.
|
|
* Ostream Housekeeping:: Miscellaneous ostream utilities.
|
|
@end menu
|
|
|
|
@node Writing
|
|
@subsection Writing on an @code{ostream}
|
|
|
|
These methods write on an @code{ostream} (you may also use the operator
|
|
@code{<<}; @pxref{Operators,,Operators and Default Streams}).
|
|
|
|
@deftypefn Method ostream& ostream::put (char @var{c})
|
|
Write the single character @var{c}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method ostream& ostream::write (@var{string}, int @var{length})
|
|
Write @var{length} characters of a string to this @code{ostream},
|
|
beginning at the pointer @var{string}.
|
|
|
|
@var{string} may have any of these types: @code{char*}, @code{unsigned
|
|
char*}, @code{signed char*}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method ostream& ostream::form (const char *@var{format}, ...)
|
|
A @sc{gnu} extension, similar to @code{fprintf(@var{file},
|
|
@var{format}, ...)}.
|
|
|
|
@var{format} is a @code{printf}-style format control string, which is used
|
|
to format the (variable number of) arguments, printing the result on
|
|
this @code{ostream}. See @code{ostream::vform} for a version that uses
|
|
an argument list rather than a variable number of arguments.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method ostream& ostream::vform (const char *@var{format}, va_list @var{args})
|
|
A @sc{gnu} extension, similar to @code{vfprintf(@var{file},
|
|
@var{format}, @var{args})}.
|
|
|
|
@var{format} is a @code{printf}-style format control string, which is used
|
|
to format the argument list @var{args}, printing the result on
|
|
this @code{ostream}. See @code{ostream::form} for a version that uses a
|
|
variable number of arguments rather than an argument list.
|
|
@end deftypefn
|
|
|
|
@node Output Position
|
|
@subsection Repositioning an @code{ostream}
|
|
|
|
You can control the output position (on output streams that actually
|
|
support positions, typically files) with these methods:
|
|
@c FIXME-future: sort out which classes support this and which
|
|
@c don't; fstream, filebuf? And what is failure condition when not supported?
|
|
|
|
@deftypefn Method streampos ostream::tellp ()
|
|
Return the current write position in the stream.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method ostream& ostream::seekp (streampos @var{loc})
|
|
Reset the output position to @var{loc} (which is usually the result of a
|
|
previous call to @code{ostream::tellp}). @var{loc} specifies an
|
|
absolute position in the output stream.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method ostream& ostream::seekp (streamoff @var{loc}, @var{rel})
|
|
@findex ios::seekdir
|
|
Reset the output position to @var{loc}, relative to the beginning, end,
|
|
or current output position in the stream, as indicated by @var{rel} (a
|
|
value from the enumeration @code{ios::seekdir}):
|
|
|
|
@vtable @code
|
|
@item beg
|
|
Interpret @var{loc} as an absolute offset from the beginning of the
|
|
file.
|
|
|
|
@item cur
|
|
Interpret @var{loc} as an offset relative to the current output
|
|
position.
|
|
|
|
@item end
|
|
Interpret @var{loc} as an offset from the current end of the output
|
|
stream.
|
|
@end vtable
|
|
@end deftypefn
|
|
|
|
@node Ostream Housekeeping
|
|
@subsection Miscellaneous @code{ostream} utilities
|
|
|
|
You may need to use these @code{ostream} methods for housekeeping:
|
|
|
|
@deftypefn Method ostream& flush ()
|
|
Deliver any pending buffered output for this @code{ostream}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int ostream::opfx ()
|
|
@code{opfx} is a @dfn{prefix} method for operations on @code{ostream}
|
|
objects; it is designed to be called before any further processing. See
|
|
@code{ostream::osfx} for the converse.
|
|
@c FIXME-future: specify sometime which methods start with opfx.
|
|
|
|
@code{opfx} tests that the stream is in state @code{good}, and if so
|
|
flushes any stream tied to this one.
|
|
|
|
The result is @code{1} when @code{opfx} succeeds; else (if the stream state is
|
|
not @code{good}), the result is @code{0}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method void ostream::osfx ()
|
|
@code{osfx} is a @dfn{suffix} method for operations on @code{ostream}
|
|
objects; it is designed to be called at the conclusion of any processing. All
|
|
the @code{ostream} methods end by calling @code{osfx}. See
|
|
@code{ostream::opfx} for the converse.
|
|
|
|
If the @code{unitbuf} flag is set for this stream, @code{osfx} flushes
|
|
any buffered output for it.
|
|
|
|
If the @code{stdio} flag is set for this stream, @code{osfx} flushes any
|
|
output buffered for the C output streams @file{stdout} and @file{stderr}.
|
|
@end deftypefn
|
|
|
|
@node Istream
|
|
@section Managing input streams: class @code{istream}
|
|
|
|
Class @code{istream} objects are specialized for input; as for
|
|
@code{ostream}, they are derived from @code{ios}, so you can use any of
|
|
the general-purpose methods from that base class. Declarations for this
|
|
class also come from @file{iostream.h}.
|
|
|
|
@deftypefn Constructor {} istream::istream ()
|
|
When used without arguments, the @code{istream} constructor simply
|
|
allocates a new @code{ios} object and initializes the input counter (the
|
|
value reported by @code{istream::gcount}) to @code{0}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Constructor {} istream::istream (streambuf *@var{sb} @w{[, ostream} @var{tie}])
|
|
You can also call the constructor with one or two arguments. The first
|
|
argument @var{sb} is a @code{streambuf*}; if you supply this pointer,
|
|
the constructor uses that @code{streambuf} for input.
|
|
You can use the second optional argument @var{tie} to specify a related
|
|
output stream as the initial value for @code{ios::tie}.
|
|
|
|
If you give the @code{istream} a @code{streambuf} explicitly, using
|
|
this constructor, the @var{sb} is @emph{not} destroyed (or deleted or
|
|
closed) when the @code{ostream} is destroyed.
|
|
@end deftypefn
|
|
|
|
@menu
|
|
* Char Input:: Reading one character.
|
|
* String Input:: Reading strings.
|
|
* Input Position:: Repositioning an istream.
|
|
* Istream Housekeeping:: Miscellaneous istream utilities.
|
|
@end menu
|
|
|
|
@node Char Input
|
|
@subsection Reading one character
|
|
|
|
Use these methods to read a single character from the input stream:
|
|
|
|
@deftypefn Method int istream::get ()
|
|
Read a single character (or @code{EOF}) from the input stream, returning
|
|
it (coerced to an unsigned char) as the result.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method istream& istream::get (char& @var{c})
|
|
Read a single character from the input stream, into @code{&@var{c}}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int istream::peek ()
|
|
Return the next available input character, but @emph{without} changing
|
|
the current input position.
|
|
@end deftypefn
|
|
|
|
@node String Input
|
|
@subsection Reading strings
|
|
|
|
Use these methods to read strings (for example, a line at a time) from
|
|
the input stream:
|
|
|
|
@deftypefn Method istream& istream::get (char* @var{c}, int @var{len} @w{[, char} @var{delim}])
|
|
Read a string from the input stream, into the array at @var{c}.
|
|
|
|
The remaining arguments limit how much to read: up to @samp{len-1}
|
|
characters, or up to (but not including) the first occurrence in the
|
|
input of a particular delimiter character @var{delim}---newline
|
|
(@code{\n}) by default. (Naturally, if the stream reaches end of file
|
|
first, that too will terminate reading.)
|
|
|
|
If @var{delim} was present in the input, it remains available as if
|
|
unread; to discard it instead, see @code{iostream::getline}.
|
|
|
|
@code{get} writes @samp{\0} at the end of the string, regardless
|
|
of which condition terminates the read.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method istream& istream::get (streambuf& @var{sb} @w{[, char} @var{delim}])
|
|
Read characters from the input stream and copy them on the
|
|
@code{streambuf} object @var{sb}. Copying ends either just before the
|
|
next instance of the delimiter character @var{delim} (newline @code{\n}
|
|
by default), or when either stream ends. If @var{delim} was present in
|
|
the input, it remains available as if unread.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method istream& istream::getline (@var{charptr}, int @var{len} @w{[, char} @var{delim}])
|
|
Read a line from the input stream, into the array at @var{charptr}.
|
|
@var{charptr} may be any of three kinds of pointer: @code{char*},
|
|
@code{unsigned char*}, or @code{signed char*}.
|
|
|
|
The remaining arguments limit how much to read: up to (but not
|
|
including) the first occurrence in the input of a line delimiter
|
|
character @var{delim}---newline (@code{\n}) by default, or up to
|
|
@samp{len-1} characters (or to end of file, if that happens sooner).
|
|
|
|
If @code{getline} succeeds in reading a ``full line'', it also discards
|
|
the trailing delimiter character from the input stream. (To preserve it
|
|
as available input, see the similar form of @code{iostream::get}.)
|
|
|
|
If @var{delim} was @emph{not} found before @var{len} characters or end
|
|
of file, @code{getline} sets the @code{ios::fail} flag, as well as the
|
|
@code{ios::eof} flag if appropriate.
|
|
|
|
@code{getline} writes a null character at the end of the string, regardless
|
|
of which condition terminates the read.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method istream& istream::read (@var{pointer}, int @var{len})
|
|
Read @var{len} bytes into the location at @var{pointer}, unless the
|
|
input ends first.
|
|
|
|
@var{pointer} may be of type @code{char*}, @code{void*}, @code{unsigned
|
|
char*}, or @code{signed char*}.
|
|
|
|
If the @code{istream} ends before reading @var{len} bytes, @code{read}
|
|
sets the @code{ios::fail} flag.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method istream& istream::gets (char **@var{s} @w{[, char} @var{delim}])
|
|
A @sc{gnu} extension, to read an arbitrarily long string
|
|
from the current input position to the next instance of the @var{delim}
|
|
character (newline @code{\n} by default).
|
|
|
|
To permit reading a string of arbitrary length, @code{gets} allocates
|
|
whatever memory is required. Notice that the first argument @var{s} is
|
|
an address to record a character pointer, rather than the pointer
|
|
itself.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method istream& istream::scan (const char *format ...)
|
|
A @sc{gnu} extension, similar to @code{fscanf(@var{file},
|
|
@var{format}, ...)}. The @var{format} is a @code{scanf}-style format
|
|
control string, which is used to read the variables in the remainder of
|
|
the argument list from the @code{istream}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method istream& istream::vscan (const char *format, va_list args)
|
|
Like @code{istream::scan}, but takes a single @code{va_list} argument.
|
|
@end deftypefn
|
|
|
|
@node Input Position
|
|
@subsection Repositioning an @code{istream}
|
|
|
|
Use these methods to control the current input position:
|
|
|
|
@deftypefn Method streampos istream::tellg ()
|
|
Return the current read position, so that you can save it and return to
|
|
it later with @code{istream::seekg}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method istream& istream::seekg (streampos @var{p})
|
|
Reset the input pointer (if the input device permits it) to @var{p},
|
|
usually the result of an earlier call to @code{istream::tellg}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method istream& istream::seekg (streamoff @var{offset}, ios::seek_dir @var{ref})
|
|
Reset the input pointer (if the input device permits it) to @var{offset}
|
|
characters from the beginning of the input, the current position, or the
|
|
end of input. Specify how to interpret @var{offset} with one of these
|
|
values for the second argument:
|
|
|
|
@vtable @code
|
|
@item ios::beg
|
|
Interpret @var{loc} as an absolute offset from the beginning of the
|
|
file.
|
|
|
|
@item ios::cur
|
|
Interpret @var{loc} as an offset relative to the current output
|
|
position.
|
|
|
|
@item ios::end
|
|
Interpret @var{loc} as an offset from the current end of the output
|
|
stream.
|
|
@end vtable
|
|
@end deftypefn
|
|
|
|
@node Istream Housekeeping
|
|
@subsection Miscellaneous @code{istream} utilities
|
|
|
|
Use these methods for housekeeping on @code{istream} objects:
|
|
|
|
@deftypefn Method int istream::gcount ()
|
|
Report how many characters were read from this @code{istream} in the
|
|
last unformatted input operation.
|
|
@c FIXME! Define "unformatted input" somewhere...
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int istream::ipfx (int @var{keepwhite})
|
|
Ensure that the @code{istream} object is ready for reading; check for
|
|
errors and end of file and flush any tied stream. @code{ipfx} skips
|
|
whitespace if you specify @code{0} as the @var{keepwhite}
|
|
argument, @emph{and} @code{ios::skipws} is set for this stream.
|
|
|
|
To avoid skipping whitespace (regardless of the @code{skipws} setting on
|
|
the stream), use @code{1} as the argument.
|
|
|
|
Call @code{istream::ipfx} to simplify writing your own methods for reading
|
|
@code{istream} objects.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method void istream::isfx ()
|
|
A placeholder for compliance with the draft @sc{ansi} standard; this
|
|
method does nothing whatever.
|
|
|
|
If you wish to write portable standard-conforming code on @code{istream}
|
|
objects, call @code{isfx} after any operation that reads from an
|
|
@code{istream}; if @code{istream::ipfx} has any special effects that
|
|
must be cancelled when done, @code{istream::isfx} will cancel them.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method istream& istream::ignore ([int @var{n}] @w{[, int} @var{delim}])
|
|
Discard some number of characters pending input. The first optional
|
|
argument @var{n} specifies how many characters to skip. The second
|
|
optional argument @var{delim} specifies a ``boundary'' character:
|
|
@code{ignore} returns immediately if this character appears in the
|
|
input.
|
|
|
|
By default, @var{delim} is @code{EOF}; that is, if you do not specify a
|
|
second argument, only the count @var{n} restricts how much to ignore
|
|
(while input is still available).
|
|
|
|
If you do not specify how many characters to ignore, @code{ignore}
|
|
returns after discarding only one character.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method istream& istream::putback (char @var{ch})
|
|
Attempts to back up one character, replacing the character backed-up
|
|
over by @var{ch}. Returns @code{EOF} if this is not allowed. Putting
|
|
back the most recently read character is always allowed. (This method
|
|
corresponds to the C function @code{ungetc}.)
|
|
@end deftypefn
|
|
|
|
@deftypefn Method istream& istream::unget ()
|
|
Attempt to back up one character.
|
|
@end deftypefn
|
|
|
|
@node Iostream
|
|
@section Input and output together: class @code{iostream}
|
|
|
|
If you need to use the same stream for input and output, you can use an
|
|
object of the class @code{iostream}, which is derived from @emph{both}
|
|
@code{istream} and @code{ostream}.
|
|
|
|
The constructors for @code{iostream} behave just like the constructors
|
|
for @code{istream}.
|
|
|
|
@deftypefn Constructor {} iostream::iostream ()
|
|
When used without arguments, the @code{iostream} constructor simply
|
|
allocates a new @code{ios} object, and initializes the input counter
|
|
(the value reported by @code{istream::gcount}) to @code{0}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Constructor {} iostream::iostream (streambuf* @var{sb} @w{[, ostream*} @var{tie}])
|
|
You can also call a constructor with one or two arguments. The first
|
|
argument @var{sb} is a @code{streambuf*}; if you supply this pointer,
|
|
the constructor uses that @code{streambuf} for input and output.
|
|
|
|
You can use the optional second argument @var{tie} (an @code{ostream*})
|
|
to specify a related output stream as the initial value for
|
|
@code{ios::tie}.
|
|
@end deftypefn
|
|
|
|
@cindex @code{iostream} destructor
|
|
@cindex destructor for @code{iostream}
|
|
As for @code{ostream} and @code{istream}, @code{iostream} simply uses
|
|
the @code{ios} destructor. However, an @code{iostream} is not deleted by
|
|
its destructor.
|
|
|
|
You can use all the @code{istream}, @code{ostream}, and @code{ios}
|
|
methods with an @code{iostream} object.
|
|
|
|
@node Files and Strings
|
|
@chapter Classes for Files and Strings
|
|
|
|
There are two very common special cases of input and output: using files,
|
|
and using strings in memory.
|
|
|
|
@code{libio} defines four specialized classes for these cases:
|
|
|
|
@ftable @code
|
|
@item ifstream
|
|
Methods for reading files.
|
|
|
|
@item ofstream
|
|
Methods for writing files.
|
|
|
|
@item istrstream
|
|
Methods for reading strings from memory.
|
|
|
|
@item ostrstream
|
|
Methods for writing strings in memory.
|
|
@end ftable
|
|
|
|
@menu
|
|
* Files:: Reading and writing files.
|
|
* Strings:: Reading and writing strings in memory.
|
|
@end menu
|
|
|
|
@node Files
|
|
@section Reading and writing files
|
|
|
|
These methods are declared in @file{fstream.h}.
|
|
|
|
@findex ifstream
|
|
@cindex class @code{ifstream}
|
|
You can read data from class @code{ifstream} with any operation from class
|
|
@code{istream}. There are also a few specialized facilities:
|
|
|
|
@deftypefn Constructor {} ifstream::ifstream ()
|
|
Make an @code{ifstream} associated with a new file for input. (If you
|
|
use this version of the constructor, you need to call
|
|
@code{ifstream::open} before actually reading anything)
|
|
@end deftypefn
|
|
|
|
@deftypefn Constructor {} ifstream::ifstream (int @var{fd})
|
|
Make an @code{ifstream} for reading from a file that was already open,
|
|
using file descriptor @var{fd}. (This constructor is compatible with
|
|
other versions of iostreams for @sc{posix} systems, but is not part of
|
|
the @sc{ansi} working paper.)
|
|
@end deftypefn
|
|
|
|
@deftypefn Constructor {} ifstream::ifstream (const char* @var{fname} @w{[, int} @var{mode} @w{[, int} @var{prot}]])
|
|
Open a file @code{*@var{fname}} for this @code{ifstream} object.
|
|
|
|
By default, the file is opened for input (with @code{ios::in} as
|
|
@var{mode}). If you use this constructor, the file will be closed when
|
|
the @code{ifstream} is destroyed.
|
|
|
|
You can use the optional argument @var{mode} to specify how to open the
|
|
file, by combining these enumerated values (with @samp{|} bitwise or).
|
|
(These values are actually defined in class @code{ios}, so that all
|
|
file-related streams may inherit them.) Only some of these modes are
|
|
defined in the latest draft @sc{ansi} specification; if portability is
|
|
important, you may wish to avoid the others.
|
|
|
|
@vtable @code
|
|
@item ios::in
|
|
Open for input. (Included in @sc{ansi} draft.)
|
|
|
|
@item ios::out
|
|
Open for output. (Included in @sc{ansi} draft.)
|
|
|
|
@item ios::ate
|
|
Set the initial input (or output) position to the end of the file.
|
|
|
|
@item ios::app
|
|
Seek to end of file before each write. (Included in @sc{ansi} draft.)
|
|
|
|
@item ios::trunc
|
|
Guarantee a fresh file; discard any contents that were previously
|
|
associated with it.
|
|
|
|
@item ios::nocreate
|
|
Guarantee an existing file; fail if the specified file did not already
|
|
exist.
|
|
|
|
@item ios::noreplace
|
|
Guarantee a new file; fail if the specified file already existed.
|
|
|
|
@item ios::bin
|
|
Open as a binary file (on systems where binary and text files have different
|
|
properties, typically how @samp{\n} is mapped; included in @sc{ansi} draft).
|
|
@end vtable
|
|
|
|
@noindent
|
|
The last optional argument @var{prot} is specific to Unix-like systems;
|
|
it specifies the file protection (by default @samp{644}).
|
|
@end deftypefn
|
|
|
|
@deftypefn Method void ifstream::open (const char* @var{fname} @w{[, int} @var{mode} @w{[, int} @var{prot}]])
|
|
Open a file explicitly after the associated @code{ifstream} object
|
|
already exists (for instance, after using the default constructor). The
|
|
arguments, options and defaults all have the same meanings as in the
|
|
fully specified @code{ifstream} constructor.
|
|
@end deftypefn
|
|
|
|
@findex ostream
|
|
@cindex class @code{ostream}
|
|
You can write data to class @code{ofstream} with any operation from class
|
|
@code{ostream}. There are also a few specialized facilities:
|
|
|
|
@deftypefn Constructor {} ofstream::ofstream ()
|
|
Make an @code{ofstream} associated with a new file for output.
|
|
@end deftypefn
|
|
|
|
@deftypefn Constructor {} ofstream::ofstream (int @var{fd})
|
|
Make an @code{ofstream} for writing to a file that was already open,
|
|
using file descriptor @var{fd}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Constructor {} ofstream::ofstream (const char* @var{fname} @w{[, int} @var{mode} @w{[, int} @var{prot}]])
|
|
Open a file @code{*@var{fname}} for this @code{ofstream} object.
|
|
|
|
By default, the file is opened for output (with @code{ios::out} as @var{mode}).
|
|
You can use the optional argument @var{mode} to specify how to open the
|
|
file, just as described for @code{ifstream::ifstream}.
|
|
|
|
The last optional argument @var{prot} specifies the file protection (by
|
|
default @samp{644}).
|
|
@end deftypefn
|
|
|
|
@deftypefn Destructor {} ofstream::~ofstream ()
|
|
The files associated with @code{ofstream} objects are closed when the
|
|
corresponding object is destroyed.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method void ofstream::open (const char* @var{fname} @w{[, int} @var{mode} @w{[, int} @var{prot}]])
|
|
Open a file explicitly after the associated @code{ofstream} object
|
|
already exists (for instance, after using the default constructor). The
|
|
arguments, options and defaults all have the same meanings as in the
|
|
fully specified @code{ofstream} constructor.
|
|
@end deftypefn
|
|
|
|
@findex fstream
|
|
@cindex class @code{fstream}
|
|
The class @code{fstream} combines the facilities of @code{ifstream} and
|
|
@code{ofstream}, just as @code{iostream} combines @code{istream} and
|
|
@code{ostream}.
|
|
|
|
@c FIXME-future: say something about fstream constructor, maybe.
|
|
|
|
@findex fstreambase
|
|
@cindex class @code{fstreambase}
|
|
The class @code{fstreambase} underlies both @code{ifstream} and
|
|
@code{ofstream}. They both inherit this additional method:
|
|
|
|
@deftypefn Method void fstreambase::close ()
|
|
Close the file associated with this object, and set @code{ios::fail} in
|
|
this object to mark the event.
|
|
@end deftypefn
|
|
|
|
@node Strings
|
|
@section Reading and writing in memory
|
|
|
|
@c FIXME!! Per, there's a lot of guesswork here---please check carefully!
|
|
|
|
@findex istrstream
|
|
@cindex class @code{istrstream}
|
|
@findex ostrstream
|
|
@cindex class @code{ostrstream}
|
|
@findex strstream
|
|
@cindex class @code{strstream}
|
|
@findex strstreambase
|
|
@cindex class @code{strstreambase}
|
|
@findex strstreambuf
|
|
@cindex class @code{strstreambuf}
|
|
The classes @code{istrstream}, @code{ostrstream}, and @code{strstream}
|
|
provide some additional features for reading and writing strings in
|
|
memory---both static strings, and dynamically allocated strings. The
|
|
underlying class @code{strstreambase} provides some features common to
|
|
all three; @code{strstreambuf} underlies that in turn.
|
|
|
|
@c FIXME-future: Document strstreambuf methods one day, when we document
|
|
@c streambuf more fully.
|
|
|
|
@deftypefn Constructor {} istrstream::istrstream (const char* @var{str} @w{[, int} @var{size}])
|
|
Associate the new input string class @code{istrstream} with an existing
|
|
static string starting at @var{str}, of size @var{size}. If you do not
|
|
specify @var{size}, the string is treated as a @code{NUL} terminated string.
|
|
@end deftypefn
|
|
|
|
@deftypefn Constructor {} ostrstream::ostrstream ()
|
|
Create a new stream for output to a dynamically managed string, which
|
|
will grow as needed.
|
|
@end deftypefn
|
|
|
|
@deftypefn Constructor {} ostrstream::ostrstream (char* @var{str}, int @var{size} [,int @var{mode}])
|
|
A new stream for output to a statically defined string of length
|
|
@var{size}, starting at @var{str}. You may optionally specify one of
|
|
the modes described for @code{ifstream::ifstream}; if you do not specify
|
|
one, the new stream is simply open for output, with mode @code{ios::out}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int ostrstream::pcount ()
|
|
Report the current length of the string associated with this @code{ostrstream}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method char* ostrstream::str ()
|
|
A pointer to the string managed by this @code{ostrstream}. Implies
|
|
@samp{ostrstream::freeze()}.
|
|
|
|
Note that if you want the string to be nul-terminated,
|
|
you must do that yourself (perhaps by writing ends to the stream).
|
|
@end deftypefn
|
|
|
|
@deftypefn Method void ostrstream::freeze ([int @var{n}])
|
|
If @var{n} is nonzero (the default), declare that the string associated
|
|
with this @code{ostrstream} is not to change dynamically; while frozen,
|
|
it will not be reallocated if it needs more space, and it will not be
|
|
deallocated when the @code{ostrstream} is destroyed. Use
|
|
@samp{freeze(1)} if you refer to the string as a pointer after creating
|
|
it via @code{ostrstream} facilities.
|
|
|
|
@samp{freeze(0)} cancels this declaration, allowing a dynamically
|
|
allocated string to be freed when its @code{ostrstream} is destroyed.
|
|
|
|
If this @code{ostrstream} is already static---that is, if it was created
|
|
to manage an existing statically allocated string---@code{freeze} is
|
|
unnecessary, and has no effect.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int ostrstream::frozen ()
|
|
Test whether @code{freeze(1)} is in effect for this string.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method strstreambuf* strstreambase::rdbuf ()
|
|
A pointer to the underlying @code{strstreambuf}.
|
|
@end deftypefn
|
|
|
|
@node Streambuf
|
|
@chapter Using the @code{streambuf} Layer
|
|
|
|
The @code{istream} and @code{ostream} classes are meant to handle
|
|
conversion between objects in your program and their textual representation.
|
|
|
|
By contrast, the underlying @code{streambuf} class is for transferring
|
|
raw bytes between your program, and input sources or output sinks.
|
|
Different @code{streambuf} subclasses connect to different kinds of
|
|
sources and sinks.
|
|
|
|
The @sc{gnu} implementation of @code{streambuf} is still evolving; we
|
|
describe only some of the highlights.
|
|
|
|
@menu
|
|
* Areas:: Areas in a streambuf.
|
|
* Overflow:: Simple output re-direction
|
|
* Formatting:: C-style formatting for streambuf objects.
|
|
* Stdiobuf:: Wrappers for C stdio.
|
|
* Procbuf:: Reading/writing from/to a pipe
|
|
* Backing Up:: Marking and returning to a position.
|
|
* Indirectbuf:: Forwarding I/O activity.
|
|
@end menu
|
|
|
|
@node Areas
|
|
@section Areas of a @code{streambuf}
|
|
|
|
Streambuf buffer management is fairly sophisticated (this is a
|
|
nice way to say ``complicated''). The standard protocol
|
|
has the following ``areas'':
|
|
|
|
@itemize @bullet
|
|
@item
|
|
@cindex put area
|
|
The @dfn{put area} contains characters waiting for output.
|
|
|
|
@item
|
|
@cindex get area
|
|
The @dfn{get area} contains characters available for reading.
|
|
@end itemize
|
|
|
|
The @sc{gnu} @code{streambuf} design extends this, but the details are
|
|
still evolving.
|
|
|
|
The following methods are used to manipulate these areas.
|
|
These are all protected methods, which are intended to be
|
|
used by virtual function in classes derived from @code{streambuf}.
|
|
They are also all ANSI/ISO-standard, and the ugly names
|
|
are traditional.
|
|
(Note that if a pointer points to the 'end' of an area,
|
|
it means that it points to the character after the area.)
|
|
|
|
@deftypefn Method char* streambuf::pbase () const
|
|
Returns a pointer to the start of the put area.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method char* streambuf::epptr () const
|
|
Returns a pointer to the end of the put area.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method char* streambuf::pptr () const
|
|
If @code{pptr() < epptr ()}, the @code{pptr()}
|
|
returns a pointer to the current put position.
|
|
(In that case, the next write will
|
|
overwrite @code{*pptr()}, and increment @code{pptr()}.)
|
|
Otherwise, there is no put position available
|
|
(and the next character written will cause @code{streambuf::overflow}
|
|
to be called).
|
|
@end deftypefn
|
|
|
|
@deftypefn Method void streambuf::pbump (int @var{N})
|
|
Add @var{N} to the current put pointer.
|
|
No error checking is done.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method void streambuf::setp (char* @var{P}, char* @var{E})
|
|
Sets the start of the put area to @var{P}, the end of the put area to @var{E},
|
|
and the current put pointer to @var{P} (also).
|
|
@end deftypefn
|
|
|
|
@deftypefn Method char* streambuf::eback () const
|
|
Returns a pointer to the start of the get area.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method char* streambuf::egptr () const
|
|
Returns a pointer to the end of the get area.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method char* streambuf::gptr () const
|
|
If @code{gptr() < egptr ()}, then @code{gptr()}
|
|
returns a pointer to the current get position.
|
|
(In that case the next read will read @code{*gptr()},
|
|
and possibly increment @code{gptr()}.)
|
|
Otherwise, there is no read position available
|
|
(and the next read will cause @code{streambuf::underflow}
|
|
to be called).
|
|
@end deftypefn
|
|
|
|
@deftypefn Method void streambuf:gbump (int @var{N})
|
|
Add @var{N} to the current get pointer.
|
|
No error checking is done.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method void streambuf::setg (char* @var{B}, char* @var{P}, char* @var{E})
|
|
Sets the start of the get area to @var{B}, the end of the get area to @var{E},
|
|
and the current put pointer to @var{P}.
|
|
@end deftypefn
|
|
|
|
@node Overflow
|
|
@section Simple output re-direction by redefining @code{overflow}
|
|
|
|
Suppose you have a function @code{write_to_window} that
|
|
writes characters to a @code{window} object. If you want to use the
|
|
ostream function to write to it, here is one (portable) way to do it.
|
|
This depends on the default buffering (if any).
|
|
|
|
@cartouche
|
|
@smallexample
|
|
#include <iostream.h>
|
|
/* Returns number of characters successfully written to @var{win}. */
|
|
extern int write_to_window (window* win, char* text, int length);
|
|
|
|
class windowbuf : public streambuf @{
|
|
window* win;
|
|
public:
|
|
windowbuf (window* w) @{ win = w; @}
|
|
int sync ();
|
|
int overflow (int ch);
|
|
// Defining xsputn is an optional optimization.
|
|
// (streamsize was recently added to ANSI C++, not portable yet.)
|
|
streamsize xsputn (char* text, streamsize n);
|
|
@};
|
|
|
|
int windowbuf::sync ()
|
|
@{ streamsize n = pptr () - pbase ();
|
|
return (n && write_to_window (win, pbase (), n) != n) ? EOF : 0;
|
|
@}
|
|
|
|
int windowbuf::overflow (int ch)
|
|
@{ streamsize n = pptr () - pbase ();
|
|
if (n && sync ())
|
|
return EOF;
|
|
if (ch != EOF)
|
|
@{
|
|
char cbuf[1];
|
|
cbuf[0] = ch;
|
|
if (write_to_window (win, cbuf, 1) != 1)
|
|
return EOF;
|
|
@}
|
|
pbump (-n); // Reset pptr().
|
|
return 0;
|
|
@}
|
|
|
|
streamsize windowbuf::xsputn (char* text, streamsize n)
|
|
@{ return sync () == EOF ? 0 : write_to_window (win, text, n); @}
|
|
|
|
int
|
|
main (int argc, char**argv)
|
|
@{
|
|
window *win = ...;
|
|
windowbuf wbuf(win);
|
|
ostream wstr(&wbuf);
|
|
wstr << "Hello world!\n";
|
|
@}
|
|
@end smallexample
|
|
@end cartouche
|
|
|
|
|
|
|
|
@node Formatting
|
|
@section C-style formatting for @code{streambuf} objects
|
|
|
|
The @sc{gnu} @code{streambuf} class supports @code{printf}-like
|
|
formatting and scanning.
|
|
|
|
@deftypefn Method int streambuf::form (const char *@var{format}, ...)
|
|
Similar to @code{fprintf(@var{file}, @var{format}, ...)}.
|
|
The @var{format} is a @code{printf}-style format control string, which is used
|
|
to format the (variable number of) arguments, printing the result on
|
|
the @code{this} streambuf. The result is the number of characters printed.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int streambuf::vform (const char *@var{format}, va_list @var{args})
|
|
Similar to @code{vfprintf(@var{file}, @var{format}, @var{args})}.
|
|
The @var{format} is a @code{printf}-style format control string, which is used
|
|
to format the argument list @var{args}, printing the result on
|
|
the @code{this} streambuf. The result is the number of characters printed.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int streambuf::scan (const char *@var{format}, ...)
|
|
Similar to @code{fscanf(@var{file}, @var{format}, ...)}.
|
|
The @var{format} is a @code{scanf}-style format control string, which is used
|
|
to read the (variable number of) arguments from the @code{this} streambuf.
|
|
The result is the number of items assigned, or @code{EOF} in case of
|
|
input failure before any conversion.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int streambuf::vscan (const char *@var{format}, va_list @var{args})
|
|
Like @code{streambuf::scan}, but takes a single @code{va_list} argument.
|
|
@end deftypefn
|
|
|
|
@node Stdiobuf
|
|
@section Wrappers for C @code{stdio}
|
|
|
|
A @dfn{stdiobuf} is a @code{streambuf} object that points to
|
|
a @code{FILE} object (as defined by @code{stdio.h}).
|
|
All @code{streambuf} operations on the @code{stdiobuf} are forwarded
|
|
to the @code{FILE}. Thus the @code{stdiobuf} object provides a
|
|
wrapper around a @code{FILE}, allowing use of @code{streambuf}
|
|
operations on a @code{FILE}. This can be useful when mixing
|
|
C code with C++ code.
|
|
|
|
The pre-defined streams @code{cin}, @code{cout}, and @code{cerr} are
|
|
normally implemented as @code{stdiobuf} objects that point to
|
|
respectively @code{stdin}, @code{stdout}, and @code{stderr}. This is
|
|
convenient, but it does cost some extra overhead.
|
|
|
|
If you set things up to use the implementation of @code{stdio} provided
|
|
with this library, then @code{cin}, @code{cout}, and @code{cerr} will be
|
|
set up to to use @code{stdiobuf} objects, since you get their benefits
|
|
for free. @xref{Stdio,,C Input and Output}.
|
|
|
|
@ignore
|
|
@c FIXME-future: setbuf is not yet documented, hence this para is not useful.
|
|
Note that if you use @code{setbuf} to give a buffer to a @code{stdiobuf},
|
|
that buffer will provide intermediate buffering in addition that
|
|
whatever is done by the @code{FILE}.
|
|
@end ignore
|
|
|
|
@node Procbuf
|
|
@section Reading/writing from/to a pipe
|
|
|
|
The @dfn{procbuf} class is a @sc{gnu} extension. It is derived from
|
|
@code{streambuf}. A @code{procbuf} can be @dfn{closed} (in which case
|
|
it does nothing), or @dfn{open} (in which case it allows communicating
|
|
through a pipe with some other program).
|
|
|
|
@deftypefn Constructor {} procbuf::procbuf ()
|
|
Creates a @code{procbuf} in a @dfn{closed} state.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method procbuf* procbuf::open (const char *@var{command}, int @var{mode})
|
|
Uses the shell (@file{/bin/sh}) to run a program specified by @var{command}.
|
|
|
|
If @var{mode} is @samp{ios::in}, standard output from the program is sent
|
|
to a pipe; you can read from the pipe by reading from the
|
|
@code{procbuf}. (This is similar to @w{@samp{popen(@var{command}, "r")}}.)
|
|
|
|
If @var{mode} is @samp{ios::out}, output written written to the
|
|
@code{procbuf} is written to a pipe; the program is set up to read its
|
|
standard input from (the other end of) the pipe. (This is similar to
|
|
@w{@samp{popen(@var{command}, "w")}}.)
|
|
|
|
The @code{procbuf} must start out in the @dfn{closed} state.
|
|
Returns @samp{*this} on success, and @samp{NULL} on failure.
|
|
@end deftypefn
|
|
|
|
@deftypefn Constructor {} procbuf::procbuf (const char *@var{command}, int @var{mode})
|
|
Calls @samp{procbuf::open (@var{command}, @var{mode})}.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method procbuf* procbuf::close ()
|
|
Waits for the program to finish executing,
|
|
and then cleans up the resources used.
|
|
Returns @samp{*this} on success, and @samp{NULL} on failure.
|
|
@end deftypefn
|
|
|
|
@deftypefn Destructor {} procbuf::~procbuf ()
|
|
Calls @samp{procbuf::close}.
|
|
@end deftypefn
|
|
|
|
@node Backing Up
|
|
@section Backing up
|
|
|
|
The @sc{gnu} iostream library allows you to ask a @code{streambuf} to
|
|
remember the current position. This allows you to go back to this
|
|
position later, after reading further. You can back up arbitrary
|
|
amounts, even on unbuffered files or multiple buffers' worth, as long as
|
|
you tell the library in advance. This unbounded backup is very useful
|
|
for scanning and parsing applications. This example shows a typical
|
|
scenario:
|
|
|
|
@cartouche
|
|
@smallexample
|
|
// Read either "dog", "hound", or "hounddog".
|
|
// If "dog" is found, return 1.
|
|
// If "hound" is found, return 2.
|
|
// If "hounddog" is found, return 3.
|
|
// If none of these are found, return -1.
|
|
int my_scan(streambuf* sb)
|
|
@{
|
|
streammarker fence(sb);
|
|
char buffer[20];
|
|
// Try reading "hounddog":
|
|
if (sb->sgetn(buffer, 8) == 8
|
|
&& strncmp(buffer, "hounddog", 8) == 0)
|
|
return 3;
|
|
// No, no "hounddog": Back up to 'fence'
|
|
sb->seekmark(fence); //
|
|
// ... and try reading "dog":
|
|
if (sb->sgetn(buffer, 3) == 3
|
|
&& strncmp(buffer, "dog", 3) == 0)
|
|
return 1;
|
|
// No, no "dog" either: Back up to 'fence'
|
|
sb->seekmark(fence); //
|
|
// ... and try reading "hound":
|
|
if (sb->sgetn(buffer, 5) == 5
|
|
&& strncmp(buffer, "hound", 5) == 0)
|
|
return 2;
|
|
// No, no "hound" either: Back up and signal failure.
|
|
sb->seekmark(fence); // Backup to 'fence'
|
|
return -1;
|
|
@}
|
|
@end smallexample
|
|
@end cartouche
|
|
|
|
@deftypefn Constructor {} streammarker::streammarker (streambuf* @var{sbuf})
|
|
Create a @code{streammarker} associated with @var{sbuf}
|
|
that remembers the current position of the get pointer.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int streammarker::delta (streammarker& @var{mark2})
|
|
Return the difference between the get positions corresponding
|
|
to @code{*this} and @var{mark2} (which must point into the same
|
|
@code{streambuffer} as @code{this}).
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int streammarker::delta ()
|
|
Return the position relative to the streambuffer's current get position.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method int streambuf::seekmark (streammarker& @var{mark})
|
|
Move the get pointer to where it (logically) was when @var{mark}
|
|
was constructed.
|
|
@end deftypefn
|
|
|
|
@node Indirectbuf
|
|
@section Forwarding I/O activity
|
|
|
|
An @dfn{indirectbuf} is one that forwards all of its I/O requests
|
|
to another streambuf.
|
|
|
|
@ignore
|
|
@c FIXME-future: get_stream and put_stream are so far undocumented.
|
|
All get-related requests are sent to get_stream().
|
|
All put-related requests are sent to put_stream().
|
|
@end ignore
|
|
|
|
An @code{indirectbuf} can be used to implement Common Lisp
|
|
synonym-streams and two-way-streams:
|
|
|
|
@example
|
|
class synonymbuf : public indirectbuf @{
|
|
Symbol *sym;
|
|
synonymbuf(Symbol *s) @{ sym = s; @}
|
|
virtual streambuf *lookup_stream(int mode) @{
|
|
return coerce_to_streambuf(lookup_value(sym)); @}
|
|
@};
|
|
@end example
|
|
|
|
@node Stdio
|
|
@chapter C Input and Output
|
|
|
|
@code{libio} is distributed with a complete implementation of the ANSI C
|
|
@code{stdio} facility. It is implemented using @code{streambuf}
|
|
objects. @xref{Stdiobuf,,Wrappers for C @code{stdio}}.
|
|
|
|
The @code{stdio} package is intended as a replacement for the whatever
|
|
@code{stdio} is in your C library.
|
|
@ignore
|
|
@c FIXME-future: This is not useful unless we specify what problems.
|
|
It can co-exist with C libraries that have alternate implementations of
|
|
stdio, but there may be some problems.
|
|
@end ignore
|
|
Since @code{stdio} works best when you build @code{libc} to contain it, and
|
|
that may be inconvenient, it is not installed by default.
|
|
|
|
Extensions beyond @sc{ansi}:
|
|
|
|
@itemize @bullet
|
|
@item
|
|
A stdio @code{FILE} is identical to a streambuf.
|
|
Hence there is no need to worry about synchronizing C and C++
|
|
input/output---they are by definition always synchronized.
|
|
|
|
@item
|
|
If you create a new streambuf sub-class (in C++), you can use it as a
|
|
@code{FILE} from C. Thus the system is extensible using the standard
|
|
@code{streambuf} protocol.
|
|
|
|
@item
|
|
You can arbitrarily mix reading and writing, without having to seek
|
|
in between.
|
|
|
|
@item
|
|
Unbounded @code{ungetc()} buffer.
|
|
@end itemize
|
|
|
|
@ignore
|
|
@c FIXME-future: Per says this is not ready to go public at v0.5
|
|
@node Libio buffer management
|
|
@chapter Libio buffer management
|
|
|
|
The libio user functions present an abstract sequence of characters,
|
|
that they read and write from. A number of buffers are used to go
|
|
between the user program and the abstract sequence. These buffers are
|
|
concrete arrays of characters that contain some sub-sequence of the
|
|
abstract sequence.
|
|
|
|
The libio buffer management protocol is fairly complex. Its design is
|
|
based on the C++ @code{streambuf} protocol, so that the C++
|
|
@code{streambuf} classes can be trivially implemented on top of the
|
|
libio protocol.
|
|
|
|
The @dfn{write area} contains characters waiting for output.
|
|
|
|
The @dfn{read area} contains characters available for reading.
|
|
|
|
The @dfn{reserve area} is available to virtual methods.
|
|
Usually, the get and/or put areas are part of the reserve area.
|
|
|
|
The @dfn{main get area} contains characters that have
|
|
been read in from the character source, but not yet
|
|
read by the application.
|
|
|
|
The @dfn{backup area} contains previously read data that is being saved
|
|
because of a user request, or that have been "unread" (put back).
|
|
@end ignore
|
|
|
|
@ignore
|
|
@c Per says this design is not finished
|
|
@node Streambuf internals
|
|
@chapter Streambuf internals
|
|
|
|
@menu
|
|
* Buffer management::
|
|
* Filebuf internals::
|
|
@end menu
|
|
|
|
@node Buffer management
|
|
@section Buffer management
|
|
|
|
@subsection Areas
|
|
|
|
NOTE: This chapter is due for an update.
|
|
|
|
Streambuf buffer management is fairly sophisticated (this is a
|
|
nice way to say "complicated"). The standard protocol
|
|
has the following "areas":
|
|
|
|
@itemize @bullet
|
|
@cindex put area
|
|
@item
|
|
The @dfn{put area} contains characters waiting for output.
|
|
@cindex get area
|
|
@item
|
|
The @dfn{get area} contains characters available for reading.
|
|
@cindex reserve area
|
|
@item
|
|
The @dfn{reserve area} is available to virtual methods.
|
|
Usually, the get and/or put areas are part of the reserve area.
|
|
@end itemize
|
|
|
|
The @sc{gnu} @code{streambuf} design extends this by supporting two
|
|
get areas:
|
|
@itemize @bullet
|
|
@cindex main get area
|
|
@item
|
|
The @dfn{main get area} contains characters that have
|
|
been read in from the character source, but not yet
|
|
read by the application.
|
|
@cindex backup area
|
|
@item
|
|
The @dfn{backup area} contains previously read data that is being
|
|
saved because of a user request, or that have been "unread" (putback).
|
|
@end itemize
|
|
|
|
The backup and the main get area are logically contiguous: That is,
|
|
the first character of the main get area follows the last character
|
|
of the backup area.
|
|
|
|
The @dfn{current get area} is whichever one of the backup or
|
|
main get areas that is currently being read from.
|
|
The other of the two is the @dfn{non-current get area}.
|
|
|
|
@subsection Pointers
|
|
|
|
The following @code{char*} pointers define the various areas.
|
|
|
|
@deftypefn Method char* streambuf::base ()
|
|
The start of the reserve area.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method char* streambuf::ebuf ()
|
|
The end of the reserve area.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method char* streambuf::Gbase ()
|
|
The start of the main get area.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method char* streambuf::eGptr ()
|
|
The end of the main get area.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method char* streambuf::Bbase ()
|
|
The start of the backup area.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method char* streambuf::Bptr ()
|
|
The start of the used part of the backup area.
|
|
The area (@code{Bptr()} .. @code{eBptr()}) contains data that has been
|
|
pushed back, while (@code{Bbase()} .. @code{eBptr()}) contains unused
|
|
space available for future putbacks.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method char* streambuf::eBptr ()
|
|
The end of the backup area.
|
|
@end deftypefn
|
|
|
|
@deftypefn Method char* streambuf::Nbase ()
|
|
The start of the non-current get area (either @code{main_gbase} or @code{backup_gbase}).
|
|
@end deftypefn
|
|
|
|
@deftypefn Method char* streambuf::eNptr ()
|
|
The end of the non-current get area.
|
|
@end deftypefn
|
|
|
|
@node Filebuf internals
|
|
@section Filebuf internals
|
|
|
|
The @code{filebuf} is used a lot, so it is importamt that it be
|
|
efficient. It is also supports rather complex semantics.
|
|
so let us examine its implementation.
|
|
|
|
@subsection Tied read and write pointers
|
|
|
|
The streambuf model allows completely independent read and write pointers.
|
|
However, a @code{filebuf} has only a single logical pointer used
|
|
for both reads and writes. Since the @code{streambuf} protocol
|
|
uses @code{gptr()} for reading and @code{pptr()} for writing,
|
|
we map the logical file pointer into either @code{gptr()} or @code{pptr()}
|
|
at different times.
|
|
|
|
@itemize @bullet
|
|
@item
|
|
Reading is allowed when @code{gptr() < egptr()}, which we call get mode.
|
|
|
|
@item
|
|
Writing is allowed when @code{pptr() < epptr()}, which we call put mode.
|
|
@end itemize
|
|
|
|
@noindent
|
|
A @code{filebuf} cannot be in get mode and put mode at the same time.
|
|
|
|
We have up to two buffers:
|
|
|
|
@itemize @bullet
|
|
@item
|
|
The backup area, defined by @code{Bbase()}, @code{Bptr()}, and @code{eBptr()}.
|
|
This can be empty.
|
|
|
|
@item
|
|
The reserve area, which also contains the main get area.
|
|
For an unbuffered file, the (@code{shortbuf()}..@code{shortbuf()+1}) is used,
|
|
where @code{shortbuf()} points to a 1-byte buffer that is part of
|
|
the @code{filebuf}.
|
|
@end itemize
|
|
|
|
@noindent
|
|
The file system's idea of the current position is @code{eGptr()}.
|
|
|
|
Characters that have been written into a buffer but not yet written
|
|
out (flushed) to the file systems are those between @code{pbase()}
|
|
and @code{pptr()}.
|
|
|
|
The end of the valid data bytes is:
|
|
@code{pptr() > eGptr() && pptr() < ebuf() ? pptr() : eGptr()}.
|
|
|
|
If the @code{filebuf} is unbuffered or line buffered,
|
|
the @code{eptr()} is @code{pbase()}. This forces a call
|
|
to @code{overflow()} on each put of a character.
|
|
The logical @code{epptr()} is @code{epptr() ? ebuf() : NULL}.
|
|
(If the buffer is read-only, set @code{pbase()}, @code{pptr()},
|
|
and @code{epptr()} to @code{NULL}. NOT!)
|
|
@end ignore
|
|
|
|
@node Index
|
|
@unnumbered Index
|
|
@printindex cp
|
|
|
|
@contents
|
|
@bye
|