File Management in C

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, population records student

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
– Optional period with extension

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

 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

How to check whether the file has opened successfully?
If file does not open successfully then the pointer will be assigned a
NULL value, so you can write the logic like this:
below code will check whether the file has opened successfully or
not. If the file does not open, this will display an error message to the
user.

FILE *fpr;
fpr = fopen("C:\\myfiles\\newfile.txt", "r");
if (fpr == NULL)
{
puts("Error while opening file");
exit();
}
 Input / Output operations on files
• C provides several different functions for reading/writing
• fgetc():This function reads the character from current pointer’s position and
upon successful read moves the pointer to next character in the file. Once
the pointers reaches to the end of the file, this function returns EOF (End
of File). We have used EOF in our program to determine the end of the
file.
• syntax: putc(c,fp1);
– c : a character variable
– fp1 : pointer to file opened with mode w
• fputc() – is used to write a single character at a time to a given file. It writes
the given character at the position denoted by the file pointer and then
advances the file pointer.
• This function returns the character that is written in case of successful write
operation else in case of error EOF is returned.
• 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

Other input / output function for files

fprintf() – write set of different data values in file
fscanf() – read set of different data values from file
getw() – read integer from file
putw() – write integer in file
 Program to read/write using getc/putc
#include <stdio.h>
main()
{ FILE *fp1;
char c;
f1= fopen(“INPUT”, “w”); /* open file for writing */
if(fpw == NULL)
{
printf("Error");
exit(1);
}
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
• fscanf():function is used to read formatted data from a file.
In a C program, we use fscanf() as below.
• fscanf (fp, “%d”, &age);
• Where, fp is file pointer to the data type “FILE”.
• age – Integer variable
• This is for example only. We can use any specifiers with any data
type as we use in normal scanf() function.
• Example:
fscanf(f2, “%d %f %s ”, &i, &f,str);
Here
i= integer
f = float
str= character or string
• fscanf returns EOF when end-of-file reached
fprintf() :
Declaration: int fprintf(FILE *fp, const char *format, …)
fprintf() function is used to write formatted data into a file. In a C
program
We use fprinf() as below.
fprintf (fp, “%s %d”, “var1”, var2);

Where, fp is file pointer to the data type “FILE”.

var1 – string variable
var2 – Integer variable
This is for example only. You can use any specifiers with any data
type as we use in normal printf() function.
#include <stdio.h>
void main() Example to store the employee data
{
FILE *fptr;
int id;
char name[30];
float salary;
fptr = fopen("emp.txt", "w+");/* open for writing */
if (fptr == NULL)
{
printf("File does not exists \n");
return;
}
printf("Enter the id\n");
scanf("%d", &id);
fprintf(fptr, "Id= %d\n", id);
printf("Enter the name \n");
scanf("%s", name);
fprintf(fptr, "Name= %s\n", name);
printf("Enter the salary\n");
scanf("%f", &salary);
fprintf(fptr, "Salary= %.2f\n", salary);
fclose(fptr);
}
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
 C program using getw, putw,fscanf, fprintf
#include <stdio.h>
main()
{ int i, sum2=0;
FILE *f2;
/* open files */
f2 = fopen("int_data.txt","w");
/* write integers to files */
for(i=10;i<15;i++) fprintf(f2,"%d\n",i);
fclose(f2);
f2 = fopen("int_data.txt","r");
while(fscanf(f2,"%d",&i)!=EOF)
{ sum2+=i; printf("text file: i=%d\n",i);
} /*end while fscanf*/
printf("text sum=%d\n",sum2);
fclose(f2);
}
Read and write data in file using structure
FWrite:- The Fwrite can write your data into a file. It can write the structure
into your file the structure can contain multiple property for the one instance of
a record.
FRead:- The Fread can be read the data from file. it can pic the one instance
of structure at a time and display it's record till the End of File is reached.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Student {
int roll_no;
char name[20];
};
int main () {
FILE *of;
of= fopen ("c1.txt", "w");
if (of == NULL) {
fprintf(stderr, "\nError to open the file\n");
exit (1);
}
struct Student inp1 = {1, "Ram"};
struct Student inp2 = {2, "Shyam"};
fwrite (&inp1, sizeof(struct Student), 1, of);
fwrite (&inp2, sizeof(struct Student), 1, of);
if(fwrite != 0)
printf("Contents to file written successfully !\n");
else
printf("Error writing file !\n");
fclose (of);

FILE *inf;
struct Student inp;
inf = fopen ("c1.txt", "r");
if (inf == NULL) {
fprintf(stderr, "\nError to open the file\n");
exit (1);
}
while(fread(&inp, sizeof(struct Student), 1, inf))
printf ("roll_no = %d name = %s\n", inp.roll_no, inp.name);
fclose (inf);
}
 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 ”);
 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
 Command line arguments

• can give input to C program from command line

E.g. > prog.c 10 name1 name2 ….
• how to use these arguments?
main ( int argc, char *argv[] )
• argc – gives a count of number of arguments (including
program name)
• char *argv[] defines an array of pointers to character (or array
of strings)
• argv[0] – program name
• argv[1] to argv[argc -1] give the other arguments as strings
 Example args.c
#include <stdio.h>

main(int argc,char *argv[])

{
while(argc>0) /* print out all arguments in reverse order*/
{
printf("%s\n",argv[argc-1]);
argc--;
}
}

$ cc args.c -o args.out
$ ./args.out 2 join leave 6
6
leave
join
2
./args.out
$