Here is a complete guide on file handling in C++ for those of you who have problems in understanding

this concept.

Note: Dear Readers the given data has been taken from various books and therefore organised and
written in short para's as notes. It can be wrong at places so dont just read and learn. The data is for
basic concepts. While using this resource, have a book of c++ with you also. Recommended Book: E
BALAGURUSAMY

File I/O with Streams:

Many real-life problems handle large volumes of data, therefore we need to use some devices such as
floppy disk or hard disk to store the data.

The data is stored in these devices using the concept of files. A file is a collection of related data stored
in a particular area on the disk.

Programs can be designed to perform the read and write operations on these files.

A program typically involves either or both of the following kinds of data communication:
Data transfer between the console unit and the program.
Data transfer between the program and a disk file.
The input/output system of C++ handles file operations which are very much similar to the console input
and output operations.

It uses file streams as an interface between the programs and the files.

The stream that supplies data to the program is known as input stream and the one that receives data
from the program is known as output stream.

In other words, the input stream extracts or reads data from the file and the output stream inserts or
writes data to the file.

Classes for the file stream operations :

The I/O system of C++ contains a set of classes that define the file handling methods.

These include ifstream, ofstream and fstream.

These classes, designed to manage the disk files, are declared in fstream.h and therefore we must
include this file in any program that uses files.
Details of some useful classes :
filebuf
Its purpose is to set the file buffer to read and write. Contains openprot constant used in the open() of
the filestream classes. Also contains close() and open() as member functions.

fstreambase
Provides operations common to the file streams. Serves as a base for fstream, ifstream and ofstream
classes. Contains open() and close() functions.

ifstream
Provides input operations. Contains open() with default input mode. Inherits the functions get(),
getline(), read(), seekg() and tellg() functions from istream.

ofstream
Provides output operations. Contains open() with default output mode. Inherits put(), seekp(), tellp(),
and write() functions from ostream.

fstream
Provides support for simultaneous input and output operations. Contains open() with default input
mode. Inherits all the functions from istream and ostream classes through iostream.

The ifstream, ofstream and fstream classes are declared in the file fstream.h
The istream and ostream classes are also included in the fstream.h file.
Opening and closing a file :
For opening a file, we must first create a file stream and than link it to the filename.

A filestream can be defined using the classes ifstream, ofstream, and fstream that are contained in the
header file fstream.h

A file can be opened in two ways:

Using the constructor function of the class. This method is useful when we open only one file in the
stream.

Using the member function open() of the class. This method is used when we want to manage multiple
files using one stream.

Using Constructor
Create a file stream object to manage the stream using the appropriate class. That is, the class ofstream
is used to create the output stream and the class ifstream to create the input stream.

Initialize the file object with the desired filename, e.g.:

ofstream outfile(“sample.txt”);

The above statement creates an object outfile of class ofstream that manages the output stream. This
statement also opens the file sample.txt and attaches it to the output stream for writing.

Similarly, the statement declared in as an ifstream object and attaches to the file “sample.txt” for
reading.

ifstream infile(“sample.txt”);

Program: Writing and reading data into file, using constructors

# include
void main()
{
ofstream outfile(“sample.txt”); // create file for output
char ch = ‘a’;
int i = 12;
float f = 4356.15;
char arr[ ] = “hello”;
outfile << ch << endl <<< endl << f << endl << arr; //send the data to file
outfile.close();
ifstream infile(“sample.txt”);

infile >> ch >> i >> f >> arr; // read data from file

cout << ch << i << f << arr; // send data to screen

}

To write data into the file, character by character.

#include
#include
void main()
{
char str[]=“C++ is superset of C. It is an object-oriented /
programming language.”;

ofstream outfile(“sample2.txt”); // Open the file in write mode

for(int i = 0; i < strlen(str); i++)

outfile.put(str[i]); // write data into the file, character by character.
}

Writing and reading Objects of a class :

So far we have done I/O of basic data types. Since the class objects are the central elements of C++
programming, it is quite natural that the language supports features for writing and reading from the
disk files objects directly.

The binary input and output functions read() and write() are designed to do exactly this job.

The write() function is used to write the object of a class into the specified file and read() function is used
to read the object of the class from the file.

Both these functions take two arguments:

1. address of object to be written.
2. size of the object.

The address of the object must be cast to the type pointer to char.

One important point to remember is that only data members are written to the disk file and the member
functions are not.

Writing an object into the file

#include
class Person
{
private:
char name[40];
int age;
public:
void getData()
{
cout << “\n Enter name:”; cin >> name;
cout << “\n Enter age:”; cin >> age;
}
} ; // End of the class definition

void main()
{
Person per ; // Define an object of Person class

per.getData(); // Enter the values to the data members of the class.

ofstream outfile(“Person.txt”); // Open the file in output mode

outfile.write((char*)&per, sizeof(per)); // Write the object into the file

}

fstream object can be used for both input & output.

In the open() function we include several mode bits to specify certain aspects of the file object.

app -> To preserve whatever was in the file before. Whatever we write to the file will be appended to the
existing contents.

We use in and out because we want to perform both input and output on the file.

eof() is a member function of ios class. It returns a nonzero value if EOF is encountered and a zero
otherwise.
Parameters of open() function

Parameter Meaning
ios::app Append to end of the file
ios::ate Go to end of the file on opening
ios::in Open file for reading only
ios::nocreate Open fails if the file does not exist
ios::noreplace Open fails if the file already exists
ios::out Open file for writing only
ios::trunc Delete contents of the file if it exists

File pointers and their manipulations:

Each file has two associated pointers known as the file pointers.

One of them is called the input pointer or get pointer.

Other is called the output pointer or put pointer.

We can use these pointers to move through the files while reading or writing.

The input pointer is used for reading the contents of a given file location and the output pointer is used
for writing to a given file location.

Functions for manipulation of file pointers

seekg() Moves get pointer (input) to a specified location.
seekp() Moves put pointer (output) to a specified location.
tellg() Gives the current position of the get pointer.
tellp() Gives the current position of the put pointer.

infile.seekg(10);
Moves the file pointer to the byte number 10.

The bytes in a file are numbered beginning from zero.

Thus, the pointer will be pointing to the 11th byte in the file.
Specifying the offset :
The seek functions seekg() and seekp() can also be used with two arguments as follows:
seekg(offset, refposition);
seekp(offset, refposition);
The parameter offset represents the number of bytes the file pointer to be moved from the location
specified by the parameter refposition.
The refposition takes one of the following these constant defined in the ios class.
ios::beg start of the file
ios::cur current position of the pointer
ios::end end of the file.

This program counts the number of objects already written into the file “Person.txt”. Then is reads the
second object and displays the values of its data members.

class person
{
private:
char name[40];
int age;
public:
void showData()
{
cout << “\n Name = “ << name;
cout << “\n Age = “ << age;
}
};

void main()
{
person pers; // create person object
ifstream infile; // create input file
infile.open(“Person.txt”); // open the file
infile.seekg(0, ios::end); // go to end from 0 byte
int endposition = infile.tellg(); // find where we are
int n = endposition/sizeof(person); // number of persons
cout << “\n There are “ << n << “ persons in file: “;
cout << “\n Enter person number: “;
cin >> n;
int position = (n-1) * sizeof(person); // number times size
infile.seekg(position);
infile.read( (char*)&pers, sizeof(pers) );
pers.showData(); // display the person
}