File
• File – A 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
Steps in Processing a File:
- Create the stream via a pointer variable using the FILE structure:
FILE *p; - Open the file, associating the stream name with the file name.
- Read or write the data.
- Close the file.
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)
· 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 ( w)
– if file already exists then contents are deleted,
– else new file with specified name created
• Appending mode (a)
– if file already exists then file opened with contents safe
– else new file created
• Reading mode (r)
– if file already exists then opened with contents safe
– else error occurs.
Example for opening a file :
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
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
• getw() – read integer
• putw() – write integer
• fgets() – read string from file
• fputs() – write a string onto file
getc() and putc() :
• handle one character at a time like getchar() and putchar()
• syntax: putc(c,fp1);
– c : a character variable
– fp1 : pointer to file opened with mode w
• syntax: c = getc(fp2);
– c : a character variable
– fp2 : pointer to file opened with mode r
• 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() :
• 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
getw() and putw() :
• handle one integer at a time
• syntax: putw(i,fp1);
– i : an integer variable
– fp1 : pointer to file ipened with mode w
• syntax: i = getw(fp2);
– i : an integer variable
– fp2 : pointer to file opened with mode r
• file pointer moves by one integer position, data stored in binary format native to local system
• getw() returns end-of-file marker EOF when file end reached
THE fgets AND fputs STATEMENTS :
These are useful for reading and writing entire lines of data to/from a file. If buffer is a pointer to a character array and n is the maximum number of characters to be stored, then
These are useful for reading and writing entire lines of data to/from a file. If buffer is a pointer to a character array and n is the maximum number of characters to be stored, then
• fgets (buffer, n, input_file);
• will read an entire line of text (max chars = n) into buffer until the newline character or n=max, whichever occurs first. The function places a NULL character after the last character in the buffer. The function will be equal to a NULL if no more data exists.
• fputs (buffer, output_file);
• writes the characters in buffer until a NULL is found. The NULL character is not written to the output_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 ”);
Random access to files :
• how to jump to a given position (byte number) in a file without reading all the previous data?
• fseek (file-pointer, offset, position);
• position: 0 (beginning), 1 (current), 2 (end)
• offset: number of locations to move from position
Example: fseek(fp,-m, 1); /* move back by m bytes from current position */
fseek(fp,m,0); /* move to (m+1)th byte in file */
fseek(fp, -10, 2); /* what is this? */
• ftell(fp) returns current byte position in file
rewind(fp) resets position to start of file
No comments:
Post a Comment