File
•
File – A place on
disc where group of related data is stored
–
E.g. 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
Pointer
variable = fopen(“filename”, “mode”); // syntax
Example for opening a file :
FILE *p1, *p2;
// variables p1, p2 are pointer
to type FILE
p1 = fopen(“data”,”r”);
p2= fopen(“results”, w”);
/*opens file with name data for reading ,
assigns identifier to p1 */
/*opens file with name results for writing ,
assigns identifier to p2 */
•
p1, p2
–
contains all
information about file
–
Communication
link between system and program
Different
modes
•
Reading mode (r)
–
if file already
exists then opened with contents safe
–
else error
occurs.
•
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
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
•
getc() reads one
character from file and assigns to the variable
•
putc() writes one
character onto a file from a variable
•
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() operation
•
getc() returns
end-of-file marker EOF when file end is reached
Program to read/write using getc/putc :
#include <stdio.h>
main()
{ FILE
*f1;
char
c;
f1=
fopen(“INPUT”, “w”); /* open file
for writing */
while((c=getchar())
!= EOF) /*get a 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() :
•
read or write
multiple data items, may be of different types, from or to file respectively.
•
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:
fscanf(f2, “%d %f”,
&i, &f);
fprintf(f1, “%d %f\n”, i, f);
fprintf(stdout,
“%f \n”, f); /*note: stdout refers to screen */
•
fscanf() returns
end-of-file marker EOF when file end reached
getw()
and putw() :
•
handle one
integer type data item at a time
•
getw() reads one
integer type data item from an input file
•
putw() writes one
integer type data item onto a output file
•
•
syntax: putw(i,fp1);
–
i : an integer
variable
–
fp1 : pointer to
file opened 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 from an
input_file 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 from buffer onto a output_file 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
Program to implement read & write using fgets()
& fputs() of file functions.
#include<stdio.h>
#include<conio.h>
void main()
{
FILE *fgt, *fpt;
char iname[30], oname[30];
clrscr();
/* file opening for writing onto file
the string reading from KB */
fgt= fopen("nameslist.txt",
"w");
printf(" enter a string: ");
scanf("%s",iname);
fputs(iname,fgt);
fclose(fgt);
/* file opening for reading from file
the string and display on screen */
fgt= fopen("nameslist.txt",
"r");
printf("\n After reading from the file
the string is :\n");
while(!feof(fgt))
{
fgets(oname,30,fgt);
printf("\t %s ",oname);
}
fclose(fgt);
getch();
}
OUTPUT:
enter
a string: inputfile
After reading from the file the string
is :
inputfile
No comments:
Post a Comment