Unit 6

Working with files

6.1 Introduction

In C++ Programming we are using the iostream standard library, it provides cin and cout methods for reading from input and writing to output respectively.

To read and write from a file we are using the standard C++ library called fstream. Let us see the data types define in fstream library is:

C++ FileStream example: writing to a file

Let's see the simple example of writing to a text file testout.txt using C++ FileStream programming.

1. #include <iostream>  
2. #include <fstream>  
3. Using namespace std;  
4. Int main () {  
5.  Ofstream filestream("testout.txt");  
6.  If (filestream.is_open())  
7.  {  
8.    Filestream << "Welcome to javaTpoint.\n";  
9.    Filestream << "C++ Tutorial.\n";  
10.    Filestream.close();  
11.  }  
12.  Else cout <<"File opening is fail.";  
13.  Return 0;  
14. }  

Output:

The content of a text file testout.txt is set with the data:

Welcome to javaTpoint.

C++ Tutorial.

C++ FileStream example: reading from a file

Let's see the simple example of reading from a text file testout.txt using C++ FileStream programming.

1. #include <iostream>  
2. #include <fstream>  
3. Using namespace std;  
4. Int main () {  
5.  String srg;  
6.  Ifstream filestream("testout.txt");  
7.  If (filestream.is_open())  
8.  {  
9.    While ( getline (filestream,srg) )  
10.    {  
11.      Cout << srg <<endl;  
12.    }  
13.    Filestream.close();  
14.  }  
15.  Else {  
16.      Cout << "File opening is fail."<<endl;   
17.    }  
18.  Return 0;  
19. }  

Note: Before running the code a text file named as "testout.txt" is need to be created and the content of a text file is given below:
Welcome to javaTpoint.
C++ Tutorial.

Output:

Welcome to javaTpoint.

C++ Tutorial.

C++ Read and Write Example

Let's see the simple example of writing the data to a text file testout.txt and then reading the data from the file using C++ FileStream programming.

1. #include <fstream>  
2. #include <iostream>  
3. Using namespace std;  
4. Int main () {  
5.   Char input[75];  
6.   Ofstream os;  
7.   Os.open("testout.txt");  
8.   Cout <<"Writing to a text file:" << endl;  
9.   Cout << "Please Enter your name: ";   
10.   Cin.getline(input, 100);  
11.   Os << input << endl;  
12.   Cout << "Please Enter your age: ";   
13.   Cin >> input;  
14.   Cin.ignore();  
15.   Os << input << endl;  
16.   Os.close();  
17.   Ifstream is;   
18.   String line;  
19.   Is.open("testout.txt");   
20.   Cout << "Reading from a text file:" << endl;   
21.   While (getline (is,line))  
22.   {  
23.   Cout << line << endl;  
24.   }      
25.   Is.close();  
26.   Return 0;  
27. }  

Output:

Writing to a text file: 

Please Enter your name: Nakul Jain   

Please Enter your age: 22 

Reading from a text file:   Nakul Jain 

22

KEY TAKEAWAY

In C++ Programming we are using the iostream standard library, it provides cin and cout methods for reading from input and writing to output respectively.

To read and write from a file we are using the standard C++ library called fstream. Let us see the data types define in fstream library is:

6.2 Classes for file Stream Operations

In C++, files are mainly dealt by using three classes fstream, ifstream, ofstream available in fstream headerfile.
ofstream: Stream class to write on files
ifstream: Stream class to read from files
fstream: Stream class to both read and write from/to files.

 

Now the first step to open the particular file for read or write operation. We can open file by
1. Passing file name in constructor at the time of object creation
2. Using the open method
For e.g.

Open File by using constructor
ifstream (const char* filename, ios_base::openmode mode = ios_base::in);
ifstream fin(filename, openmode) by default openmode = ios::in
ifstream fin(“filename”);

Open File by using open method
Calling of default constructor
ifstream fin;

Fin.open(filename, openmode)
fin.open(“filename”);

Modes :

Default Open Modes :

Problem Statement : To read and write a File in C++.
Examples:

Input :

Welcome in GeeksforGeeks. Best way to learn things.

-1

Output :

Welcome in GeeksforGeeks. Best way to learn things.

Below is the implementation by using ifsream & ofstream classes.

Below is the implementation by using fstream class.

KEY TAKEAWAY

In C++, files are mainly dealt by using three classes fstream, ifstream, ofstream available in fstream headerfile.
ofstream: Stream class to write on files
ifstream: Stream class to read from files
fstream: Stream class to both read and write from/to files.
 

6.3 Opening and closing files

So far, we have been using the iostream standard library, which provides cin and cout methods for reading from standard input and writing to standard output respectively.

This tutorial will teach you how to read and write from a file. This requires another standard C++ library called fstream, which defines three new data types −

To perform file processing in C++, header files <iostream> and <fstream> must be included in your C++ source file.

Opening a File

A file must be opened before you can read from it or write to it. Either ofstream or fstream object may be used to open a file for writing. And ifstream object is used to open a file for reading purpose only.

Following is the standard syntax for open() function, which is a member of fstream, ifstream, and ofstream objects.

Void open(const char *filename, ios::openmode mode);

Here, the first argument specifies the name and location of the file to be opened and the second argument of the open() member function defines the mode in which the file should be opened.

You can combine two or more of these values by ORing them together. For example if you want to open a file in write mode and want to truncate it in case that already exists, following will be the syntax −

Ofstream outfile;

Outfile.open("file.dat", ios::out | ios::trunc );

Similar way, you can open a file for reading and writing purpose as follows −

Fstream  afile;

Afile.open("file.dat", ios::out | ios::in );

Closing a File

When a C++ program terminates it automatically flushes all the streams, release all the allocated memory and close all the opened files. But it is always a good practice that a programmer should close all the opened files before program termination.

Following is the standard syntax for close() function, which is a member of fstream, ifstream, and ofstream objects.

Void close();

KEY TAKEAWAY

We have been using the iostream standard library, which provides cin and cout methods for reading from standard input and writing to standard output respectively.

6.4 Detecting End Of_File (EOF)

Description

It is used to check whether eofbit is set. This flag is set by all standard input operations when the End-of-File is reached in the sequence associated with the stream.

Declaration

Following is the declaration for eof() const function.

Bool eof() const;

Parameters

None

Return Value

True if the stream's eofbit error state flag is set (which signals that the End-of-File has been reached by the last input operation).

False otherwise.

Exceptions

Strong guarantee − if an exception is thrown, there are no changes in the stream.

Data Races

Accesses the stream object.

Concurrent access to the same stream object may cause data races.

Example

In below example explains about eof() const.

#include <iostream>    

#include <fstream>     

Int main () {

Std::ifstream is("example.txt");  

Char c;

While (is.get(c))                 

Std::cout << c;

If (is.eof())                     

Std::cout << "[EoF reached]\n";

Else

Std::cout << "[error reading]\n";

Is.close();                       

Return 0;

}

KEY TAKEAWAY

Description

It is used to check whether eofbit is set. This flag is set by all standard input operations when the End-of-File is reached in the sequence associated with the stream.

6.5 Modes of File Opening

This table shows the different modes in C++ that are possible when opening a file. However, you need to answer three basic questions every time you open a file:

• Do you want to read from the file or write to the file? Use ifstream to read and ofstream for writing. If you intend to both write to and read from the same file, use the fstream and set mode to in|out, but good luck — it’s much better to write to a file completely and then close it and reopen it for reading as a separate object.
• If you are writing to the file and it already exists, do you want to add to the existing contents (in which case, open with ate set) or truncate the file and start over (in which case use trunc)?
• Are you reading or writing text or binary data? Both ifstream and ofstream default to text mode. Use binary mode if you are reading or writing raw, non-text data.

The primary difference between binary and text mode lies in the way that newlines are handled. The Unix operating system was written in the days when typewriters were still fashionable (when it was called “typing” instead of “keyboarding”). Unix ended sentences with a linefeed followed by a carriage return.

Subsequent operating systems saw no reason to continue using two characters to end a sentence, but they couldn’t agree on which character to use. Some use the carriage return, others used the linefeed, now renamed newline. The C++ standard is the single newline.

When a file is opened in text mode, the C++ library converts the single newline character into what is appropriate for your operating system on output, whether it’s a carriage return plus linefeed, a single carriage return, a linefeed, or something else entirely. It performs the opposite conversion while reading a file. The C++ library does no such conversions for a file opened in binary mode.

Always use binary mode when manipulating a file that’s not in human-readable format. Otherwise, if a byte in the data stream just happens to be the same as a carriage return or a linefeed, the file I/O library will modify it.

KEY TAKEAWAY

This table shows the different modes in C++ that are possible when opening a file. However, you need to answer three basic questions every time you open a file:

• Do you want to read from the file or write to the file? Use ifstream to read and ofstream for writing. If you intend to both write to and read from the same file, use the fstream and set mode to in|out, but good luck — it’s much better to write to a file completely and then close it and reopen it for reading as a separate object.
• If you are writing to the file and it already exists, do you want to add to the existing contents (in which case, open with ate set) or truncate the file and start over (in which case use trunc)?
• Are you reading or writing text or binary data? Both ifstream and ofstream default to text mode. Use binary mode if you are reading or writing raw, non-text data.

6.6 File pointers and manipulators

Function for manipulation of file pointer: – The C++ I/O system support for function for setting a file pointer to any desired position inside the file or to get the file pointer. These allow the programmer to have control over a pointer in the file where read or write operation text place. These for function are listed below.

The seekp() and tellp() are member function of ofstream. The seekg() or tellg() are member function of ifstream. The class fstream deals with file in both input and output modes. Hence, there are two file pointer in class fastream and the put pointer used for writing and get pointer used for the reading. Syntax of the seek function is –

<Stream Object>.seekg(long offset,seek_origin=ios::beg);

<Stream Object>.seekp(long offset,seek_origin=ios::beg

KEY TAKEAWAY

Function for manipulation of file pointer: – The C++ I/O system support for function for setting a file pointer to any desired position inside the file or to get the file pointer. These allow the programmer to have control over a pointer in the file where read or write operation text place.

6.7 Updating file

Given a binary file that contains the records of students, the task is to modify or alter the record of the specified student. If the record of no such student exists, then print “record not found”.

Examples:

Input:

Old roll no: 1

New roll no: 11

New name: "Geek"

Output:

Roll no: 11

Name: "Geek"

Record successfully modified

Input:

Old roll no: 234

New roll no: 14

New name: "Geek2"

Output:

Record not found

In this example, the existing roll number of the student whose record is to be modified is taken from the user and a newly updated record is created that replaces the previous record.

Approach:

• Step 1: Searching for the roll number in the binary file.
• Step 2: While searching in the file, the variable “pos” stores the position of file pointer record then traverse(continue) reading of the record.
• Step 3: If the roll number to be searched exists then place the write pointer (to ending of the previous record) i.e. at pos.
• Step 4: Call getdata function to take the new record.
• Step 5: Write the new object at the position “pos” and hence the record is updated and print “record successfully updated”.
• Step 6: If the roll number does not exists then print “record not found”.

Standard Library Functions used:

// tells the position of read pointer

FILE.TELLG();

// places the writing pointer at

// position "pos" in the file

File.seekp(POS);

Below is the implementation of the above approach:

KEY TAKEAWAY

Given a binary file that contains the records of students, the task is to modify or alter the record of the specified student. If the record of no such student exists, then print “record not found”.

Examples:

Input:

Old roll no: 1

New roll no: 11

New name: "Geek"

Output:

Roll no: 11

Name: "Geek"

Record successfully modified

Input:

Old roll no: 234

New roll no: 14

New name: "Geek2"

Output:

Record not found

In this example, the existing roll number of the student whose record is to be modified is taken from the user and a newly updated record is created that replaces the previous record.

6.8 Error handling during files operations

Sometimes during file operations, errors may also creep in. For example, a file being opened for reading might not exist. Or a file name used for a new file may already exist. Or an attempt could be made to read past the end-of-file. Or such as invalid operation may be performed. There might not be enough space in the disk for storing data.

To check for such errors and to ensure smooth processing, C++ file streams inherit 'stream-state' members from the ios class that store the information on the status of a file that is being currently used. The current state of the I/O system is held in an integer, in which the following flags are encoded :

C++ Error Handling Functions

There are several error handling functions supported by class ios that help you read and process the status recorded in a file stream.

Following table lists these error handling functions and their meaning :

The above functions can be summarized as eof() returns true if eofbit is set; bad() returns true if badbit is set. The fail() function returns true if failbit is set; the good() returns true there are no errors. Otherwise, they return false.

These functions may be used in the appropriate places in a program to locate the status of a file stream and thereby take the necessary corrective measures. For example :

:

Ifstream fin;

Fin.open("master", ios::in);

While(!fin.fail())

{

:        // process the file

}

If(fin.eof())

{

:         // terminate the program

}

Else if(fin.bad())

{

:         // report fatal error

}

Else

{

Fin.clear();     // clear error-state flags

:

}

:

C++ Error Handling Example

Here is an example program, illustrating error handling during file operations in a C++ program:

/* C++ Error Handling During File Operations

* This program demonstrates the concept of

* handling the errors during file operations

* in a C++ program */

#include<iostream.h>

#include<fstream.h>

#include<process.h>

#include<conio.h>

Void main()

{

Clrscr();

Char fname[20];

Cout<<"Enter file name: ";

Cin.getline(fname, 20);

Ifstream fin(fname, ios::in);

If(!fin)

{

Cout<<"Error in opening the file\n";

Cout<<"Press a key to exit...\n";

Getch();

Exit(1);

}

Int val1, val2;

Int res=0;

Char op;

Fin>>val1>>val2>>op;

Switch(op)

{

Case '+':

Res = val1 + val2;

Cout<<"\n"<<val1<<" + "<<val2<<" = "<<res;

Break;

Case '-':

Res = val1 - val2;

Cout<<"\n"<<val1<<" - "<<val2<<" = "<<res;

Break;

Case '*':

Res = val1 * val2;

Cout<<"\n"<<val1<<" * "<<val2<<" = "<<res;

Break;

Case '/':

If(val2==0)

{

Cout<<"\nDivide by Zero Error..!!\n";

Cout<<"\nPress any key to exit...\n";

Getch();

Exit(2);

}

Res = val1 / val2;

Cout<<"\n"<<val1<<" / "<<val2<<" = "<<res;

Break;

}

Fin.close();

Cout<<"\n\nPress any key to exit...\n";

Getch();

}

Let's suppose we have four files with the following names and data, shown in this table:

Now we are going to show the sample run of the above C++ program, on processing the files listed in the above table. Here are the four sample runs of the above C++ program, processing all the four files listed in the above table. Here is the sample output for the first file.

This output is for the second file

This is for the third file

This output produced, if the fourth file is processed.

KEY TAKEAWAY

Sometimes during file operations, errors may also creep in. For example, a file being opened for reading might not exist. Or a file name used for a new file may already exist. Or an attempt could be made to read past the end-of-file. Or such as invalid operation may be performed. There might not be enough space in the disk for storing data.

To check for such errors and to ensure smooth processing, C++ file streams inherit 'stream-state' members from the ios class that store the information on the status of a file that is being currently used. The current state of the I/O system is held in an integer, in which the following flags are encoded :

References:

1. E Balagurusamy, “Programming with C++”, Tata McGraw Hill, 3rd Edition.

2. Herbert Schildt, “The Complete Reference C++”, 4th Edition.

3. Robert Lafore, “Object Oriented Programming in C++”, Sams Publishing, 4th Edition.

4. Matt Weisfeld, “The Object-Oriented Thought Process”, Pearson Education.