1. Data File Handling in C++
Paritosh Srivastava
PGT (Comp. Science)
Kendriya VidyalayaJoshimath

2. Topics - Agenda Introduction Opening & closing of files
Stream state member functions
File operations
Binary file operations
Random access file operations
CBSE Question Pattern from this topic
Conclusion
All rights reserved

3. Introduction
Computer programs are associated to work with files as it helps in storing data & information permanently.
File - itself a bunch of bytes stored on some storage devices.
In C++ this is achieved through a component header file called fstream.h
The I/O library manages two aspects- as interface and for transfer of data.
The library predefine a set of operations for all file related handling through certain classes.
All rights reserved

4. The fstream.h header file
Streams act as an interface between files and programs.
They represent as a sequence of bytes and deals with the flow of data.
Every stream is associated with a class having member functions and operations for a particular kind of data flow.
File  Program ( Input stream) - reads
Program  File (Output stream) – write
All designed into fstream.h and hence needs to be included in all file handling programs.
Diagrammatically as shown in next slide

5. DISK FILE PROGRAM All rights reserved Output Stream Input Stream
write data
to file
DISK FILE
read data
from file
Output Stream
Input Stream
data output
data input
PROGRAM
All rights reserved

6. File Handling Classes
Hierarchy Diagram

7. Why to use Files: Convenient way to deal large quantities of data.
Store data permanently (until file is deleted).
Avoid typing data into program multiple times.
Share data between programs.
We need to know:
how to "connect" file to program
how to tell the program to read data
how to tell the program to write data
error checking and handling EOF

8. // Initial experience reading and writing files
#include <fstream.h>
#include <iostream.h>
#include <stdlib.h>
int main()
{ ifstream in_stream;
ofstream out_stream;
int num;
in_stream.open("numbers.dat");
if (in_stream.fail()) { cout << "Input file could not be opened.\n";
exit(1); }
out_stream.open("squares.dat");
if (out_stream.fail()) { cout <<"Output file could not opened.\n";
in_stream >> num;
out_stream << "The square of " << num << " is " <<num * num;
in_stream.close();
out_stream.close(); }
All rights reserved

9. File Handling Classes
When working with files in C++, the following classes can be used:
ofstream – writing to a file
ifstream – reading for a file
fstream – reading / writing
What does it all have to do with cout?
When ever we include <iostream.h>, an ostream object, pointing to stdout is automatically defined – this object is cout.
ofstream inherits from the class ostream (standard output class).
ostream overloaded the operator >> for standard output.…thus an ofstream object can use methods and operators defined in ostream.

10. Opening & Closing a File
A file can be open by the method “open()” or immediately in the constructor (the natural and preferred way).
void ofstream / ifstream::open(const char* filename, int mode);
filename – file to open (full path or local)
mode – how to open (1 or more of following – using | )
ios::app – append
ios::ate – open with marker at the end of the file
ios::in / ios::out – (the defaults of ifstream and ofstream)
ios:nocreate / ios::noreplace – open only if the file exists / doesn’t exist
ios::trunc – open an empty file
ios::binary – open a binary file (default is textual)
Don’t forget to close the file using the method “close()”

11. 1: To access file handling routines:
#include <fstream.h>
2: To declare variables that can be used to access file:
ifstream in_stream;
ofstream out_stream;
3: To connect your program's variable (its internal name) to an external file (i.e., on the Unix file system):
in_stream.open("infile.dat");
out_stream.open("outfile.dat");
4: To see if the file opened successfully:
if (in_stream.fail())
{ cout << "Input file open failed\n";
exit(1); // requires <stdlib.h>}

12. in_stream >> num; [Compare: cin >> num;]
5: To get data from a file (one option), must declare a variable to hold the data and then read it using the extraction operator:
int num;
in_stream >> num;
[Compare: cin >> num;]
6: To put data into a file, use insertion operator:
out_stream << num;
[Compare: cout << num;]
NOTE: Streams are sequential – data is read and written in order – generally can't back up.
7: When done with the file:
in_stream.close();
out_stream.close();
All rights reserved

13. Stream state member functions
In C++, file stream classes inherit a stream state member from the ios class, which gives out the information regarding the status of the stream.
For e.g.:
eof() –used to check the end of file character
fail()- used to check the status of file at opening for I/O
bad()- used to check whether invalid file operations or unrecoverable error .
good()- used to check whether the previous file operation has been successful

14. File operations
The following member functions are used for reading and writing a character from a specified file.
get()- is used to read an alphanumeric character from a file.
put()- is used to write a character to a specified file or a specified output stream

15. Reading /Writing from/to Binary Files
To write n bytes:
write (const unsigned char* buffer, int n);
To read n bytes (to a pre-allocated buffer):
read (unsighed char* buffer, int num)
#include <fstream.h> main() { int array[] = {10,23,3,7,9,11,253}; ofstream OutBinaryFile("my_b_file.txt“, ios::out | ios::binary); OutBinaryFile.write((char*) array, sizeof(array));
OutBinaryFile.close(); }

16. CHARACTER I/O C++ has some low-level facilities for character I/O.
char next1, next2, next3;
cin.get(next1);
Gets the next character from the keyboard. Does not skip over blanks or newline (\n). Can check for newline (next == '\n')
Example:
cin.get(next2);
cin.get(next3);
Predefined character functions must #include <ctype.h> and can be used to
convert between upper and lower case
test whether in upper or lower case
test whether alphabetic character or digit
test for space
All rights reserved

17. //#include, prototypes, void main() omitted for space ifstream fin;
char Chem1, Chem2;
double ratio;
fin.open("input.dat"); // open error check omitted for space
fin.get(Chem1);
while (!fin.eof()) {
if (isdigit(Chem1))
cout << "Test Code: " << Chem1 << endl;
else
fin >> ratio;
fin.get(Chem2);
Chem2 = toupper(Chem2);
cout << "Ratio of " << Chem1 << " to " << Chem2 << " is " << ratio << endl; }
new_line(fin);
void new_line(istream& in)
char symbol;
do {
in.get(symbol);
} while (symbol != '\n');
All rights reserved

18. Reading /Writing from/to Textual Files
#include <fstream.h> main() { // Writing to file ofstream OutFile("my_file.txt"); OutFile<<"Hello "<<5<<endl; OutFile.close(); int number; char dummy[15];
// Reading from file ifstream InFile("my_file.txt"); InFile>>dummy>>number;
InFile.seekg(0); InFile.getline(dummy,sizeof(dummy)); InFile.close(); }
To write:
put() – writing single character
<< operator – writing an object
To read:
get() – reading a single character of a buffer
getline() – reading a single line
>> operator – reading a object

19. Binary file operations
In connection with a binary file, the file mode must contain the ios::binary mode along with other mode(s)
To read & write a or on to a binary file, as the case may be blocks of data are accessed through the use of C++ read() and write() respectively.
All rights reserved

20. Random access file operations
Every file maintains two internal pointers:
get_pointer and put_pointer
They enable to attain the random access in file otherwise which is sequential in nature.
In C++ randomness is achieved by manipulating certain functions
All rights reserved

21. Moving within the File
seekg() / seekp() – moving the reading (get) / writing (put) marker
two parameters: offset and anchor
tellg() / tellp() – getting the position of the reading (get) / writing (put) marker

22. EOF and File I/O Within Functions
When using a file within a function, the file parameter MUST BE a reference parameter:
int read_file(ifstream& infile);
As with keyboard input, it is often desirable to process some unknown amount of data. We use the end-of-file (EOF) to accomplish this. EOF is automatically included in text files we create.
Can test for EOF in several ways.
while (in_stream >> num) OR
in_stream >> num; // priming read
while (! in_stream.eof())
{loop body
in_stream >> num;}
All rights reserved

23. char file_name[20]; // cstring
int main() {
ofstream out_stream;
double d1, d2;
char file_name[20]; // cstring
cout << "Enter output file name: ";
cin >> file_name;
out_stream.open(file_name);
if (out_stream.fail())
cout << "Output file could not be opened.\n";
exit(1); }
out_stream.setf(ios::fixed);
out_stream.setf(ios::showpoint);
cout << "Enter two numbers: ";
cin >> d1 >> d2;
out_stream << setprecision(2) << setw(10) << d1 << setw(10) << d1 * d1 << endl;
out_stream << setprecision(2) << setw(10) << d2 <<setw (10) << d2 * d2 << endl;
out_stream.close();
All rights reserved

24. int side1, side2, side3, perimeter; double area; ifstream in_stream;
int main() {
int side1, side2, side3, perimeter;
double area;
ifstream in_stream;
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(2);
open_input_file(in_stream);
cout << setw(7) << "Side 1" << setw(7) << "Side 2" << setw(7) << "Side 3" << setw(7) << "Area" << setw(12) << "Perimeter\n";
in_stream >> side1;
while (! in_stream.eof()) // true AFTER attempt to read beyond eof
in_stream >> side2 >> side3;
compute(side1, side2, side3, perimeter, area);
cout << setw(5) << side1 << setw(7) << side2 <<setw(7) << side3 << setw(9) << area << setw(10) << perimeter << endl; }
in_stream.close();
All rights reserved

25. void open_input_file(ifstream& instream)
{ instream.open("lengths.dat");
if (instream.fail())
{ cout << "Input file could not be opened.\n";
exit(1); } }
void compute(int side1, int side2, int side3, int& perimeter, double& area)
{ double s;
perimeter = side1 + side2 + side3;
s = perimeter / 2.0;
area = sqrt (s * (s - side1) * (s - side2) * (s - side3));
All rights reserved

26. RELATED TO DATA FILE HANDLING
CBSE QUESTION PATTERN
RELATED TO
DATA FILE HANDLING ☼

27. Summary
Files in C++ are interpreted as a sequence of bytes stored on some storage media.
Bases classes are used to perform I/O operations.
The data of a file is stored in either readable form or in binary code called as text file or binary file.
The flow of data from any source to a sink is called as a stream.
All rights reserved

28. More Information on File I/O
When getting data from a file, there is no need to prompt for input.
One program may have multiple input and/or output files, and may intermix keyboard/ display I/O with file I/O.
The file name may be obtained from the user, rather than hard coded in the program.
The layout of a program's output is called the format. A variety of options are available for controlling the appearance of the output.
Flags to control floating point display:
out_stream.setf(ios::fixed);
out_stream.setf(ios::showpoint);
out_stream.precision(2);
rd_state() – returns a variable with one or more (check with AND) of the following options:
ios::goodbit – OK
ios::eofbit – marker on EOF
ios::failbit – illegal action, but alright to continue
ios:badbit – corrupted file, cannot be used.
We can also access the bit we wish to check with eof(), good(), fail(), bad(),
clear() is used to clear the status bits (after they were checked).
All rights reserved

29. Questions ? ?
All rights reserved

30. Thank You