Scribd
Upload
4 views

MODULE 5 File Handling in C

Uploaded by

aniketkumarsingh715
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
4 views

MODULE 5 File Handling in C

Uploaded by

aniketkumarsingh715
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 25

MODULE- 5

File Handling in C

1
Console oriented Input/Output

• Console oriented – use terminal (keyboard/screen)

• scanf(“%d”,&i) – read data from keyboard

• printf(“%d”,i) – print data to monitor

• Suitable for small volumes of data

• Data lost when program terminated


Real-life applications

• Large data volumes

• E.g. physical experiments (CERN collider), human genome,


population records etc.

• Need for flexible approach to store/retrieve data

• Concept of files
Files

• File – place on disc where group of related data is stored


– E.g. your C programs, executables

• High-level programming languages support file operations


– Naming
– Opening
– Reading
– Writing
– Closing
Defining and opening file

• To store data file in secondary memory (disc) must specify to


OS

– Filename (e.g. sort.c, input.data)

– Data structure (e.g. FILE)

– Purpose (e.g. reading, writing, appending)


Filename

• String of characters that make up a valid filename for OS

• May contain two parts


– Primary name
– Optional period with extension

• Examples: a.out, prog.c, temp, text.out, dsi.xls


General format for opening file

FILE *fp; /*variable fp is pointer to type FILE*/

fp = fopen(“filename”, “mode”);
/*opens file with name filename , assigns identifier to fp */

• fp
– contains all information about file
– Communication link between system and program
• Mode can be
– r open file for reading only
– w open file for writing only
– a open file for appending (adding) data
Different modes

• Writing mode
– if file already exists then contents are deleted,
– else new file with specified name created
• Appending mode
– if file already exists then file opened with contents safe
– else new file created
• Reading mode
– if file already exists then opened with contents safe
– else error occurs.

FILE *p1, *p2;


p1 = fopen(“data”,”r”);
p2= fopen(“results”, w”);
Additional modes

• r+ open to beginning for both reading/writing

• w+ same as w except both for reading and writing

• a+ same as ‘a’ except both for reading and writing


Closing a file
• File must be closed as soon as all operations on it completed

• Ensures
– All outstanding information associated with file flushed out from buffers
– All links to file broken
– Accidental misuse of file prevented

• If want to change mode of file, then first close and open again
Closing a file
Syntax: fclose(file_pointer);

Example:

FILE *p1, *p2;


p1 = fopen(“INPUT.txt”, “r”);
p2 =fopen(“OUTPUT.txt”, “w”);
……..
……..
fclose(p1);
fclose(p2);

• pointer can be reused after closing


Input/Output operations on files

• C provides several different functions for reading/writing

• getc() – read a character


• putc() – write a character
• fprintf() – write set of data values
• fscanf() – read set of data values
getc() and putc()

• handle one character at a time like getchar() and putchar()


• syntax: c = getc(fp2);
– c : a character variable
– fp2 : pointer to file opened with mode r
• syntax: putc(c,fp1);
– c : a character variable
– fp1 : pointer to file opened with mode w
• file pointer moves by one character position after every getc()
and putc()
• getc() returns end-of-file marker EOF when file end reached
Program to read/write using getc/putc
#include <stdio.h>
main()
{ FILE *fp1;
char c;
f1= fopen(“INPUT”, “w”); /* open file for writing */

while((c=getchar()) != EOF) /*get char from keyboard until CTL-Z*/


putc(c,f1); /*write a character to INPUT */

fclose(f1); /* close INPUT */


f1=fopen(“INPUT”, “r”); /* reopen file */

while((c=getc(f1))!=EOF) /*read character from file INPUT*/


printf(“%c”, c); /* print character to screen */

fclose(f1);
} /*end main */
fscanf() and fprintf()
The fscanf() function is used to read formatted data from the stream. The
syntax of fscanf() can be given as

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

The fscanf() function is used to read data from the stream


and store them according to the parameter format into the
locations pointed by the additional arguments.
Example

#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *fp;
char name[80];
int roll_no;
fp = fopen("student.txt", "r");
if(fp==NULL)
{
printf("\n The file could not be opened");
exit(0);
}
printf("\n Enter the name and roll number of the student: ");

// 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);
}
fscanf() and fprintf()
• similar to scanf() and printf()
• in addition provide file-pointer
• given the following
– file-pointer f1 (points to file opened in write mode)
– file-pointer f2 (points to file opened in read mode)
– integer variable i
– float variable f
• Example:
fprintf(f1, “%d %f\n”, i, f);
fprintf(stdout, “%f \n”, f); /*note: stdout refers to screen */
fscanf(f2, “%d %f”, &i, &f);
• fscanf returns EOF when end-of-file reached
fprintf()
The fprint#() function is used to write formatted output to stream. The
syntax of fprintf() can be given as

int fprintf (FILE * stream, const char * format, ...)

The function writes data that is formatted as specified by the format argument to the
specified stream. After the format parameter, the function can have as many
additional arguments as specified in the format.
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *fp;
int i;
char name[20];
float salary;
fp = fopen("student.txt", "w");
if (fp==NULL)
{
printf("\n The file could not be opened");
exit(1);
}
puts("\n Enter your name: ");
gets(name);
fflush(stdin);
puts("\n Enter your salary: ");
scanf("%f", &salary);

fprintf(fp, " NAME: %s \t SALARY %f",name, salary);

fclose(fp);
}
OUTPUT
Errors that occur during I/O

• Typical errors that occur

– trying to read beyond end-of-file

– trying to use a file that has not been opened

– perform operation on file not permitted by ‘fopen’ mode

– open file with invalid filename

– write to write-protected file


Error handling
• given file-pointer, check if EOF reached, errors while handling
file, problems opening file etc.
• check if EOF reached: feof()
• feof() takes file-pointer as input, returns nonzero if all data
read and zero otherwise
if(feof(fp))
printf(“End of data\n”);

• ferror() takes file-pointer as input, returns nonzero integer if


error detected else returns zero
if(ferror(fp) !=0)
printf(“An error has occurred\n”);
Error while opening file

• if file cannot be opened then fopen returns a NULL pointer

• Good practice to check if pointer is NULL before proceeding

fp = fopen(“input.dat”, “r”);

if (fp == NULL)
printf(“File could not be opened \n ”);

You might also like