1. FILE HANDLING IN C

2. Files in C
In C, each file is simply a sequential stream of bytes. C imposes no structure on a file.
A file must first be opened properly before it can be accessed for reading or writing. When a file is opened, a stream is associated with the file.
Successfully opening a file returns a pointer to (i.e., the address of) a file structure, which contains a file descriptor and a file control block.
12/28/2018 2

3. File Operations Creation of new file Opening of existing file
Reading from file
Writing to file
Moving to specific location in a file
Closing a file

4. Files in C
The statement:
FILE *fptr1, *fptr2 ;
declares that fptr1 and fptr2 are pointer variables of type FILE. They will be assigned the address of a file descriptor, that is, an area of memory that will be associated with an input or output stream.
Whenever you are to read from or write to the file, you must first open the file and assign the address of its file descriptor (or structure) to the file pointer variable.
12/28/2018 4

5. Opening Files The statement: fptr1 = fopen ( "mydata", "r" ) ;
 would open the file mydata for input (reading).
fptr2 = fopen ("results", "w" ) ;
 would open the file results for output (writing).
Once the files are open, they stay open until you close them or end the program (which will close all files.)
12/28/2018 5

6. Modes for opening files
The second argument of fopen is the mode in which we open the file. There are three
"r" opens a file for reading
"w" opens a file for writing - and writes over all previous contents (deletes the file so be careful!)
"a" searches a file for appending - writing on the end of the file.
12/28/2018 6

7. The exit() function
Sometimes error checking means we want an "emergency exit" from a program. We want it to stop dead.
In main we can use "return" to stop.
In functions we can use exit to do this.
Exit is part of the stdlib.h library
exit(-1);
in a function is exactly the same as
return -1;
in the main routine
12/28/2018 7

8. Testing for Successful Open
If the file was not able to be opened, then the value returned by the fopen routine is NULL.
For example, let's assume that the file mydata does not exist. Then:
FILE *fptr1 ;
fptr1 = fopen ( "mydata", "r") ;
if (fptr1 == NULL) {
printf ("File 'mydata' did not open.\n") ; }
12/28/2018 8

9. Reading From Files In the following segment of C language code:
int a, b ;
FILE *fptr1, *fptr2 ;
fptr1 = fopen ( "mydata", "r" ) ;
fscanf ( fptr1, "%d%d", &a, &b) ;
the fscanf function would read values from the file "pointed" to by fptr1 and assign those values to a and b.
12/28/2018 9

10. End of File
The end-of-file indicator informs the program when there are no more data (no more bytes) to be processed.
There are a number of ways to test for the end-of-file condition. One is to use the feof function which returns a true or false condition:
fscanf (fptr1, "%d", &var) ;
if ( feof (fptr1) ) {
printf ("End-of-file encountered.\n”); }
12/28/2018 10

11. End of File
There are a number of ways to test for the end-of-file condition. Another way is to use the value returned by the fscanf function:
int istatus ;
istatus = fscanf (fptr1, "%d", &var) ;
if ( istatus == EOF ) {
printf ("End-of-file encountered.\n”) ; }
12/28/2018 11

12. Writing To Files
Likewise in a similar way, in the following segment of C language code:
int a = 5, b = 20 ;
FILE *fptr2 ;
fptr2 = fopen ( "results", "w" ) ;
fprintf ( fptr2, "%d %d\n", a, b ) ;
the fprintf functions would write the values stored in a and b to the file "pointed" to by fptr2.
12/28/2018 12

13. Closing Files The statements: fclose ( fptr1 ) ; fclose ( fptr2 ) ;
will close the files and release the file descriptor space and I/O buffer memory.
12/28/2018 13

14. /* display contents of file on screen.*/
#include<stdio.h>
Void main() {
FILE *fp;
char ch;
fp=fopen(“pri.c”,”r”);
While(1)
ch=fgetc(fp);
If(ch==EOF)
break;
printf(“%c”,ch); }
fclose(fp);

15. Explanation:
fopen() does 3 jobs namely 1) it searches on disk the file to be opened. 2) then it loads file from disk into memory called buffer.
3) it sets up character pointer that points to 1st character of the buffer.
fgetc() reads chracter from current pointer position, advances pointer so that it points to next character. It gets stored in variable “ch”.
fclose(fp) buffer associated with file is removed from memory.
fputc() writes character to buffer.

16. /* count chars,spaces,tabs and newlines in a file*/
#include<stdio.h>
Void main() {
FILE *fp;
char ch;
int nol=1;not=0,nob=0,noc=0;
fp=fopen(“pri.c”,”r”);
while(1)
ch=fgetc(fp);
if(ch==EOF)
break;
noc++;
if(ch==‘ ‘)
nob++;

17. if(ch==‘\n’) nol++; if (ch==‘\t’) not++; } fclose(fp);
printf(“\n number of characters=%d”,noc);
printf(“\n number of blanks=%d”,nob);
printf(“\n number of tabs=%d”, not);
printf(“\n number of lines=%d”,nol);
getch();

18. Program takes contents of a file and copies them into another file, character by character.
#include<stdio.h>
#include<stdlib.h>
Void main() {
FILE *fs, *ft;
char ch;
fs=fopen(“pr1.c”,”r”);
if(fs==NULL)
puts(“cannot open source file”);
exit(1); }
ft=fopen(“pr2.c”,”w”);
if(ft==NULL)
puts(“cannot open target file”);

19. fclose(fs);
exit(2); }
While(1) {
ch=fgetc(fs);
if(ch==EOF)
break;
else
fputc(ch,ft);
fclose(ft);

20. /* Receives strings from keyboard and writes them to file*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void main() {
FILe *fp;
char s[80];
fp=fopen(“poem.txt”,”w”);
if(fp==NULL)
puts(“cannot open file”);
exit(1); }
printf(“\n enter a few lines of text:\n”);

21. while(strlen(gets(s))>0){
fputs(s,fp);
fputs(“\n”,fp); }
fclose(fp);

22. Note that each string is terminated by hitting “enter”.
Explanation:
Note that each string is terminated by hitting “enter”.
To terminate the execution of program, hit “enter” at the beginning of a line- signal to close file.
fputs() writes contents of array to disk. It doesn’t automatically add a newline character to end of the string, we must do explicitly .

23. /* write records to a file using structure*/
#include<stdio.h>
#incude<conio.h>
Void main() {
FILE *fp;
char another=‘y’;
struct emp
char name[40];
int age;
float bs; };
Struct emp e;
fp=fopen(“employee.dat”,”w”);
If(fp==NULL)

24. puts(“cannot open file”);
exit(1); }
while (another==‘y’) {
printf(“\n enter name,age and basic salary:”);
scanf(“%s%d%f”, &e.name,&e.age,&e.bs);
fprintf(fp,”%s%d%f\n”,e.name,e.age,e.bs);
printf(“add another record(y/n)”);
fflush(stdin);
another=getch();
fclose(fp);

25. fprintf() writes values in structure variable to the file.
Explantion:
we are reading data into structure variable using scanf(), and then dumping it into disk file using fprintf().
fprintf() writes values in structure variable to the file.
fflush() removes any data remaining in the buffer.
Stdin buffer related with standard input device- keyboard.