Object Oriented Programming

File Handling in C++

 What is a File?
• Combination of characters, words, sentences
and paragraph are called as file.
• Two Types of files
– Text File (readable English characters)
– Executable program file (Dos Command)
 File Properties
• Name of the file
• Path of the file (Absolute & Relative)
• Length of the file
• Date of Creation
• File Access
 Why do we need files?
• Information of the computer is volatile
• Execute the program and the data is saved on
the hard disk.
• e.g Payroll system for SEECS Employees
• Store information once and reuse it
• Read/write/manipulate the data is File
handling
 File Handling

• Two ways to Access the Files

– Sequential Access File
– Random Access File
 Text File Handling
• Basic steps for File handling

– Open the file

– Read and Write
– Close the File
 Cont…
• Previously we worked with “cin” and “cout”.
• Concept of Streams
• During File Handling a header file called
“<fstream.h>” is to be included.
• <fstream.h> is a header file for file streams.
 Read and Write file
• When we read the file, it means that file is
used as an input for the program.
• We need to have a stream for input file
• ifstream ( input file stream)
• In order to read and write from the same file ,
ofstream.

8
 Declaring File Stream (Step 1)

ifstream inFile; //object for reading from file

ofstream outFile; //object for writing into file

NOTE:
The variable/ objects inFile and outFile are used as
“handle to refer” files.
 Cont…..(Step 2)
• So far we didn’t attach the file with a handle.
– ifstream myFile;
• We must open a file.
• For this we will use a function “Open”.
– myFile.open(Filename);
Note: Absolute / Relative Path for Filename
 Cont…..(Step 3)
• Tell the compiler what you want to do with
file i.e read, write or modify .
• Once the file is opened we can read it.
myFile>>c;

/* The first word of the file will be read in c,

where c is a character array, same as using
cin. */
 Cont…

myFile>>c1>>c2>>c3;

// The first word will be read in c1,2nd in c2, 3rd

in c3.
 Cont….(Step 4)
• File must be closed and it is the responsibility
of programmer to close the file.
• myFile.close();
• No argument in close function.
 Think…….

• What if the File that we are trying to open

does not exist on the disk?????????
 Error Checking Mechanism

• It is very important
• ifstream myFile;
myFile.open(“mytext.txt”);

/*If this file does not exists on the disk, the variable
myFile will not be associated with any file. We must
make sure that the file opening process is
successful. */
 Cont…

If(!myFile)
{
cout<<“There is some error opening the
file”<<endl;
cout<<“ File cannot be opened”<<endl;
}
else
cout<<“File opened successfully”<<endl;
 Example:
#include <fstream.h>
void main()
{ char name[50];
char sal[10];
char dept[30];
ifstream inFile;
inFile.open("myfile.txt");
if(!inFile)
{
cout<<"Can’t open input file"<<endl;
}
while(!inFile.eof())
{
inFile>>name>>sal>>dept;
cout<<name<<"\t“<<sal<<“\t”<<dept<<endl;
}
inFile.close();
} //end of main
 Output of the Program

Name Salary Department

Omer 20000 Exam
Ali 40000 Faculty
Rashid 60000 Faculty
 Output File Handling

• Creation of a new file on the disk and writing data in it.

or
• Open an existing file and overwrite it in such a manner that
all old information is lost from it and new information is
stored.
or
• Open an existing file and append it in the end
or
• Open an existing file and modify it from anywhere.
 Cont…
• We can use the previous options when
opening the file.

• open(filename,mode)

• The first argument is the name of the file,

second argument will the mode of the file.
 Cont…..
• Syntax
myFile.open(“myFile.txt”, ios::in);
or
myFile.open(“myFile.txt”);

/* The second argument associated myFile stream

object with “myFile.txt” for input. */
// There are different modes available
 File output: Appending
#include <fstream>
#include<iostream>

using namespace std;

void main()

{ cout<<"creating a file"<<endl;

ofstream afile("test1.dat");

cout<<"writing to file.."<<endl;

afile<<"these are test data";

} //end of file
 List of File Handling Modes

ios :: in open for reading (default for ifstream)

ios :: out open for writing (default for ofstream)
ios :: app start writing at end of file (APPend)
ios :: ate start reading or writing at EOF of file (ATEnd)
ios :: trunc truncate file to zero length if it exists (TRUNCate)
ios :: nocreate error when opening if file does not already exist
ios :: noreplace error when opening for output if file already exists
ios :: binary open file in binary (not text) mode
 Cont…
Mode Meaning

in Open a file/stream for extraction (input)

out Open a file/stream for insertion

(output)
App Append rather than truncate an existing file. Each
insertion (output) will be written to end of the file.
trunc Discard the file contents if exists (similar to default
behavior
ate Opens the file without truncating, but allows data to
be written anywhere in the file.
binary Treat the file as binary rather than text. A binary file
has data stored in internal formats, rather than
readable text. 24
 Important……

• If a file is opened with ios::out mode, a new

file is created. However if the file already
exists, its contents will be deleted and get
empty unless you write something to it.
 Example 2
main()
{
ofstream outFile;
outFile.open(“myFileOut.txt”,ios::out);
if(!outFile)
{
cout<<“ cannot open file”<<endl;
}

outFile.close();
}
 Try yourself…..

Write a program, which reads an input file of

employee’s i.e. employeein.txt”. Add the
salary of each employee by 200, and write the
result in new file “ employeeout.txt”??
 get( )
• “>>” sign is not enough
• get( ) function is used to get a character from the file.
• The last character in the file is EOF, defined in header file.
• E.g
char c;
while((c=inFile.get( ) !=EOF)
{
//do all the processing
outFile.put(c);
}
 Why get( )

• >> does not read the new line character

where as the get( ) function reads each
character as it is typed.

• If we need to make copy of the file then get( )

function must be used.
 put( )

• put( ) function writes a character including

new line feed to the file.
 Think…….

What if we want to write/read a whole

line to file instead of writing character or
words. After all the processing speed now
is day is quite high?
 getLine() Character array delimiter

myfile.getline (char *s, int n, char delim);

Numbers of
characters to

• Two functions be read

– getLine() for input file stream

– putLine() for output file stream

// char name[100];
int maxChar=100;
int stopchar=‘o’;
inFile.getLine(name,maxChar,stopchar);
 Try yourself…..

• Write a program which reads a file using the

getLine() function and display it on the
screen?
 fail()
• A call to open can be unsuccessful for a number of
reasons.
• A member function of ifstream and ofstream named
fail can be used to test whether or not a stream
operation has failed.
• It take no arguments and returns a bool.
• Syntax:
– in_stream.fail( );
 Cont…
Example:
in_stream.open(“stuff.dat”);
if (in_stream.fail())
{
cout<<“input file opening failed.\n”;
exit();

//to use this function include #include <cstdlib>

}
 isspace()
• The function isspace() returns true if its
argument is a whitespace character else
returns false.
• Whitespace are all the characters that are
displayed as blank space on the screen,
including the blank character, the tab character,
and the new-line character ’\n’.
 Example:
The following program will read the sentence terminate
with the period and echo the string with all whitespace
characters replace with the symbol “_”.

char next;
do{
cin.get(next);
if(isspace(next))
cout<<‘_’;
else
cout<<next;
} while (next !=‘.’);
 Try it yourself !!!!!!
Write a program that creates the output file
“myoutput.txt” that is identical to the file
“myoriginal.txt” except that all the
occurrences of ‘C’ are replace by “C++”.
 Random Access Files
• Discuss how to access the files randomly,
forward and backward.
• Current position inside the file.
• Concept of file position ( Pointer into the file)
• tellg( ) and tellp( )----functions for
determining the file pointer position.
 Position in a File
• Assume that a file stream myfile is opened for
reading .
• Myfile.tellg( ) gives us the current get position of the
file pointer.
• It returns a whole number of type long, which is the
position of the next character to be read from that
file.
• tellp() function is used to determine the next
position to write a character while writing into a file.
It also returns a long number.
 Setting the Position
• How to move forward and backward within the
file????
• seekg( ) and seekp( ) functions
• seekg( )--- takes us to certain position to start
reading.
• seekp( )---> leads the position to write into.
• Both functions require an argument of type long to
let them know the number of bytes to move forward
or backward. (positive and negative number)
 Setting the Position
Number of characters
Starting point
to move to

filePtr.seekg ( long Num , ios :: origin ) ;

seekg ( 10L , ios :: beg ) ;

seekg (10L , ios :: cur ) ;
seekg ( 10L , ios :: end ) ;
 Example:--)
• aFile.seekg(10L, ios::beg)
//move 10 bytes forward from the beginning of the file.
• aFile.seekg(20L, ios::cur)
// move 20 bytes in the forward direction starting from current
position (where current position can be obtained by using
tellg( ) function.
• aFile.seekg(-10L,ios::cur)
// move 10 bytes in the backward direction from the current
position
• aFile.seekg(-100, ios::end)
// move 100 bytes in backward direction from the end of the
file.
 Think and Apply…..

• Try to move the file pointer beyond the end of

the file and before the beginning of the file
and observe the behavior…….
 Example 1
#include<fstream.h>
main ( )
{
int length ;
ifstream inFile ( “myFile.txt” ) ;
inFile.seekg ( 0L , ios :: end ) ;
length = inFile.tellg ( ) ;
}
It will tell you Length of the file
 read ( ) and write ( )
Functions
Area in memory
Number of bytes to
be read

read ( char *buff , int count ) ;

Area in memory
Number of bytes to
be written

write ( char *buff , int count ) ;

 Example 3
char str [ 10000 ] ;
myInputFile.read ( str , 10000 ) ;
myOuputFile.write ( str , 10000 ) ;

1. Read 10000 bytes from the file into str

2. Write 10000 bytes to a file from str
 Example 2:
This program firstly writes a string into a file and then replaces it partially.

main()
{
long pos;
ofstream outfile;
outfile.open(“test.txt”);
outfile.write(“this is an apple”,16);
//write the string in the file
pos=outfile.tellp();
//get the file pointer position
outfile.seekp(pos-7);
// move 7 positions backward
outfile.close();
}
 Try it !!!!!!!! 
• Write a program that read the contents from
“myfile1.txt” and copies the contents in
reverse order in “outputfile.txt”……..

(Hint:---Make use of seekg function)

 HINTS:-)
afile.seekg(0L, ios::end);
afile.seekg(-1L, ios::end);
//set the position of the cursor to the last character of
the file
while(afile)
{
cout<<afile.tellg()<<endl;
afile.get(c);
Ofile.put(c);
afile.seekg(-2L,ios::cur);
//set the position of the cursor to the one
character before the current position
}
 fstream

fstream myFile ( “Sample.txt” , ios :: in

| ios :: out ) ;
 Example:- Try to understand by yourself
fstream rfile;
main()
{
char rchar;
rfile.open(“myfile.txt”,ios::in||ios::out)
if(!rfile)
{ cout<<“error opening file”;}
for(rchar=‘A’;rchar<=‘Z’;rchar++)
{ rfile<<rchar; }
rfile.seekg(8L, ios::beg);
rfile>>rchar;
cout<<“the 8th char is”<<rchar;
rfile.seekg(-16L, ios::end);
rfile>>rchar;
cout<<“ the 16th character from the end”<<rchar;
rfile.close();
}
 reinterpret_cast
• Unfortunately, most pointers that we pass to function write
as the first argument are not of type const char *
• To output objects of other types, we must convert the
pointers to those objects to type const char *
• C++ provides the reinterpret_cast operator for cases like this
in which a pointer of one type must be cast to an unrelated
pointer type
– You can also use this cast operator to convert
between pointer and integer types, and vice versa

CPS235: FilesAndStreams 53
 reinterpret_cast
• A reinterpret_cast is performed at compile time and does not
change the value of the object to which its operand points
– Instead, it requests that the compiler reinterpret
the operand as the target type (specified in the
angle brackets following the keyword
reinterpret_cast).
• Here we are using a reinterpret case to convert an int* (the
type of the expression &num) to a const char*
• The same conversion would have to be done in case of the
read() function of the istream class

CPS235: FilesAndStreams 54
 Writing Bytes with ostream Member
Function write()
• To write an int variable num to the file, use:
outFile.write( reinterpret_cast< const char *
>(&num ), sizeof( num) );
OR
• outFile.write((char *)&num , sizeof( num) );
• This writes the binary version of the number’s 4 bytes
• Function write treats its first argument as a group of bytes by
viewing the object in memory as a const char*, which is a pointer
to a byte (remember that a char is one byte)
• Starting from that location, function write outputs the number of
bytes specified by its second argument, an integer of type size_t

CPS235: FilesAndStreams 55
int main() {
ifstream inCredit( "credit.dat", ios::in );

// exit program if ifstream cannot open file

if ( !inCredit ) {
cout << "File could not be opened." << endl;
exit( 1 );
} // end if

cout << "Account" << "Last Name“ << "First Name”<< "Balance
<< endl;

ClientData client; // create record

// read first record from file

inCredit.read( reinterpret_cast< char * >( &client ),
sizeof( ClientData ) );

56
 // read all records from file
while ( ! inCredit.eof() ) {
// display record
if ( client.getAccountNumber() != 0 )
outputLine( client );

// read next from file

inCredit.read( reinterpret_cast< char * >( &client ),
sizeof( ClientData ) );
} // end while

return 0;
} // end main

// display single record

void outputLine(const ClientData &record ) {
cout << record.getAccountNumber()
<< record.getLastName()
<< record.getFirstName()
<< record.getBalance() << endl;
} // end outputLine
57
Account Last Name First Name Balance
33 Dunn Stacey 314.33
37 Barker Doug 0.00
88 Smith Dave 258.34
96 Stone Sam 34.98

58