File Handling in C++

File Handling in C++

File Handling concept in C++ language is used for store a data permanently in computer. Using file handling we can store our data in Secondary memory (Hard disk). In This article we discuss working of file handling in C++. Following pointers will be covered in the article,

• Opening a File
• Closing a File
• Functions use in File Handling
• File Opening mode

Why use File Handling in C++

• For permanet storage.
• The transfer of input - data or output - data from one computer to another can be easily done by using files.

For read and write from a file you need another standard C++ library called fstream, which defines three new data types:

How to achieve File Handling

For achieving file handling in C++ we need follow following steps

• Naming a file
• Opening a file
• Reading data from file
• Writing data into file
• Closing a file

Functions use in File Handling

Defining and Opening a File

The function open() can be used to open multiple files that use the same stream object.

file-stream-class   stream-object;
stream-object.open("filename"); 

ofstream  outfile;      // create stream
outfile . open ("data1");  // connect stream to data1

#include
#include
#include 

void main()
{
    fstream st; // Step 1: Creating object of fstream class
    st.open("E:\sitesbay.txt",ios::out);  // Step 2: Creating new file
    if(!st) // Step 3: Checking whether file exist
    {
        cout<<"File creation failed";
    }
    else
    {
        cout<<"New file created";
        st.close(); // Step 4: Closing file
    }
    getch();
}

Writing to a File

#include 
#include
#include 

void main()
{
    fstream st; // Step 1: Creating object of fstream class
    st.open("E:\studytonight.txt",ios::out);  // Step 2: Creating new file
    if(!st) // Step 3: Checking whether file exist
    {
        cout<<"File creation failed";
    }
    else
    {
        cout<<"New file created";
        st<<"Hello";    // Step 4: Writing to file
        st.close(); // Step 5: Closing file
    }
    getch();
}

Reading from a File

#include 
#include
#include 

void main()
{
    fstream st; // step 1: Creating object of fstream class
    st.open("E:\sitesbay.txt",ios::in);   // Step 2: Creating new file
    if(!st) // Step 3: Checking whether file exist
    {
        cout<<"No such file";
    }
    else
    {
        char ch;
        while (!st.eof())
        {
            st >>ch;  // Step 4: Reading from file
            cout << ch;   // Message Read from file
        }
        st.close(); // Step 5: Closing file
    }
    getch();
}

Closing a File

A file must be close after completion of all operation related to file. For closing file we need close() function.

outfile.close();

#include 
#include
#include 

void main()
{
    fstream st; // Step 1: Creating object of fstream class
    st.open("E:\sitesbay.txt",ios::out);  // Step 2: Creating new file
    st.close(); // Step 4: Closing file
    getch();
}

File Opening mode

Both ios :: app and ios :: ate take us to the end of the file when it is opened. The difference between the two parameters is that the ios :: app allows us to add data to the end of file only, while ios :: ate mode permits us to add data or to modify the existing data any where in the file.

The mode can combine two or more parameters using the bitwise OR operator (symbol |)

fstream file;
file.Open("data . txt", ios :: out | ios :: in);

File pointer

Each file have two associated pointers known as the file pointers. One of them is called the input pointer (or get pointer) and the other is called the output pointer (or put pointer). The input pointer is used for reading the contents of a given file location and the output pointer is used for writing to a given file location.

Function for manipulation of file pointer

When we want to move file pointer to desired position then use these function for manage the file pointers.

put() and get() function

The function put() write a single character to the associated stream. Similarly, the function get() reads a single character from the associated stream.

read() and write() function

These function take two arguments. The first is the address of the variable V , and the second is the length of that variable in bytes. The address of variable must be cast to type char * (i.e pointer to character type).

file . read ((char *)&V , sizeof (V));
file . Write ((char *)&V , sizeof (V));

Read and Write data from/to File

#include<iostream.h>
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#include<fstream.h>

class student

{
   public:
   int roll;
   char name[15],f_name[20];
   void put();
   void get();
   void switch_case();
  }; student s;

 void student::put()
  {
   clrscr();
   fstream file;
   cout<<"Enter roll no:  ";
   cin>>roll;
   cout<<"Enter name: ";
   gets(name);
   cout<<"Enter father name: ";
   gets(f_name);
   file.open("stu.dat",ios::out|ios::app);
//  file.seekp(0,ios::beg);
   file.write((char *)this,sizeof(student));
   file.close();
   getch();
   s.switch_case();
  }

  void student::get()
  {
   int temp;
   clrscr();
   cout<"Enter roll no: ";
   cin>>temp;
   fstream file;
   file.open("stu.dat",ios::in);
   file.seekg(0,ios::beg);
   while(file.read((char *)this,sizeof(student)));
    {
    if(roll==temp)
    {
    cout<<"roll no. "<<roll<<endl;
    cout<<"stu name:  "<<name<<endl;
    cout<<"father name: "<<f_name;
   }
   }
    file.close();
    getch();
    s.switch_case();
   }

  void student::switch_case()
   {
    int i;
    cout<<"Enter your choice (1-Read, 2-Write, 3-exit): ";
    cin>>i;
    switch(i)
    {
    case 1:
	  s.put();
	  break;

    case 2:
	  s.get();
	  break;

    case 3:
	  exit(0);

    default:
	  cout<<"wrong choice ";
    }
    }

  void main()
    {
     clrscr();
     s.switch_case();
    }

Enter your choice (1-Read, 2-Write, 3-exit): 1
Enter roll_no: 1
Enter name: Hitesh
Enter father name: Pandit
Enter your choice (1-Read, 2-Write, 3-exit): 2
Enter roll_no.: 1
roll no.: 1
stu name.: Hitesh
father name: Pandit

Download ppt file releated to file handling File Handling ppt