UniMAP SemI-11/12EKT120: Computer Programming1 Files.

UniMAP SemI-11/12 EKT120: Computer Programming 1

Files

Outline Introduction File Declaration and Initialization Creating and Opening File Closing File EOF Reading from and Writing into a File Extra : Random Access FilesUniMAP SemI-11/12 EKT120: Computer Programming 2


Introduction Almost all programs developed before,

are interactive. In interactive environment, input is

entered via keyboard and output is via screen or monitor.

This type of processing is not suitable if it involves huge amount of input or output to be entered or displayed on the screen at one time.

Therefore, file processing can solve the problem mentioned.

Storage of data in variables and arrays is temporary – all data are lost when a program terminates.

Files are used for permanent retention of large amounts of data.

A file is a group of related records.* record – is a group of related fields.



File Declaration To implement file processing in C, it is advisable to

include #include <stdlib.h> in your program.

To use file for input and output, a file pointer variable has to be declared.FILE *in_file; => in_file is a pointer to a FILE structureFILE *out_file;=> out_file is a pointer to a FILE structure

in_file and out_file are also known as internal file names.

File Initialization File pointer initialization has the following format :

internal_filename =fopen(external_filename, mode); For example, to declare and initialize the file

pointer variables in_file and out_file:FILE *in_file;FILE *out_file;in_file = fopen (“c:data.txt”, “r”);out_file = fopen (“c:results.txt”, “w”);

internal file name external file name 6mode

7

Opening File and fopen function

Format: internal_filename =fopen(external_filename, mode);

Each file must be opened before it can be accessed or processed.

When opening a file, external file name needs to be related to the internal file name using fopen function.

fopen is the stdio library function used to open or create a file.

Internal file name is the name that the C system uses to identify a file among others that a program might process.

External file name is the name given at “save file as” outside the program e.g. “student.dat”, “records.out”, “data.txt”, etc.

Mode is to indicate the process to be made onto a file.


File Modes Basics mode are:

“r” : open file to read “w” : open file to write “a” : append data to the end of an already

existing file “r+” : open and create file for update, i.e. read and

write, does not overwrite previous contents “w+” : open and create file for update, overwrite “a+” : append, open or create file for update


File Opening Verification There is a possibility of a file fails to open. Could

be the particular file does not exist. Therefore, need to check or verify whether the

file is successfully opened. If file fails to open, need to stop the program, use

exit(-1). A file pointer whose value equals to NULL(empty or ‘0’)is called a null pointer.if (in_file == NULL){ printf(“\nFile fails to open\n”);exit(-1);}


File Opening Verification You can also combine file initialization and

file opening verification, using statement:if ((in_file = fopen(“student.dat”, “r”)) == NULL){

printf(“\nFile fails to open\n”);exit(-1);

}

* NULL = empty or ‘0’


Closing File and fclose function Each opened file needs to be

closed. Format:

fclose(internal_filename);Examples:fclose(in_file);fclose(out_file);


End-of-File (EOF) and feof function Usually you don’t know how many data

you want to read from file. Therefore, need to check whether you

have reached end of file. End-of-file (EOF) character marks the end

of the entire file. Function feof is used to detect EOF.

Format:feof(internal_filename)


Example for EOF and feof functionFILE *in_file;in_file = fopen(“student.dat”, “r”);if(in_file == NULL){

printf(“Error opening file\n”);exit(-1);

}while(!feof(in_file)){ //statements to process data }fclose(in_file);


Reading Data from a Text File

Format: fscanf (internal file name, format control string, input

list);fscanf(in_file, “%d”, &iMarks);

fgetc (internal file name);cCh = fgetc(in_file);

▪ fgets (string variable, size, internal file name);fgets(acName, 10, in_file);


Writing Data to a Text File Format:

fprintf (internal file name, format control string, output list);fprintf(out_file, “%d”, iMarks);

fputc (character expression, internal file name);fputc(cCh, out_file);fputc(“4”, out_file);

fputs (string expression, internal file name);fputs(acName, out_file);

fputs(“Jane”, out_file);


Sample Program#include <stdio.h>#include <stdlib.h>

int main(void){ FILE *in_file; FILE *out_file; int iMarks, iTotal = 0, iCount = 0; float fAvg;

in_file = fopen("student.dat", "r"); out_file= fopen("student.out",

"w"); if(in_file == NULL) { printf("Error opening file\n"); exit(-1); }

while(!feof(in_file)) { fscanf(in_file,"%d",&iMarks); ++iCount; iTotal = iTotal + iMarks; fprintf(out_file, " %d ",iMarks); } fAvg = iTotal /iCount; fprintf(out_file, "\n%.2f\n", fAvg); fclose(in_file); fclose(out_file);

return 0;}


Sample Input File and Output File

50 60 70 80 9044 55 66 77 8824 56 79 50 77

student.dat

50 60 70 80 90 44 55 66 77 88 24 56 79 50 77 64.00

student.out

Input file name

Data in input file

Output file name

Display data in output file


Extra sample program#include <stdio.h>#include <stdlib.h>#define item 3int main(void){ //FILE *in_file; FILE *out_file; int iMarks, iTotal = 0, iCount = 0; float fAvg;

//in_file = fopen("student.dat", "r");

out_file= fopen("student.out", "w");

// if(in_file == NULL) // { // printf("Error opening file\n"); //exit(-1); // }

//while(!feof(in_file))for(i=0;i<item;i++) {// fscanf(in_file,"%d",&iMarks);

printf(“Enter marks: “);scanf(“%d”, &iMarks);

//++iCount; iTotal = iTotal + iMarks; fprintf(out_file, " %d ",iMarks); } fAvg = iTotal /item; fprintf(out_file, "\n%.2f\n", fAvg); // fclose(in_file); fclose(out_file);

return 0;}

Random Access Files In sequential access file, records in a file created with

the formatted output function fprintf are not necessarily the same length.

Individual records of a random access file are normally fixed in length.

This record can be accessed directly without searching through other records. Thus, file searching process will be faster.

Random access is suitable to be used in large database systems such as in airline reservation systems, banking systems and other kind of transaction processing systems.

UniMAP SemI-11/12 19EKT120: Computer Programming

Random Access File Because every record in randomly

access file normally fixed in length, data can be inserted in random access file without destroying other data.

Data stored previously can also be updated or deleted without rewriting the entire file.


Creating a Randomly Accessed File

Function fwrite is used to transfer a specified numbers of byte beginning at a specified location in memory into a file.

The data is written beginning at the location in the file indicated by the file position pointer.

Function fread transfers a specified number of bytes from the file specified by the file position to an area in memory with a specified address.


Creating a Randomly Accessed File

When writing an integer, instead of using fprintf(fPtr, “%d”, iNumber);

which could print as few as 1 digit or as many as 11 digits, we can use fwrite(&iNumber, sizeof(int), 1, fPtr);

which always writes 4 bytes from variable iNumber to the file represented by fPtr.


Creating a Randomly Accessed File fread is used to read 4 bytes integer into variable number.

The fread and fwrite functions are capable of reading and writing arrays of data to and from a disk.

The third argument in the fread and fwrite is the number of element in array that should be read from disk or written to disk.

The preceding fwrite function call, writes a single integer to disk, so third argument is 1.

File processing program rarely writes a single field to a file. Normally, we write one struct at a time.


Creating a Randomly Accessed File – Example

#include <stdio.h>

struct clientData{

int iAcctNum;char acLastName[15];char acFirstName[15];float fBalance;

};

int main(){int iIndex;struct clientData sBlankClient = {0, “ “, “ “, 0.0};FILE *cfPtr;if((cfPtr = fopen(“credit.txt”, “w”)) = = NULL)

printf(“file cant be open”);else{ for (iIndex= 1; iIndex<=100; iIndex++)

fwrite(&sBlankClient, sizeof(struct ClientData), 1, cfPtr);

fclose(cfPtr); }return 0; }

This program shows how to open a randomly access file, define a record format using structure, write a data to disk, and close the file.

This program initializes all 100 records of a file “credit.txt” with empty struct using function fwrite

24

Writing Data Randomly to a Randomly Accessed File

#include <stdio.h>#include <stdlib.h>

struct clientData{

int iAcctNum;char acLastName[15];char acFirstName[15];float bBalance;

};

int main (){ FILE *cfPtr; struct clientData sClient; if ((cfPtr = fopen(“credit.txt”, “r+”))==NULL) printf(“file cant be open”);

else{print(“Enter account number(0 to end input): ”);scanf(“%d”, &sClient.iAcctNum);while (sClient.iAcctNum != 0){printf(“Enter lastname, firstname, balance”);scanf(“%s %s %f, &sClient.acLastName, &sClient.acFirstName, &sClient.fBalance);

fseek(cfPtr, (sClient.iAcctNum – 1) * sizeof(struct clientData), SEEK_SET);fwrite(&sClient, sizeof(struct clientData), 1, cfPtr);

printf(“Enter account number”);scanf(“%d”, &sClient.iAcctNum);} //end of while statements} //end of else statementsfclose(cfPtr); return 0; } //end of main

25

Writing Data Randomly to a Randomly Accessed File Output:

Enter account number (0 to end)? 29Enter lastname, firstname, balance?Brown Nancy -24.54Enter account number (0 to end)? 30Enter lastname, firstname, balance?Dunn Stacy 314.33Enter account number (0 to end)? 31Enter lastname, firstname, balance?Barker Doug 0.00Enter account number (0 to end)? 0


Writing Data Randomly to a Randomly Accessed File

The statement fseek(cfPtr,(sClient.iAcctNum–1) *sizeof(struct clientData),SEEK_SET); positions the file position pointer for the file reference by cfPtr to the byte location calculated by

(iAccountNum-1)*sizeof(struct clientData); Because of the account number is between 1 to 100

but the byte positioning starts from 0, the account number needs to be subtracted with 1 (minus 1).


Reading Data Randomly from a Randomly Accessed File

#include <stdio.h>struct clientData{

int iAcctNum;char acLastName[15];char acFirstName[15];float fBalance;

};int main (){

FILE *cfPtr;struct clientData sClient;if((cfPtr = fopen(“credit.txt”, “r”)) = = NULL)printf(“file cant be open”);else{printf(“%-6s%-16s%-11s%10s\n”, “Acct”, “Last Name”, “ First Name”, “Balance”);while (!feof(cfPtr)) { fread(&sClient, sizeof(struct clientData), 1, cfPtr);if (sClient.iAcctNum != 0)printf(“(“%-6s%-16s%-11s%10.2f\n”,”sClient.iAcctNum, sClient.acLastName,

sClient.acFirstName, sClient.fBalance);}} fclose (cfPtr); return 0; }

28

Reading Data Randomly from a Randomly Accessed File Output:

Acct Last Name First Name Balance

29 Brown Nancy -24.54

30 Dunn Stacey 314.33

31 Barker Doug 0.00

fread(&sClient, sizeof(struct clientData), 1, cfPtr);

Reads the number of bytes determined by sizeof(struct clientData) from the file reference by cfPtr and stores the data in the structure sClient.


THANK YOU


UniMAP SemI-11/12EKT120: Computer Programming1 Files.

Documents

Transcript of UniMAP SemI-11/12EKT120: Computer Programming1 Files.