FILES

Introduction to Files:
Files:
* A file is a collection of data stored on a secondary storage device like hard disk.

* A file is basically used because real life applications involve large amounts of data and in such
situations

the console oriented I/O operations pose two major problems:

* First, it becomes cumbersome and time consuming to handle huge amount of data through

terminals.

* Second, when doing I/O using terminal, the entire data is lost when either the program is

terminated or computer is turned off. Therefore, it becomes necessary to store data on a

permanent storage (the disks) and read whenever necessary, without destroying the data.

5.6.1 Streams in C

*In C, the standard streams are termed as pre-connected input and output channels between a text

terminal and the program (when it begins execution).

* Therefore, stream is a logical interface to the devices that are connected to the computer.

* Stream is widely used as a logical interface to a file where a file can refer to a disk file, the
computer

screen, keyboard, etc.

* Although files may differ in the form and capabilities, allstreams are the same.

* The three standard streams (figure 16.1) in C languages are- standard input (stdin), standard output

(stdout) and standard error (stderr).

* Standard input (stdin): Standard input is the stream from which the program receives its data.

The program requests transfer of data using the read operation. However, not all programs require

input. Generally, unless redirected, input for a program is expected from the keyboard.

* Standard output (stdout): Standard output is the stream where a program writes its output

data. The program requests data transfer using the write operation. However, not all programs

generate output.

* Standard error (stderr): Standard error is basically an output stream used by programs to

report error messages or diagnostics. It is a stream independent of standard output and can be

redirected separately. No doubt, the standard output and standard error can also be directed to the

same destination.

JAIN COLLEGE 0F ENGINEERING & TECH. HUBBLI pg.

1
FILES

* A stream is linked to a file using an open operation and disassociated from a file using a close
operation.

5.6.2 Buffer Associated with File Stream:

*When a stream linked to a disk file is created, a buffer is automatically created and associated

with the stream.

* A buffer is nothing but a block of memory that is used for temporary storage of data that has to

be read from or written to a file.

* Buffers are needed because disk drives are block oriented devices asthey can operate efficiently
when

data has to be read/ written in blocks of certain size. The size of ideal buffer size is hardware
dependant.

* The buffer acts as an interface between the stream (which is character-oriented) and the disk

hardware (which is block oriented).

* When the program has to write data to the stream, it is saved in the buffer till it is full. Then the
entire

contents of the buffer are written to the disk as a block as shown in figure 16.2.

JAIN COLLEGE 0F ENGINEERING & TECH. HUBBLI pg.

2
FILES

FIG 16.2 BUFFERS ASSOCIATED WITH STREAMS

*Similarly, when reading data from a disk file, the data is read as a block from the file and written
into

the buffer. The program reads data from the buffer. The creation and operation of the buffer is

automatically handled by the operating system. However, C provides some functions for buffer

manipulation. The data resides in the buffer until the buffer is flushed or written to a file.

5.6.3 Types of Files:

* In C, the types of files used can be broadly classified into two categories- text files and binary files.

1. ASCII Text files

* A text file is a stream of characters that can be sequentially processed by a computer in forward

direction. For this reason a text file is usually opened for only one kind of operation (reading, writing,

or appending) at any given time.

*Because text files only process characters, they can only read or write data one character at a time.

* In a text file, each line contains zero or more characters and ends with one or more characters that

specify the end of line. Each line in a text file can have maximum of 255 characters.

* A line in a text file is not a C string, so it is not terminated by a null character.

* When data is written to a text file, each newline character is converted to a carriage return/line
feed

character. Similarly, when data is read from a text file, each carriage return/ line feed character is

converted in to newline character.

* Another important thing is that when a text file is used, there are actually two representations of
data-

internal or external. For ex, an int value will be represented as 2 or 4 bytes of memory internally but

externally the int value will be represented as a string of characters representing its decimal or

JAIN COLLEGE 0F ENGINEERING & TECH. HUBBLI pg.

3
FILES

hexadecimal value. To convert internal representation into external, we can use printf and fprintf

functions. Similarly, to convert an external representation into internal scanf and fscanf can be used.

2. Binary Files:
*A binary file is a file which may contain any type of data, encoded in binary form for computer

storage and processing purposes.

* Like a text file, a binary file is a collection of bytes.

* Note that in C a byte and a character are equivalent. Therefore, a binary file is also referred to as a

character stream with following two essential differences.

* A binary file does not require any special processing of the data and each byte of data is

transferred to or from the disk unprocessed.

* C places no constructs on the file, and it may be read from, or written to, in any manner the

programmer wants.

* Binary files store data in the internal representation format. Therefore, an int value will be stored I

binary form as 2 or byte value. The same format is used to store data in memory as well as in file.
Like

text file, binary file also ends with an EOF marker.

* Binary files can be either processed sequentially or randomly.

* In a text file, an integer value 123 will be stored as a sequence of three characters- 1, 2 and 3. So
each

character will take 1 byte and therefore, to store the integer value 123 we need 3 bytes. However, in
a

binary file, the int value 123 will be stored in 2 bytes in the binary form. This clearly indicates that

binary files takes less space to store the same piece of data and eliminates conversion between

internal and external representations and are thus more efficient than the text files.

5.7 Using Files in C:

* To use files in C, we must follow the steps given below.

* Declare a file pointer variable

* Open the file

* Process the file

* Close the file

1. Declaring a File Pointer Variable

JAIN COLLEGE 0F ENGINEERING & TECH. HUBBLI pg.

4
FILES

* There can be a number of files on the disk. In order to access a particular file, you must specify the

name of the file that has to be used.

* This is accomplished by using a file pointer variable that points to a structure FILE (defined in

stdio.h).

* The file pointer will then be used in all subsequent operations in the file.

* The syntax for declaring a file pointer is

FILE *file_pointer_name;

* For example, if we write

FILE *fp;

Then, fp is declared as a file pointer.

* An error will be generated if you use the filename to access a file rather than the file pointer

2. Opening a File

* A file must be first opened before data can be read from it or written to it.

* In order to open a file and associate it with a stream, the fopen() function is used.

* The prototype of fopen() can be given as:

FILE *fopen(const char *file_name, const char *mode);

* Using the above prototype, the file whose pathname is the string pointed to by file_name is
opened in

the mode specified using the mode.

* If successful, fopen() returns a pointer-to-structure and if it fails, it returns NULL.

File Name

* Every file on the disk has a name associated with it.

* In DOS the file name can have one to eight characters optionally followed by a period and an

extension that has one to three characters.

* Windows and UNIX permit filenames having maximum of 256 characters.

* In C, fopen() may contain the path information instead of specifying the filename. The path gives

information about the location of the file on the disk.

File Mode:
*Mode conveys to C the type of processing that will be done with the file.

* The different modes in which a file can be opened for processing are given in Table below:

JAIN COLLEGE 0F ENGINEERING & TECH. HUBBLI pg.

5
FILES

* The fopen() can fail to open the specified file under certain conditions that are listed below:

* Opening a file that is not ready for usage.

* Opening a file that is specified to be on a non-existent directory/drive.

* Opening a non-existent file for reading.

* Opening a file to which access is not permitted.

Ex:

FILE *fp;

fp = fopen("Student.DAT", "r");if(fp==NULL)

printf("\n The file could not be opened");exit(1);

} OR

char filename[30];FILE *fp;

gets(filename);

fp = fopen(filename, "r+");

if(fp==NULL)

printf("\n The file could not be opened");exit(1);

3. Closing a File Using fclose()

* To close an opened file, the fclose() function is used which disconnects a file pointer from a file.

JAIN COLLEGE 0F ENGINEERING & TECH. HUBBLI pg.

6
FILES

* After the fclose() has disconnected the file pointer from the file, the pointer can be used to access a

different file or the same file but in a different mode.

* The fclose() function not only closes the file but also flushes all the buffers that are maintained for

that file

* If you do not close a file after using it, the system closes it automatically when the program exits.

However, since there is a limit on the number of files which can be open simultaneously; the

programmer must close a file when it has been used.

* The prototype of the fclose() function can be given as,

int fclose(FILE *fp);

Here, fp is a file pointer which points to the file that has to be closed. The function returns an integer
value

which indicates whether the fclose() was successful or not. A zero is returned if the function was
successful;

and a non-zero value is returned if an error occurred.

5.8 Read Data from Files

* C provides the following set of functions to read data from a file.

* fscanf()

* fgets()

* fgetc()

* fread()

1. fscanf()

*The fscanf() is used to read formatted data from the stream.

* The syntax of the fscanf() can be given as,

int fscanf(FILE *stream, const char *format,…);

* The fscanf() is used to read data from the stream and store them according to the parameter

format into the locations pointed by the additional arguments.

Ex:

#include<stdio.h>

void main()

FILE *fp;

char name[80];int roll_no;

JAIN COLLEGE 0F ENGINEERING & TECH. HUBBLI pg.

7
FILES

fp = fopen("Student.DAT", "r");

if(fp==NULL)

printf("\n The file could not be opened");exit(1);

printf("\n Enter the name and roll number of the student : ");

fscanf(stdin, "%s %d", name, &roll_no); /* read from keyboard */

printf(“\n NAME : %s \t ROLL NUMBER = %d", name, roll_no); // READ FROM FILE-

Student.DAT

fscanf(fp, "%s %d", name, &roll_no);

printf(“\n NAME : %s \t ROLL NUMBER = %d", name, roll_no);fclose(fp);

2. fgets()
*fgets() stands for file get string.

* The fgets() function is used to get a string from a stream.

* The syntax of fgets() can be given as:

char *fgets(char *str, int size, FILE *stream);

* The fgets() function reads at most one less than the number of characters specified by size (gets

size - 1 characters) from the given stream and stores them in the string str. The fgets() terminates

as soon as it encounters either a newline character or end-of-file or any other error. However, if a

newline character is encountered it is retained. When all the characters are read without any error, a
'\0'

character is appended to end the string.

Ex:
#include<stdio.h>
void main()
{
FILE *fp; char str[80];
fp = fopen("Student.DAT", "r");
if(fp==NULL)
{

JAIN COLLEGE 0F ENGINEERING & TECH. HUBBLI pg.

8
FILES

printf("\n The file could not be opened");exit(1);

}
while (fgets(str, 80, fp) != NULL)printf("\n
%s", str);
printf("\n\n File Read. Now closing the file");fclose(fp);
}

3. fgetc()
* The fgetc() function returns the next character from stream, or EOF if the end of file is reached

or if there is an error.

* The syntax of fgetc() can be given as

int fgetc( FILE *stream );

* fgetc returns the character read as an int or return EOF to indicate an error or end of file.

* fgetc() reads a single character from the current position of a file (file associated with stream). After

reading the character, the function increments the associated file pointer (if defined) to point to the
next

character. However, if the stream has already reached the end of file, the end-of-file indicator for the

stream is set.

Ex: Write a C program to copy a text file to another, read both the input file name and
target file name.
#include <stdio.h>
#include <stdlib.h>
void main()
{
FILE *fptr1, *fptr2;
char filename1[100], filename2[100],ch;
printf("Enter the filename to open for reading: \n");
scanf("%s", filename1);
fptr1 = fopen(filename1, "r");if (fptr1
== NULL)
{

JAIN COLLEGE 0F ENGINEERING & TECH. HUBBLI pg.

9
FILES

printf("Error in opening the file");exit(0);

}
printf("Enter the filename to open for writing: \n");scanf("%s",
filename2);
fptr2 = fopen(filename2, "w");if (fptr2
== NULL)
{
printf("Error in opening the file");exit(0);
}
while (!feof(fptr1))
{
ch=fgetc(fptr1);
fputc(ch,fptr2);
}
printf("\n Contents copied to %s", filename2);
fclose(fptr1);
fclose(fptr2);
}

4. fread ()
* The fread() function is used to read data from a file.
* Its syntax can be given as
int fread( void *str, size_t size, size_t num, FILE *stream );
* The function fread() reads num number of objects (where each object is size bytes) and
places them
into the array pointed to by str. The data is read from the given input stream.
* Upon successful completion, fread() returns the number of bytes successfully read. The
number
of objects will be less than num if a read error or end-of-file is encountered. If size or num is
0, fread()

JAIN COLLEGE 0F ENGINEERING & TECH. HUBBLI pg.

10
FILES

will return 0 and the contents of str and the state of the stream remain unchanged. In case
of error, theerror
indicator for the stream will be set.
 The fread() function advances the file position indicator for the stream by the number of
bytes read.

Ex:
#include <stdio.h>void
main()
{
FILE *fp; char str[10];
fp = fopen("Letter.TXT", "r+");
if(fp==NULL)
{
printf("\n The file could not be opened");exit(1);
}
fread(str, 1, 10, fp);
str[10]= '\0';
printf("\n First 9 characters of the file are : %s", str);fclose(fp);

5.9 Writing Data to Files:

* C provides the following set of functions to read data from a file.
* fprintf()
* fputs()
* fputc()
* fwrite()

1. fprintf()
* The fpritnt() is used to write formatted output to stream.
* Its syntax can be given as,
int fprintf ( FILE * stream, const char * format, ... );

JAIN COLLEGE 0F ENGINEERING & TECH. HUBBLI pg.

11
FILES

*The function writes to the specified stream, data that is formatted as specified by the
format argument.
After the format parameter, the function can have as many additional arguments as
specified in format.
* The parameter format in the fprintf() is nothing but a C string that contains the text that
has to be written
on to the stream.

Ex:
#include <stdio.h>void
main()
{
FILE *fp;int i;
char name[20];float salary;
fp = fopen("Details.TXT", "w");
if(fp==NULL)
{
printf("\n The file could not be opened");
exit(1);
}
for(i=0;i<10;i++)
{
printf ("\n Enter your name : ");gets(name);
printf ("\n Enter your salary : ");scanf("%f",
&salary);
fprintf(fp, " NAME : %s \t SALARY: %f", name, salary);
}
fclose(fp);
}

JAIN COLLEGE 0F ENGINEERING & TECH. HUBBLI pg.

12
FILES

2. fputs()
 The fputs() is used to write a line into a file.
 The syntax of fputs() can be given as
int fputs( const char *str, FILE *stream );
 The fputs() writes the string pointed to by str to the stream pointed to by
stream.
 On successful completion, fputs() returns 0. In case of any error, fputs()
returns EOF.
Ex:
#include<stdio.h>void
main()
{
FILE *fp;
char feedback[100];
fp = fopen("Comments.TXT", "w");
if(fp==NULL)
{
printf("\n The file could not be opened");exit(1);
}
printf("\n Kindly give the feedback on this book : ");
gets(feedback);
fputs(feedback, fp);fclose(fp);
}
3. fputc()
*The fputc() is used to write a character to the stream.
*The syntax of fputc() can be given as,
int fputc(int c, FILE *stream);

JAIN COLLEGE 0F ENGINEERING & TECH. HUBBLI pg.

13
FILES

* The fputc() function will write the byte specified by c (converted to an

unsigned char) to the output
stream pointed to by stream. Upon successful completion, fputc() will return
the value it haswritten.
Otherwise, in case of error, the function will return EOF and the error indicator
for the streamwill be set.
Ex: #include<stdio.h>
void main()
{
FILE *fp;
char feedback[100];
int i;
fp = fopen("Comments.TXT", "w");
if(fp==NULL)
{
printf("\n The file could not be opened");exit(1);
}
printf("\n Kindly give the feedback on this book : ");
gets(feedback);
for(i=0;i<feedback[i];i++)
fputc(feedback[i], fp);
fclose(fp);
}
4. fwrite()
* The fwrite() is used to write data to a file.
*The syntax of fwrite() can be given as,
int fwrite(const void *str, size_t size, size_t count, FILE *stream);
*The fwrite() function will write, from the array pointed to by str, up to count objects of size
specified

JAIN COLLEGE 0F ENGINEERING & TECH. HUBBLI pg.

14
FILES

by size, to the stream pointed to by stream.

 The file-position indicator for the stream (if defined) will be advanced by the number of
bytes
successfully written. In case of error, the error indicator for the stream will be set.
Ex: #include<stdio.h>
void main()
{
FILE *fp; size_t count;
char str[] = "GOOD MORNING ";
fp = fopen("Welcome.txt", "wb");
if(fp==NULL)
{
printf("\n The file could not be opened");exit(1);
}
count = fwrite(str, 1, strlen(str), fp);
printf("\n %d bytes were written to the files”, count);fclose(fp);
}
*fwrite() can be used to write characters, integers, structures, etc to a file. However, fwrite()
can be
used only with files that are opened in binary mode.
5.10 Detecting the End-Of-File
*In C, there are two ways to detect the end-of-file.
1. While reading the file in text mode, character by character, the programmer can
compare the character that has been read with the EOF, which is a symbolic constant
defined in stdio.h with a value -1.
while(1)
{
c = fgetc(fp); // here c is an int variable
if (c==EOF)break;
printf("%c", c);
}

JAIN COLLEGE 0F ENGINEERING & TECH. HUBBLI pg.

15
FILES

2. The other way is to use the standard library function feof() which is defined in stdio.h.
The feof()
is used to distinguish between two cases
* When a stream operation has reached the end of a file
* When the EOF ("end of file") error code has been returned as a generic error indicator
even
when the end of the file has not been reached
* The prototype of feof() can be given as:
int feof(FILE *fp);
*feof() returns zero (false) when the end of file has not been reached and a one (true) if
the end-of-filehas
been reached.
while( !feof(fp)
{ fgets(str, 80, fp);
printf("\n %s", str);
}

JAIN COLLEGE 0F ENGINEERING & TECH. HUBBLI pg.

16