THE IO LIBRARY in C++

For more Https://www.ThesisScientist.com
UNIT 11
THE IO LIBRARY
C++ has no built-in Input/Output (IO) capability. Instead, this capability is
provided by a library. The standard C++ IO library is called the iostream
library. The definition of the library classes is divided into three header files.
An additional header file defines a set of manipulators which act on streams.
These are summarized by Table 11.1.
Figure 11.1 relates these header files to a class hierarchy for a UNIX-
based implementation of the iostream class hierarchy. The highest-level classes
appear unshaded. A user of the iostream library typically works with these
classes only. Table 11.2 summarizes the role of these high-level classes. The
library also provides four predefined stream objects for the common use of
programs. These are summarized by Table 11.3.
Table 11.1 Iostream header files.
Header File Description
iostream.h Defines a hierarchy of classes for low-level (untyped character-
level) IO and high-level (typed) IO. This includes the definition of
the ios, istream, ostream, and iostream classes.
fstream.h Derives a set of classes from those defined in iostream.h for file
IO. This includes the definition of the ifstream, ofstream, and
fstream classes.
strstream.h Derives a set of classes from those defined in iostream.h for IO
with respect to character arrays. This includes the definition of the
istrstream, ostrstream, and strstream classes.
iomanip.h Defines a set of manipulator which operate on streams to produce
useful effects.
Table 11.2 Highest-level iostream classes.
Form of IO Input Output Input and Output
Standard IO istream ostream iostream
File IO ifstream ofstream fstream
Array of char IO istrstream ostrstream strstream
Table 11.3 Predefined streams.
Stream Type Buffered Description
cin istream Yes Connected to standard input (e.g., the keyboard)
cout ostream Yes Connected to standard output (e.g., the monitor)
clog ostream Yes Connected to standard error (e.g., the monitor)
cerr ostream No Connected to standard error (e.g., the monitor)

A stream may be used for input, output, or both. The act of reading data
from an input stream is called extraction. It is performed using the >>
operator (called the extraction operator) or an iostream member function.
Similarly, the act of writing data to an output stream is called insertion, and is
performed using the << operator (called the insertion operator) or an iostream
member function. We therefore speak of ‘extracting data from an input
stream’ and ‘inserting data into an output stream’.
Figure 11.1 Iostream class hierarchy.
iostream.h
fstream.h
strstream.h
v v v
v v
v
v
v
v
unsafe_ios
stream_MT
ios streambufunsafe_ostreamunsafe_istream
istream ostream
iostream
fstreambase unsafe_fstreambase
filebuf
ifstream ofstream
fstream
unsafe_strstreambase
strstreambuf
istrstream ostrstream
strstream
strstreambase
vmeans virtual base class

The Role of streambuf
The iostream library is based on a two layer model. The upper layer deals with
formatted IO of typed objects (built-in or user-defined). The lower layer deals
with unformatted IO of streams of characters, and is defined in terms of
streambuf objects (see Figure 11.2). All stream classes contain a pointer to a
streambuf object or one derived from it.
Figure 11.2 Two-layer IO model.
stream layer
streambuf layer
inserted object
output chars
extracted object
input chars
The streambuf layer provides buffering capability and hides the details of
physical IO device handling. Under normal circumstances, the user need not
worry about or directly work with streambuf objects. These are indirectly
employed by streams. However, a basic understanding of how a streambuf
operates makes it easier to understand some of the operations of streams.
Think of a streambuf as a sequence of characters which can grow or
shrink. Depending on the type of the stream, one or two pointers are
associated with this sequence (see Figure 11.3):
 A put pointer points to the position of the next character to be deposited
into the sequence as a result of an insertion.
 A get pointer points to the position of the next character to be fetched
from the sequence as a result of an extraction.
For example, ostream only has a put pointer, istream only has a get pointer,
and iostream has both pointers.
Figure 11.3 Streambuf put and get pointers.
...sequence
get pointer
put pointer
d a t a p r e s e n t

When a stream is created, a streambuf is associated with it. Therefore, the
stream classes provide constructors which take a streambuf* argument.

Stream Output with ostream
Ostream provides formatted output capability. Use of the insertion operator <<
for stream output was introduced in Chapter 1, and employed throughout this
book. The overloading of the insertion operator for user-defined types was
discussed in Chapter 7. This section looks at the ostream member functions.
The put member function provides a simple method of inserting a single
character into an output stream. For example, assuming that os is an ostream
object,
os.put('a');
inserts 'a' into os.
Similarly, write inserts a string of characters into an output stream. For
example,
os.write(str, 10);
inserts the first 10 characters from str into os.
An output stream can be flushed by invoking its flush member function.
Flushing causes any buffered data to be immediately sent to output:
os.flush(); // flushes the os buffer
The position of an output stream put pointer can be queried using tellp
and adjusted using seekp. For example,
os.seekp(os.tellp() + 10);
moves the put pointer 10 characters forward. An optional second argument to
seekp enables the position to be specified relatively rather than absolutely. For
example, the above is equivalent to:
os.seekp(10, ios::cur);
The second argument may be one of:
 ios::beg for positions relative to the beginning of the stream,
 ios::cur for positions relative to the current put pointer position, or
 ios::end for positions relative to the end of the stream.
These are defined as a public enumeration in the ios class.
Table 11.4 summarizes the ostream member functions. All output
functions with an ostream& return type, return the stream for which they are

invoked. Multiple calls to such functions can be concatenated (i.e., combined
into one statement). For example,
os.put('a').put('b');
is valid and is equivalent to:
os.put('a');
os.put('b');
Table 11.4 Member functions of ostream.
ostream (streambuf*);
The constructor associates a streambuf (or its derivation) with the class
to provide an output stream.
ostream& put (char);
Inserts a character into the stream.
ostream& write (const signed char*, int n);
ostream& write (const unsigned char*, int n);
Inserts n signed or unsigned characters into the stream.
ostream& flush ();
Flushes the stream.
long tellp ();
Returns the current stream put pointer position.
ostream& seekp (long, seek_dir = ios::beg);
Moves the put pointer to a character position in the stream relative to
the beginning, the current, or the end position:
enum seek_dir {beg, cur, end};

Using the ios Class
Ios provides capabilities common to both input and output streams. It uses a
streambuf for buffering of data and maintains operational information on the
state of the streambuf (i.e., IO errors). It also keeps formatting information for
the use of its client classes (e.g., istream and ostream).
The definition of ios contains a number of public enumerations whose
values are summarized by Table 11.5. The io_state values are used for the
state data member which is a bit vector of IO error flags. The formatting
flags are used for the x_flags data member (a bit vector). The open_mode
values are bit flags for specifying the opening mode of a stream. The
seek_dir values specify the seek direction for seekp and seekg.
Table 11.5 Useful public enumerations in ios.
enum io_state: Provides status flags (for ios::state).
ios::goodbit When state is set to this value, it means that all is ok.
ios::eofbit End-of-file has been reached.
ios::badbit An invalid operation has been attempted.
ios::failbit The last IO operation attempted has failed.
ios::hardfail An unrecoverable error has taken place.
Anonymous enum: Provides formatting flags.
ios::left Left-adjust the output.
ios::right Right-adjust the output.
ios::internal Output padding indicator.
ios::dec Convert to decimal.
ios::oct Convert to octal.
ios::hex Convert to hexadecimal.
ios::showbase Show the base on output.
ios::showpoint Show the decimal point on output.
ios::uppercase Use upper case for hexadecimal output.
ios::showpos Show the + symbol for positive integers.
ios::fixed Use the floating notation for reals.
ios::scientific Use the scientific notation for reals.
ios::skipws Skip blanks (white spaces) on input.
ios::unitbuf Flush all streams after insertion.
enum open_mode: Provides values for stream opening mode.
ios::in Stream open for input.
ios::out Stream open for output.
ios::app Append data to the end of the file.
ios::ate Upon opening the stream, seek to EOF.
ios::trunc Truncate existing file.
ios::noreplace Open should fail if file already exists.
ios::nocreate Open should fail if file does not already exist.
ios::binary Binary file (as opposed to default text file).
enum seek_dir: Provides values for relative seek.
ios::beg Seek relative to the beginning of the stream.

ios::cur Seek relative to the current put/get pointer position.
ios::end Seek relative to the end of the stream.
IO operations may result in IO errors, which can be checked for using a
number of ios member functions. For example, good returns nonzero if no
error has occurred:
if (s.good())
// all is ok...
where s is an iostream. Similarly, bad returns nonzero if an invalid IO
operation has been attempted:
if (s.bad())
// invalid IO operation...
and fail returns true if the last attempted IO operation has failed (or if bad()
is true):
if (s.fail())
// last IO operation failed...
A shorthand for this is provided, based on the overloading of the ! operator:
if (!s) // same as: if (s.fail())
// ...
The opposite shorthand is provided through the overloading of the void* so
that it returns zero when fail returns nonzero. This makes it possible to
check for errors in the following fashion:
if (cin >> str)
// no error occurred
The entire error bit vector can be obtained by calling rdstate, and
cleared by calling clear. User-defined IO operations can report errors by
calling setstate. For example,
s.setstate(ios::eofbit | ios::badbit);
sets the eofbit and badbit flags.
Ios also provides various formatting member functions. For example,
precision can be used to change the precision for displaying floating point
numbers:
cout.precision(4);
cout << 233.123456789 << 'n';
This will produce the output:
233.1235

The width member function is used to specify the minimum width of the next
output object. For example,
cout.width(5);
cout << 10 << 'n';
will use exactly 5 character to display 10:
10
An object requiring more than the specified width will not be restricted to it.
Also, the specified width applies only to the next object to be output. By
default, spaces are used to pad the object up to the specified minimum size.
The padding character can be changed using fill. For example,
cout.width(5);
cout.fill('*');
cout << 10 << 'n';
will produce:
***10
The formatting flags listed in Table 11.5 can be manipulated using the
setf member function. For example,
cout.setf(ios::scientific);
cout << 3.14 << 'n';
will display:
3.14e+00
Another version of setf takes a second argument which specifies formatting
flags which need to be reset beforehand. The second argument is typically one
of:
ios::basefield  ios::dec | ios::oct | ios::hex
ios::adjustfield  ios::left | ios::right | ios::internal
ios::floatfield  ios::scientific | ios::fixed
For example,
cout.setf(ios::hex | ios::uppercase, ios::basefield);
cout << 123456 << 'n';
will display:

Stream Manipulators
A manipulator is an identifier that can be inserted into an output stream or
extracted from an input stream in order to produce a desired effect. For
example, endl is a commonly-used manipulator which inserts a newline into
an output stream and flushes it. Therefore,
cout << 10 << endl;
has the same effect as:
cout << 10 << 'n';
In general, most formatting operations are more easily expressed using
manipulators than using setf. For example,
cout << oct << 10 << endl;
is an easier way of saying:
cout.setf(ios::oct, ios::basefield);
cout << 10 << endl;
Some manipulators also take parameters. For example, the setw
manipulator is used to set the field width of the next IO object:
cout << setw(8) << 10; // sets the width of 10 to 8 characters
Table 11.6 summarizes the predefined manipulators of the iostream
library.
Table 11.6 Predefined manipulators.
Manipulator Stream Type Description
endl output Inserts a newline character and flushes the stream.
ends output Inserts a null-terminating character.
flush output Flushes the output stream.
dec input/output Sets the conversion base to decimal.
hex input/output Sets the conversion base to hexadecimal.
oct input/output Sets the conversion base to octal.
ws input Extracts blanks (white space) characters.
setbase(int) input/output Sets the conversion base to one of 8, 10, or 16.
resetiosflags(long) input/output Clears the status flags denoted by the argument.
setiosflags(long) input/output Sets the status flags denoted by the argument.
setfill(int) input/output Sets the padding character to the argument.
setprecision(int) input/output Sets the floating-point precision to the argument.
setw(int) input/output Sets the field width to the argument.

File IO with fstreams
A program which performs IO with respect to an external file should include
the header file fstream.h. Because the classes defined in this file are derived
from iostream classes, fstream.h also includes iostream.h.
A file can be opened for output by creating an ofstream object and
specifying the file name and mode as arguments to the constructor. For
example,
ofstream log("log.dat", ios::out);
opens a file named log.dat for output (see Table 11.5 for a list of the open
mode values) and connects it to the ofstream log. It is also possible to create
an ofstream object first and then connect the file later by calling open:
ofstream log;
log.open("log.dat", ios::out);
Because ofstream is derived from ostream, all the public member
functions of the latter can also be invoked for ofstream objects. First, however,
we should check that the file is opened as expected:
if (!log)
cerr << "can't open 'log.dat'n";
else {
char *str = "A piece of text";
log.write(str, strlen(str));
log << endl;
}
The external file connected to an ostream can be closed and disconnected
by calling close:
log.close();
A file can be opened for input by creating an ifstream object. For example,
ifstream inf("names.dat", ios::in);
opens the file names.dat for input and connects it to the ifstream inf.
Because ifstream is derived from istream, all the public member functions of
the latter can also be invoked for ifstream objects.
The fstream class is derived from iostream and can be used for opening a
file for input as well as output. For example:
fstream iof;

iof.open("names.dat", ios::out); // output
iof << "Adamn";
iof.close();
char name[64];
iof.open("names.dat", ios::in); // input
iof >> name;
iof.close();
Table 11.7 summarizes the member functions of ofstream, istream, and
fstream (in addition to those inherited from their base classes).
Table 11.7 Member functions of ofstream, ifstream, and fstream.
ofstream (void);
ofstream (int fd);
ofstream (int fd, char* buf, int size);
ofstream (const char*, int=ios::out, int=filebuf::openprot);
The first version makes an ofstream which is not attached to a file. The
second version makes an ofstream and connects it to an open file
descriptor. The third version does the same but also uses a user-
specified buffer of a given size. The last version makes an ofstream and
opens and connects a specified file to it for writing.
ifstream (void);
ifstream (int fd);
ifstream (int fd, char* buf, int size);
ifstream (const char*, int=ios::in, int=filebuf::openprot);
Similar to ofstream constructors.
fstream (void);
fstream (int fd);
fstream (int fd, char* buf, int size);
fstream (const char*, int, int=filebuf::openprot);
Similar to ofstream constructors.
void open (const char*, int, int = filebuf::openprot);
Opens a file for an ofstream, ifstream, or fstream.
void close (void);
Closes the associated filebuf and file.
void attach(int);
Connects to an open file descriptor.
void setbuf(char*, int);
Assigns a user-specified buffer to the filebuf.
filebuf* rdbuf (void);
Returns the associated filebuf.

Array IO with strstreams
The classes defined in strstream.h support IO operations with respect to
arrays of characters. Insertion and extraction on such streams causes the data
to be moved into and out of its character array. Because these classes are
derived from iostream classes, this file also includes iostream.h.
The three highest-level array IO classes (ostrstream, istrstream, strstream)
are very similar to the file IO counterparts (ofstream, ifstream, fstream). As
before, they are derived from iostream classes and therefore inherit their
member functions.
An ostrstream object is used for output. It can be created with either a
dynamically-allocated internal buffer, or a user-specified buffer:
ostrstream odyn; // dynamic buffer
char buffer[1024];
ostrstream ssta(buffer, 1024); // user-specified buffer
The static version (ssta) is more appropriate for situations where the user is
certain of an upper bound on the stream buffer size. In the dynamic version,
the object is responsible for resizing the buffer as needed.
After all the insertions into an ostrstream have been completed, the user
can obtain a pointer to the stream buffer by calling str:
char *buf = odyn.str();
This freezes odyn (disabling all future insertions). If str is not called before
odyn goes out of scope, the class destructor will destroy the buffer. However,
when str is called, this responsibility rests with the user. Therefore, the user
should make sure that when buf is no longer needed it is deleted:
delete buf;
An istrstream object is used for input. Its definition requires a character
array to be provided as a source of input:
char data[128];
//...
istrstream istr(data, 128);
Alternatively, the user may choose not to specify the size of the character
array:
istrstream istr(data);
The advantage of the former is that extraction operations will not attempt to
go beyond the end of data array.

THE IO LIBRARY in C++

More Related Content

What's hot (20)

Similar to THE IO LIBRARY in C++ (20)

More from Prof Ansari (20)

Recently uploaded (20)

THE IO LIBRARY in C++