Programming Fundamental-1

Instructor Name: Muhammad Safyan

Lecture-File Handling
 Introduction
 Storage of data in variables and arrays is temporary.
 Files handling is one of the important feature, are
used for data persistence permanent retention of
large amounts of data.
 C++ programs have ability to create, update and
process data files.
 We will consider both sequential files and random-
access files
 We compare formatted-data file processing and raw-
data file processing.
 Introduction

 cin and cout are stream in C++by which data can enter
and come out.
 cin is used to enter the data
 cout is used to display the data on the screen.
 More streams are available for file handling
 For this, header file to be used is <fstream.h>
 These streams are used the way we have been employing
cin and cout but we can do more with these streams.
 Introduction

Files can be handled can have three options

1. Only read the file
 File is used as input for the program
 stream for input file i.e. ifstream (input file stream)
2. File is used as to write output for the program
 write into some file, ofstream (output file stream) can be
used.
3. We can read, write and manipulate the same file using
fstream.h
 Object for Reading and Writing Files
 First, we have to include the fstream.h in our programs
 After that Declare file streams
 cin and cout are predefined streams therefore we did not
declare these.
 We can declare file stream as:
 ifstream inFile; // object for reading from a file
 ofstream outFile; // object for writing to a file
variables inFile and outFile are used as handle to refer files
like internal variables which will be used to handle the files that are on
the disk
 Introduction
For example , payroll system
ifstream myFile;
We have to attach this variable.
Before attaching we have to open a file.
To open file, a function named ‘open’ to open a file.
myFile.open(filename);
New way of function calling using dot (.)
The argument for the open function filename is the name
of the file on the disk.
 Introduction

The data type of argument filename is character string, used

to give the file name in double quotation marks.
 myFile.open(“payroll.txt”);
 myFile.open “D:/payroll.txt”);
 Introduction

 Once the file is open, we can read it.

 The access mechanism is same, as we have been using with
streams. So to read a word from the file we can write as:
 myFile >> c;
 First word of the file will be read in c, where c is a character
array similar as we used with cin.
 There are certain limitations to this read just one word at
one time. It means, on encountering a space, it will stop
reading further. Therefore, we have to use it repeatedly to
read the complete file
 Introduction
 We can also read multiple words at a time as:
 myFile >> c1 >> c2 >> c3;
 The first word will be read in c1, 2 nd in c2 and 3 rd in c3.
 Before reading the file, we should know some information
regarding the structure of the file. If we have a file of an
employee, we should know that the first word is
employee’s name, 2nd word is salary etc, so that we can
read the first word in a string and 2nd word in an int
variable.
 Introduction
while handling files. Error checking is very important.
Suppose we have to open a text file myfile.txt from the
current directory, we will write as:
ifstream myFile;
myFile.open(“myfile.txt”);
if (!myFile)
{
cout << “There is some error opening file” << endl;
cout << “ File cannot be opened” << end;
exit(1);
}
else
cout << “ File opened successfully “ << end;
 Data in the File

Name Salary Department

Aamir 12000 Sales
Amara 15000 HR
Adnan 13000 IT
Afzal 11500 Marketing
 File Handling(Reading)-Example
#include <iostream.h>
#include <fstream.h>
main()
{
char name[50]; // used to read name of employee from file
char sal[10]; // used to read salary of employee from file

char dept[30]; // used to read dept of employee from file

ifstream inFile ; // Handle for the input file

char inputFileName[] = "myfile.txt”;
inFile.open(inputFileName); // Opening the file
 File Handling(Reading)-Example
// checking that file is successfully opened or not
if (!inFile)
{
cout << "Can't open input file named " <<
inputFileName << endl;
exit(1);
}
while (!inFile.eof())
{
inFile >> name >> sal >> dept;
cout << name << "\t" << sal << " \t" << dept << endl;
}
inFile.close();
}
 File Handling(output)-Example
 Output File Handling
 You can do several things with output files
 Creation of a new file on the disk
 writing data in it
 Open an existing file and overwrite (old information is
lost and new information is stored.)
 Open an existing file and append it in the end.
 An existing file can be opened and modified in
a way that it can be written anywhere in the file
 The actual syntax of open function is:
 open (filename, mode)
 myFile.open(“myfile.txt” , ios::in);
File Handling-Mode
 File Handling(output)-Example
This program writes into a txt file “myfileOut.txt” which contains the “Welcome to GCU”
#include <iostream.h>
#include <fstream.h>
main()
{
ofstream outFile; // Handle for the input file
char outputFileName[] = “ d:/myFileOut.txt"; // The file is created
char ouputText[100] = "Welcome to GCU"; // used to write into the file
outFile.open(outputFileName, ios::out); // Opening the file

// checking that file is successfully opened or not

if (!outFile)
{
cout << "Can't open input file named " << outputFileName << endl;
exit(1);
}
// Writing into the file
outFile << ouputText;
outFile.close();
}
 File Handling(Reading)

We have been using ‘>>’ sign for reading data from the file.
There are some other ways to read from the file.
 The get() function is used to get a character from the file,
so that we can use get() to read a character and put it in a
char variable.
 The last character in the file is EOF, defined in header
files
 When we are reading file using get() function the loop
will be as:
 File Handling(Reading)

char c;
while ( (c = inFile.get()) != EOF)
{
// do all the processing
outFile.put(c);
}
 File Handling(Reading)
main()
{
ifstream infile; // Handle for the input file
char outputFileName[]="d:/Dicitionary.txt"; // The file is created
infile.open(outputFileName,ios::in); // Opening the file
char c;
while((c=infile.get())!=EOF)
{
cout<<c;
}
infile.close();
getch();
}
 Copying a File (Reading and writing)
main()
{
ifstream infile; // Handle for the input file
ofstream outfile;
char inputFileName[]="d:/Dicitionary.txt";
char outputFileName[]="d:/abc.txt";
infile.open(inputFileName,ios::in);
outfile.open(outputFileName,ios::out); // Opening the file
char c;
while((c=infile.get())!=EOF)
outfile<<c;
infile.close();
outfile.close();
getch();
 File Reading line by line
 We can initialize the file directly
ifstream inFile(“myFileIn.txt”);
ofstream outFile(“myfileOut.txt”, ios::out);
 We can also read a line from the file. The benefit of reading
a line is efficiency, but clarity should not be sacrificed over
efficiency.
 File Reading line by line

Computer accessories are much slower than processor i.e.

GHz. Therefore reading a single character from the file is too
slow.
Buffering and other techniques are used to make the disk
access faster. It will be quite efficient if we read the data in
bigger chunks
 File Handling
Instead of reading and writing character-by-character or
word-by-word, reading and writing line by line is efficient.
A function is available for this purpose i.e. getLine() for
input file stream and putLine() for output file stream. The
syntax of getLine() is as follows:
char name[100];
int maxChar = 100;
int stopChar = ‘o’;
inFile.getLine(name, maxChar, stopChar);
 File Handling
 first argument is a character array the array should be large
enough to hold the complete line.
 second argument is the maximum number of characters to be
read.
 third one is the character if we want to stop somewhere.
 Suppose we have an input file containing the line ‘Hello
World’, then the statements:
char str[20];
inFile.getLine(str, 20, ‘W’);
cout << “The line read from the input file till W is ” << str;
 File Handling

 Using the getLine() repeatedly to read the file is much

more efficient rather than using the get() function.
 As the getLine() function does not read the new line
character, we have to put it explicitly.
 File Handling

Write a program which reads a file using the getLine()

function and display it on the screen.
 File Handling
Write a program which reads a file using the getLine() function and display it on the
screen.
main()
{
ifstream inFile; // Handle for the input file
char inputFileName[] = "test.txt"; // file name, this file is in the current directory
const int MAX_CHAR_TO_READ = 100; // maximum character to read in one line
char completeLineText[MAX_CHAR_TO_READ]; // to be used in getLine function

inFile.open(inputFileName); // Opening the file

// Reading the complete file line by line and printing on screen

while (!inFile.eof())
{
inFile.getline(completeLineText, MAX_CHAR_TO_READ);
cout << completeLineText << endl;
}
inFile.close();
}
File Handling
 File Handling
 File contains Name of the employee and salary of current
month.
 There is a single space between the name and the salary.
 Calculate the total salaries of the employees. Create an
output file and write the total salary in that file.
 We can read a line from the input file using the getLine()
function.
 Need to break this line into pieces and get the name and
salary in different variables.
string token function i.e. strtok().
 File Handling
The string token function (strtok()) takes a string and a
delimiter i.e. the character that separates tokens from each
other.
There is a space between the name and the salary,
space can be used character as delimiter.
So the first call to the string token function will return the
name and subsequent string token can be get as
strtok(NULL," ");
 File Handling
#include<iostream.h> sal=atoi(tokenptr);
#include<conio.h> totalsal+=sal;
#include<fstream.h> }
main() outfile<<"The total salary = "<<totalsal;
{ infile.close();
ifstream infile; outfile.close();
ofstream outfile; getch();
infile.open("d:/salin.txt", ios::in); }
outfile.open("d:/salout.txt", ios::out);
int sal, totalsal;
sal=0;
totalsal=0;
char *tokenptr;
char completelinetext[100];
while(!infile.eof())
{
infile.getline(completelinetext,100);
tokenptr=strtok(completelinetext," ");

tokenptr=strtok(NULL," ");
 File Handling
Write a program, which reads an input file of employee’s i.e. “employeein.txt”, add
the salary of each employee by 2000, and write the result in a new file
“employeeout.txt”.
#include<iostream.h>
#include<conio.h>
#include<fstream.h>
main()
{
ifstream infile;
ofstream outfile;
infile.open("d:/salin.txt", ios::in);
outfile.open("d:/salout.txt", ios::out);
int sal, totalsal;
sal=0;
totalsal=0;
char *tokenptr;
char completelinetext[100];
while(!infile.eof())
{
infile.getline(completelinetext,100);
tokenptr=strtok(completelinetext," ");
outfile<<tokenptr<<" ";
tokenptr=strtok(NULL," ");

sal=atoi(tokenptr)+2000;
outfile<<sal<<endl;
}
infile.close();
 Exercise Problem

Write a program, which reads an input file. The structure of

the input file is First Name, Middle Initial, Last Name. Create
an output file with the structure First Name, Login Name,
Password. First name is same as in the input file. The login
name is middle initial and last name together. The password
is the first four digits of the first name. First name, middle
initial and last name does not contain space.
#include<iostream.h> while(!infile.eof())
#include<conio.h> {
#include<fstream.h> infile.getline(completelinetext,200);
#include<string.h> tokenptr=strtok(completelinetext," ");
using std::string; outfile<<tokenptr<<" ";
//using std::namespace; c=tokenptr;
main() psw=c.substr(0,4);
{ tokenptr=strtok(NULL," ");
ifstream infile; middle=tokenptr;
ofstream outfile; tokenptr=strtok(NULL," ");
infile.open("d:/userfile.txt", ios::in); last=middle+tokenptr;
outfile.open("d:/logfile.txt", ios::out); outfile<<last<<" ";
char *tokenptr; outfile<<psw<<endl;
string psw; }
string c; infile.close();
string middle; outfile.close();
string last; getch();
}
char completelinetext[200];
 Writing data into Files

 ifstream (Input File Stream), a simple provision of the

filename is sufficient enough, as the default mode is
for reading or input.
 ofstream (Output File Stream), we have several
alternatives.
 If we open a file for writing, there is default mode
available to destroy (delete) the previous contents of
the file,
 Random Access Files
 To moving forward or backward within a file, you
must know the current position inside the file.
 For this there is concept of file position (or position inside
a file) i.e. a pointer into the file.
 While reading from and writing into a file, we should
be very clear from where (which location inside the file)
our process of reading or writing will start.
 To determine this file pointer position inside a file, we
have two functions
 tellg() and tellp().
 Position in a File

 Let’s say we have a stream myfile for reading

 myfile.tellg () gives us the current get position of the file
pointer.
 It returns a whole long type number , tellong, which is the
position of the next character to be read from that file.

 Similarly, tellp () function is used to determine the next

position to write a character while writing into a file. It also
returns a long number.
 Position in a File
ofstream outfile;
outfile.open ("d:/abc.txt");
outfile.write ("This is an apple",16);
pos = outfile.tellp();
cout<<pos;

Setting the Position

seekg () and seekp () functions : to set the cursor position in a
file
seekg () takes us to a certain position to start reading from
while seekp () leads to a position to write into.
requires an argument of type long to let them how many bytes to
move forward or backward.
 Moving in a File
Cursor can move from the
 beginning of a file,
 current position or
 end of the file,
 This move forward or backward operation, is always relative to
some position.
 From the end of the file, we can only move in the backward
direction.
 By using positive value, we tell these functions to move in the
forward direction
 By using negative value, we tell these functions to move in the
backward direction
.
 Moving in a File

aFile. seekg (10L, ios::beg)

Similarly, by writing:
aFile. seekg (20L, ios::cur)
 We are moving 20 bytes in the forward direction starting
from the current position.
 Remember, the current position can be obtained using the
tellg () function.
 Moving in a File

By writing:

aFile. seekg (-10L, ios:cur)

 The file pointer will move 10 bytes in the backward
direction from the current position.
 With seekg (-100L, ios::end), we are moving in the
backward direction by 100 bytes starting from the end of
the file.
 Moving in a File

#include<iostream.h>
#include<conio.h>
#include<fstream.h>
main()
{
long pos;
ifstream infile;
infile.open ("d:/salin.txt");
infile.seekg(-20, ios::end);
char c;
while((c=infile.get())!=EOF)
cout<<c;
infile.close();
getch();
}
 Moving in a File

 seekg() and tellg() Functions

 One other use is to determine the length of the file. Think
about it, how can we do it.
.

 Adding the record at end
#include<iostream.h> cin>>name;
#include<conio.h> cout<<"enter sal"<<endl;;
#include<fstream.h> cin>>salary;
#include<string.h> ofstream outfile;
using namespace::std; outfile.open("d:/salin.txt", ios::app);
main()
{ outfile.seekp(0,ios::end);
char name[100]; outfile<<endl<<name<<" "<<salary;
char name1[100]; getch();
int salary; }
long pos; ;
string c;
string n;
int recno=0;
cout<<"enter name"<<endl;
 Searching Record from file
#include<iostream.h> cin>>n;
#include<conio.h> fstream infile;
#include<fstream.h> infile.open("d:/salin.txt");
#include<string.h> while(!infile.eof())
using namespace::std; {
main() infile.getline(name,100);
{ c=name;
char name[100]; recno+=1;
char name1[100]; if(c.find(n)==0)
long pos; {
string c; cout<<endl<<"record found at
string n; position="<<recno<<endl;
int recno=0; cout<<name;
cout<<"enter name"<<endl; }
}
getch();
}