Scribd
Upload
70 views5 pages

C++ File Handling and Stream Classes

C++

Uploaded by

chinmayhiremath5234
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
70 views5 pages

C++ File Handling and Stream Classes

C++

Uploaded by

chinmayhiremath5234
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd

Module-4

In C++ there are number of stream classes for defining various streams
related with files and for doing input-output operations. All these classes are
defined in the file iostream.h. Figure given below shows the hierarchy of
these classes
1.

ios class is topmost class in the stream classes hierarchy. It is the base class
for istream, ostream, and streambuf class.

2. istream and ostream serves the base classes for iostream class. The
class istream is used for input and ostream for the output.

3. Class ios is indirectly inherited to iostream class using istream and ostream. To
avoid the duplicity of data and member functions of ios class, it is declared as virtual
base class when inheriting in istream and ostream as

4. class istream: virtual public ios


5. {
6. };
7. class ostream: virtual public ios
8. {
9. };
acilities provided by these stream classes.
1. The ios class: The ios class is responsible for providing all input and output facilities
to all other stream classes.

2. The istream class: This class is responsible for handling input stream. It provides
number of function for handling chars, strings and objects such as get, getline, read,
ignore, putback etc..
The ostream class: This class is responsible for handling output stream. It provides
number of function for handling chars, strings and objects such as write, put etc..
3. The iostream: This class is responsible for handling both input and output
stream as both istream class and ostream class is inherited into it. It
provides function of both istream class and ostream class for handling
chars, strings and objects such as get, getline, read, ignore, putback,
put, write etc..
File stream
File handling is used to store data permanently in a computer. Using file
handling we can store our data in secondary memory (Hard disk).
How to achieve the File Handling
For achieving file handling we need to follow the following steps:-
STEP 1-Naming a file
STEP 2-Opening a file
STEP 3-Writing data into the file
STEP 4-Reading data from the file
STEP 5-Closing a file.

Streams in C++ :-

We give input to the executing program and the execution program gives back the output.
The sequence of bytes given as input to the executing program and the sequence of bytes
that comes as output from the executing program are called stream. In other words,
streams are nothing but the flow of data in a sequence.
The input and output operation between the executing program and the devices like
keyboard and monitor are known as “console I/O operation”. The input and output
operation between the executing program and files are known as “disk I/O operation”.

C++ Files
The fstream library allows us to work with files.

To use the fstream library, include both the


standard <iostream> AND the <fstream> header file:

#include <iostream>
#include <fstream>
There are three classes included in the fstream library, which are used to
create, write or read files:

Class Description

ofstream Creates and writes to files

ifstream Reads from files

fstream A combination of ofstream and ifstream: creates, reads, and writes to files

Create and Write To a File


To create a file, use either the ofstream or fstream class, and specify the name of
the file.

To write to the file, use the insertion operator (<<).

Read a File
To read from a file, use either the ifstream or fstream class, and the name of the file.

Binary Files with C++


The insertion and extraction operators (i.e. << and >> are meant to be used by
programs for writing to and reading from text files; it is assumed that the
programmer is familiar with the differences between these two file formats.
Basics of File I/O

Opening a Stream
The ifstream and ofstream each have member functions named open which are used to
attaching the stream to a physical filename and opening the file for either reading or
writing. The open member function also provides for a couple of optional arguments that are not
often described. The most general prototype of this function is

void open(const char *filename[, int mode][, int prot]);

Writing to a Binary File


I mentioned once that << is used to write data to a text file. If you had a
variable x that contained the value 354 and you used the statment outfile << x; this
would cause the character 3, the character 5, and the character 4 to be written (in
ASCII form) to the file. This is not binary form which would only require 16-bits.
The ofstream class provides a member function named write that allows for
information to be written in binary form to the stream. The prototype of
the write function is
ostream& write(void *buffer, streamsize n);

Reading from a Binary File


Reading data from a binary file is just like writing it except that the function is now
called read instead of write When reading data from a file there are a couple of new
things to watch out for:

 It is the responsibility of the programmer to make sure that the buffer is large
enough to hold all the data that is being read

File Pointer

The tellp() member function has a prototype of the form


streampos tellp();

This function accepts no parameters, but returns the location given in bytes from the
beginning of the file where the file pointer is currently sitting. The next read or write
will take place from this location.

The seekp() member function has a prototype of the form


void seekp(streampos location, int relative);

1. ios::beg This indicates that the location is the number of bytes from the
beginning of the file.
2. ios::cur This indicates that the location is the number of bytes from the current
file pointer location. This allows for a relative positioning of the file pointer.
3. ios::end This indicates that the location is the number of bytes from the end of
the file.

Writing Classes to Binary Files


The easiest way to store records in files is to use astruct If you are keeping track of
records in memory structures using classes, then saving these classes to disk takes
a little extra work.

Common questions

Powered by AI

The stream classes in C++ facilitate console and disk I/O operations by structuring data flow to and from devices or files. Console I/O operations, involving keyboards and monitors, are primarily handled by the istream and ostream classes, while disk I/O operations for files use fstream classes. These classes abstract data input and output as sequential streams, making the implementation of data flow in programs more manageable .

File positioning in C++ is managed using the seek functions available in ifstream and ofstream. The seekp() function is used to position the write file pointer, while seekg() positions the read pointer. These functions accept a position and an offset, allowing for positioning with respect to the beginning, current position, or end of the file using ios::beg, ios::cur, and ios::end respectively .

The ios class is declared as a virtual base class to avoid duplicity of data and member functions when it is inherited by both istream and ostream classes. This prevents multiple copies of the ios class being created in the iostream class hierarchy, which would create ambiguity and inefficiency .

Storing data from classes in binary format requires additional steps beyond just reading objects. Developers must manually manage the conversion of class objects to a buffer that can be written using the write function, as this approach directly handles bytes. Similarly, loading requires reading bytes into a buffer and converting them back to an object. This approach is suitable for directly storing complex data structures .

File pointers are crucial in handling file I/O operations as they determine the position in the file where reading or writing will occur. The tellp() function returns the current position of the file write pointer, and the seekp() function moves the file write pointer to a specified position. These positions can be set relative to the beginning of the file (ios::beg), the current position (ios::cur), or the end of the file (ios::end).

Writing to binary files in C++ involves using the ofstream class and its write member function. This function takes a buffer, which is a pointer to the data, and a streamsize indicating the number of bytes to be written. This allows data to be written in binary form rather than as ASCII characters. The programmer is responsible for ensuring the correct data type and the amount of data being written .

In C++, the ios class is at the top of the stream classes hierarchy and acts as the base class for istream, ostream, and streambuf classes. The istream and ostream classes, which handle input and output streams respectively, serve as base classes for the iostream class. The ios class is declared as a virtual base class to prevent duplicity when inherited by istream and ostream classes .

To perform basic file handling in C++, the following steps must be followed: 1. Name the file. 2. Open the file. 3. Write data to the file. 4. Read data from the file. 5. Close the file. These steps ensure data can be stored permanently and accessed using stream operations .

In C++, binary files differ from text files primarily in how data is written and read. For text files, the insertion (<<) operator is used to write data as ASCII characters. For example, if an integer 354 is written to a text file, it is stored as characters '3', '5', and '4'. However, writing the same data in binary form would require 16-bits, as binary files store data in binary format using the write function of the ofstream class, which writes raw bytes to the stream .

The fstream class in C++ provides a combination of functionalities from the ifstream and ofstream classes, allowing it to create, read, and write files. By including the <fstream> header file along with <iostream>, programmers can use fstream for versatile file operations in both text and binary formats .

You might also like