Section 6.1 Input/Output with files

C++ has support both for input and output with files through the following classes:

• ofstream: File class for writing operations (derived from ostream)
• ifstream: File class for reading operations (derived from istream)
• fstream: File class for both reading and writing operations (derived from iostream)

Open a file

In order to open a file with a stream object we use its member function open():

void open (const char * filename, openmode mode);

ios::in	Open file for reading
ios::out	Open file for writing
ios::ate	Initial position: end of file
ios::app	Every output is appended at the end of file
ios::trunc	If the file already existed it is erased
ios::binary	Binary mode

ofstream file;
file.open ("example.bin", ios::out | ios::app | ios::binary);

class	default mode to parameter
ofstream	ios::out | ios::trunc
ifstream	ios::in
fstream	ios::in | ios::out

Since the first task that is performed on an object of classes ofstream, ifstream and fstream is frequently to open a file, these three classes include a constructor that directly calls the open member function and has the same parameters as this. This way, we could also have declared the previous object and conducted the same opening operation just by writing:

ofstream file ("example.bin", ios::out | ios::app | ios::binary);

You can check if a file has been correctly opened by calling the member function is_open():

bool is_open();

Closing a file

void close ();

In case that an object is destructed while still associated with an open file, the destructor automatically calls the member function close.

Text mode files

Generally, when using text files we shall use the same members of these classes that we used in communication with the console (cin and cout). As in the following example, where we use the overloaded insertion operator <<:

// writing on a text file
#include <fstream.h>

int main () {
  ofstream examplefile ("example.txt");
  if (examplefile.is_open())
  {
    examplefile << "This is a line.\n";
    examplefile << "This is another line.\n";
    examplefile.close();
  }
  return 0;
}

Data input from file can also be performed in the same way that we did with cin:

// reading a text file
#include <iostream.h>
#include <fstream.h>
#include <stdlib.h>

int main () {
  char buffer[256];
  ifstream examplefile ("example.txt");
  if (! examplefile.is_open())
  { cout << "Error opening file"; exit (1); }

  while (! examplefile.eof() )
  {
    examplefile.getline (buffer,100);
    cout << buffer << endl;
  }
  return 0;
}

This last example reads a text file and prints out its content on the screen. Notice how we have used a new member function, called eof that ifstream inherits from class ios and that returns true in case that the end of the file has been reached.

Verification of state flags

bad()

Returns true if a failure occurs in a reading or writing operation. For example in case we try to write to a file that is not open for writing or if the device where we try to write has no space left.

fail()

Returns true in the same cases as bad() plus in case that a format error happens, as trying to read an integer number and an alphabetical character is received.

eof()

Returns true if a file opened for reading has reached the end.

good()

It is the most generic: returns false in the same cases in which calling any of the previous functions would return true.

get and put stream pointers

• ifstream, like istream, has a pointer known as get pointer that points to the next element to be read.
  
• ofstream, like ostream, has a pointer put pointer that points to the location where the next element has to be written.
  
• Finally fstream, like iostream, inherits both: get and put

These stream pointers that point to the reading or writing locations within a stream can be read and/or manipulated using the following member functions:

tellg() and tellp()

These two member functions admit no parameters and return a value of type pos_type (according ANSI-C++ standard) that is an integer data type representing the current position of get stream pointer (in case of tellg) or put stream pointer (in case of tellp).

seekg() and seekp()

This pair of functions serve respectively to change the position of stream pointers get and put. Both functions are overloaded with two different prototypes:

seekg ( pos_type position );
seekp ( pos_type position );

Using this prototype the stream pointer is changed to an absolute position from the beginning of the file. The type required is the same as that returned by functions tellg and tellp.

seekg ( off_type offset, seekdir direction );
seekp ( off_type offset, seekdir direction );

Using this prototype, an offset from a concrete point determined by parameter direction can be specified. It can be:

ios::beg	offset specified from the beginning of the stream
ios::cur	offset specified from the current position of the stream pointer
ios::end	offset specified from the end of the stream

The following example uses the member functions just seen to obtain the size of a binary file:

// obtaining file size
#include <iostream.h>
#include <fstream.h>

const char * filename = "example.txt";

int main () {
  long l,m;
  ifstream file (filename, ios::in|ios::binary);
  l = file.tellg();
  file.seekg (0, ios::end);
  m = file.tellg();
  file.close();
  cout << "size of " << filename;
  cout << " is " << (m-l) << " bytes.\n";
  return 0;
}

Binary files

File streams include two member functions specially designed for input and output of data sequentially: write and read. The first one (write) is a member function of ostream, also inherited by ofstream. And read is member function of istream and it is inherited by ifstream. Objects of class fstream have both. Their prototypes are:

write ( char * buffer, streamsize size );
 read ( char * buffer, streamsize size );

// reading binary file
#include <iostream.h>
#include <fstream.h>

const char * filename = "example.txt";

int main () {
  char * buffer;
  long size;
  ifstream file (filename, ios::in|ios::binary|ios::ate);
  size = file.tellg();
  file.seekg (0, ios::beg);
  buffer = new char [size];
  file.read (buffer, size);
  file.close();

  cout << "the complete file is in a buffer";

  delete[] buffer;
  return 0;
}

Buffers and Synchronization

When the buffer is flushed, all data that it contains is written to the physic media (if it is an out stream) or simply erased (if it is an in stream). This process is called synchronization and it takes place under any of the following circumstances:

• When the file is closed: before closing a file all buffers that have not yet been completely written or read are synchronized.
• When the buffer is full: Buffers have a certain size. When the buffer is full it is automatically synchronized.
• Explicitly with manipulators: When certain manipulators are used on streams a synchronization takes place. These manipulators are: flush and endl.
• Explicitly with function sync(): Calling member function sync() (no parameters) causes an immediate syncronization. This function returns an int value equal to -1 if the stream has no associated buffer or in case of failure.

© The C++ Resources Network, 2000 - All rights reserved

Previous: 5-5. Preprocessor directives.

index