chapter-12-data-file-handling.pdf

Chapter 12- Data File Handling II PUC, MDRPUC, Hassan
1 | P a g e Keerthi Kumar H M
Chapter-12
DATA FILE HANDLING
 Introduction:
 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.
 In general a file is a sequence of bits, bytes, lines or records whose meaning is defined by its user.
 C++ I/O occurs in streams, which are sequence of bytes.
 If bytes flows from device like a keyboard, a disk drive, etc to main memory, this is called input
operation.
 If bytes flow from main memory to devices like a display screen, a printer etc. this is called output
operation.
 In C++, file input/output facilities are implemented through a header file fstream.h.
 Stream in C++:
 A stream is sequence of bytes. In C++, a stream is a general name given to flow of data.
 Different streams are used to represent different kinds of data flow.
 The three streams in C++ are as follows.
o Input Stream: The stream that supplies data to the program is known as input stream.
o Output Stream: The stream that receives data from the program is known as output
stream.
o Error Stream: Error streams basically an output stream used by the programs to the file or
on the monitor to report error messages.

 fstream.h header file:
 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 are derived from fstream base and from the corresponding iostream.h.
 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.
 Classes for file stream operation:
 Types of data Files:
 Generally there are two types of files in C++:
Class Meanings
filebuf It sets the file buffer to read and write
fstreambase
It supports operations common to the file streams. It serves as a base class for the
derived classes ifstream,ofstream and fstream and contains open( ) and close( )
as member functions
ifstream
It supports input operations. It contains open( ) with default input mode and
inherits get( ), getline( ), read( ), seekg( ) and tellg( ) functions from istream.
ofstream
It supports output operations. It contains open( ) with default output mode and
inherits put( ), seekp( ), tellp( ) and write( ) functions from ostream
fstream
It supports simultaneous input and output operations. It contains open( ) with
default input mode and inherits all the functions from istream and ostream
classes through iostream

 Text Files:
o A text file is a file that stores the information in ASCII characters.
o Each line of text is terminated by a special character, known as End of Line (EOL) or delimiter.
 Binary Files:
o A binary file is a file that contains information in the same format as it is held in memory.
o In binary files, no delimiters are used for a line and no translations occur here.
 Opening and Closing of Files:
 A file must first be opened before data can be read from it or written to it.
 In C++ there are two ways to open a file with the file stream object.
o Opening file using constructor.
o Opening file using open ( ) member function.
 The first method is preferred when a single file is used with a stream. However for managing
multiple files with the same stream, the second method is preferred.
 Opening files using Constructors:
 In order to access a file, it has to be opened either in read, write or append mode.
 In all the three file stream classes, a file can be opened by passing a filename as the first parameter
in the constructor itself.
 The syntax for opening a file using constructor is
streamclass_name file_objectname (“filename”)
 The syntax of opening a file for output purpose only using an object ofstream class and the
constructor is as follows:
ofstream ofstream_object(“file name”);
 Example: ofstream fout (“results.dat”);
 The syntax of opening a file for input purpose only using an object ifstream class and the
constructor is as follows:
ifstream ifstream_object(“file name”);
 Example: ifstream fin (“results.dat”);
 Opening files using open( ):
 open( ) can be used to open multiple files that use the same stream object.
 The syntax for opening a file using open ( ) member function is as follows:
file_stream_class stream_object;
stream_object.open (“file_name”);

 The syntax of opening a file for output purpose only using an object ofstream class and open( )
member function is as follows:
oftream_object.open(“file name”);
 Example: ofstream outfile;
outfile.open (“data”);
outfile.open (“text.dat”);
 The syntax of opening a file for input purpose only using an object ifstream class and open( )
member function is as follows:
iftream_object.open(“file name”);
 Example: ifstream ifile;
ifile.open (“data”);
 To open a file for both input and output, we declare objects of fstream class. We know that the
class fstream is derived from both ifstream and ofstream,
 The syntax for opening a file an object of type fstream class and the constructor is as follows:
fstream fstream-object(“file name’, mode);
 The syntax for opening a file an object of type fstream class and the open( ) member function is as
follows:
fstream-object.open(“file name’, mode);
 File Modes:
 While using constructors or open( ), the files were created or opened in the default mode.
 There was only one argument passed, i.e. the filename.
 C++ provides a mechanism of opening a file in different modes in which case the second
parameter must be explicitly passed.
 Syntax: stream_object.open(“filename”, mode);
 Example: fout.open(“data”, ios::app) // This opens the file data in the append mode.
 The lists of file modes are:
Mode method Meaning Stream Type
ios::app append to end of the file at opening time ofstream
ios::in open file for reading ifstream
ios::out open file for writing ofstream
ios::ate
Open file for updating and move the file
pointer to the end of file
ifstream
Important
3 Marks

Example:
fstreamfout (“text”, ios::out); // open text in output mode
fstream fin(“text”, ios::in); // open text in input mode
fout.open(“data”, ios::app) // This opens the file data in the append mode
fout.open(“data”, ios::app | ios::nocreate)
// This opens the file in the append mode but fails to open if it does not exist
 Closing File:
 The member function close( ) on its execution removes the linkage between the file and the stream
object.
 Syntax: stream_object.close( );
 Example: ofstream.close( );
ifstream.close( );
 Input and output operation in text file:
 The data in text files are organized into lines with new line character as terminator.
 Text file need following types of character input and output operations:
o put( ) function
o get( ) function
 put ( ):
 The put( ) member function belongs to the class ofstream and writes single character to the
associated stream.
 Syntax: ofstream_object.put(ch); // where ch is the character variable.
 Example: char ch=’A’;
ofstream fout(“text.txt”);
fout.put (ch);
 fout is the object of ofstream. Text is the name of the file. Value at ch is written to text.
 get( ):
 The get( ) member function belong to the class ifstream and reads a single character from the
associated stream.
ios::trunc On opening, delete the contents of file ofstream
ios::nocreate Turn down opening if the file does not exists ofstream
ios::noreplace Turn down opening if the file already exists ofstream
ios::binary Opening a binary file. ifstream
Important
3 Marks

 Syntax: ifstream_object.get (ch); // where ch is the character variable.
 Example: char ch;
ifstream fin(“text.txt”);
fin.get (ch);
 fin is the object of ifstream. Text is the name of the file. Reads a character into the variable ch.
 getline( ):
 It is used to read a whole line of text. It belongs to the class ifstream.
 Syntax: fin.getline(buffer, SIZE)
 It reads SIZE characters from the file represented by the object fin or till the new line character is
encountered, whichever comes first into the buffer.
 Example:
char book[SIZE];
ifstream fin;
fin.getline (book, SIZE);
 Input and output operation in binary files:
 Binary files are very much use when we have to deal with database consisting of records.
 The binary format is more accurate for storing the numbers as they are stored in the exact internal
representation.
 There is no conversion while saving the data and hence it is faster.
 Functions used to handle data in binary form are:
o write ( ) member function.
o read ( ) member function
 write ( ):
 The write ( ) member function belongs to the class ofstream and which is used to write binary data
to a file.
 Syntax: ofstream_object.write((char *) & variable, sizeof(variable));
 These functions take 2 arguments. The first is the address of the variable and second the size of the
variable in bytes. The address of the variable must be type casted to pointer to character.
 Example: student s;
ofstream fout(“std.dat”, ios::binary);
fout.write((char *) &s, sizeof(s));
Important
3 Marks

 read ( ):
 The read ( ) member function belongs to the class ifstream and which is used to read binary data
from a file.
 Syntax: ifstream_object.read((char *) & variable, sizeof(variable));
 These functions take 2 arguments. The first is the address of the variable and second the size of the
variable in bytes. The address of the variable must be type casted to pointer to character.
 Example: student s;
ifstream fin(“std.dat”, ios::binary)
fin.write((char *) &s, sizeof(s));
 Detecting End of file:
 Detecting end of file is necessary for preventing any further attempt to read data from the file.
 eof( ) is a member function of ios class.
 It returns a non-zero (true) value if the end of file condition is encountered while reading;
otherwise returns a zero (false).
 Example:
ifstream fin;
if(fin.eof( ))
{
statements;
}
 This is used to execute set statements on reaching the end of the file by the object fin.
 File pointers and their manipulation:
 In C++, the file I/O operations are associated with the two file pointers:
o Input pointer (get pointer)
o Output pointer (put pointer)
 We use these pointers to move through files while reading or writing.
 Each time an input or output operation takes place, appropriate pointer is automatically advanced.
o ifstream, like istream, has a pointer known as get pointer that points to the element to be read
in the next input operation.
o ofstream, like ostream, has a pointer known as put pointer that points to the location where the
next element has to be written.
 There are three modes under which we can open a file:
o Read only mode

o Write only mode
o Append mode
 When we open a file in read only mode, the input pointer is automatically set at the beginning so
that we read the file from the beginning.
 When we open a file in write only mode, the existing contents are deleted and output pointer is set
at the beginning
 If we want to open an existing file to add more data, the file is opened in append mode. This
moves the file pointer to the end of the file.
 Functions for manipulation of file pointers:
 To move file pointers to any desired position inside a file, file stream classes support the following
functions.
o seekg() - Moves get file pointer to a specific location
o seekp() - Moves put file pointer to a specific location
o tellg() - Returns the current position of the get pointer
o tellp() - Returns the current position of the put pointer
 The seekp() and tellp() are member functions of ofstream
 The seekg() and tellg() are member functions of ifstream.
 All four functions are available in the class fstream.
 seekg( ):
 Move the get pointer to a specified location from the beginning of a file.
 There are two types:
o seekg(long);
o seekg(offset, seekdir);
 The seekg(long) moves the get pointer to a specified location from the beginning of a file.
Important
3 Marks

 Example: inf.seekg(20);
 The seekg(offset, seekdir) has two arguments: offset and seekdir.
 The offset indicates the number of bytes the get pointer is to be moved from seekdir position.
 seekdir takes one of the following three seek direction constants.
Constant Meaning
ios::beg seek from beginning of file
ios::cur seek from current location
ios::end seek from end of file
 Syntax: stream_objectname.seekg(offset, origin_value);
 Example : Some of the pointer offset calls and their actions are shown in the following table
seekg( ) function option Action performed
object.seekg(0, ios::beg) Take get pointer to the beginning of the file
object.seekg(0, ios::end) Go to end of the file
object.seekg(0, ios::cur) Stay get pointer at the current position.
object.seekg(m, ios::beg) Move forward by (m+1) bytes in the file
object.seekg(-m, ios::end) Go backward by m bytes from the file end.
 seekp ( ):
 Move the put pointer to a specified location from the beginning of a file.
 There are two types:
o seekp(long);
o seekp(offset, seekdir);
 The seekp(long) moves the put pointer to a specified location from the beginning of a file.
 Example: inf.seekp(20);
 The seekp(offset, seekdir) has two arguments: offset and seekdir.
 The offset indicates the number of bytes the put pointer is to be moved from seekdir position.
 Syntax: stream_objectname.seekp(offset, origin_value);
seekp( ) function option Action performed
object.seekp(0, ios::beg) Go to beginning of the file for writing
object.seekp(0, ios::end) Go to end of the file for writing
object.seekp(0, ios::cur) Stay at the current position for writing

object.seekp(m, ios::beg) Move forward by m bytes from the beginning for writing
object.seekp(-m, ios::end) Go backward by m bytes from the end for writing
 tellg ( ) and tellp( ):
 tellg( ) returns the current position of the get pointer.
 Syntax: position = ifstream_object.tellg( );
 Example: int position
position= fin.tellg();
 tellp( ) returns the current position of the put pointer.
 Syntax: position = ifstream_object.tellp( );
 Example: int position
position= fin.tellp();
 Basic operation on binary file in C++:
 Basic operation on binary file is:
o Searching
o Appending data
o Inserting data in sorted files
o Deleting a record
o Modifying data
CHAPTER 12 – DATA FILE HANDLING BLUE PRINT
VSA (1 marks) SA (2 marks) LA (3 Marks) Essay (5 Marks) Total
- 01 Question 01 Question - 02 Question
- Question no 15 Question no 23 - 05 Marks
Important Questions
2 Marks Question:
1. Differentiate between ifstream and ofstream. [March 2015]
2. What is a stream? Mention any one stream used in C++. [June 2015]
3. Write any two member functions belonging to of stream class. [March 2016]
4. Write any two member functions belonging to if stream class. [June 2016]
5. Differentiate between read( ) and write( ). [March 2017]
6. Differentiate between put( ) and get( ) functions with reference to binary files. [June 2017]

3 Marks Question:
1. Give the function of put( ), get( ) and getline( ) with respect to text files. [March 2015]
2. List the fifferent modes of opening a file with their meaning in C++. [June 2015]
3. Give the functions for the following: [March 2016]
a. get( ) b. getline( ) c. read( )
4. Mention the types of data files. Explain. [June 2016]
5. Explain any three modes of to open a file in C++. [March 2017]
6. Write the member function belong to ifstream. [June 2017]
****************

chapter-12-data-file-handling.pdf

More Related Content

Similar to chapter-12-data-file-handling.pdf (20)

More from study material (20)

Recently uploaded (20)

chapter-12-data-file-handling.pdf