In the bucket hashing strategy, the hashing of a key does not yield the position of a single location, but of a storage area  in which several key entries can be stored. This storage area is called a bucket. The file is divided in to a number of buckets. Each one has enough space to store multiple values. All key entries having matching hash values will be stored physically contiguously.

When a record has to be retrieved its key is hashed to give an offset this offset is a bucket offset, i.e. it gives the offset of a location where several records with the same hash value are stored. Then the bucket is read into internal memory and searched sequentially.

Coalesced Chaining

The logic of this method completely eliminates the possibility that more than one collision will occur even for the same hash value.

It requires the storage area to be divided in to two parts

- a prime hash area
- an overflow area

Initially, the hashing function is used to translate keys into location in the prime area. The first key value that hashes to a particular hash is thus placed in the prime area.

All subsequent keys which hash to the same value result I collision and are placed in the overflow area.

Links have to be established between key entries which hash to the same value it is because of this fact that each such entry requires a link field in addition to the key and data fields. if a node is not linked to any other node . it is given the familiar null value, indicating that there are no further key entries having the same hash value.

If the number of records grows beyond the number of available positions, they cannot be inserted without allocating more space. Hence too many locations are allocated initially, resulting in wasting of time in execution.

To reduce this wastage, the separate chaining method is used.

Separate Chaining

In this method, an array of header nodes is used. Each element in the array is a pointer which stores the address of a distinct linked list each linked list is a list of records whose keys have the same hash values. When a record has to be retrieved, the hashing function converts the given key to yield a position (subscript) in the array. The linked list which is initiated. I.e. pointed at by the header node at the subscript, is searched.

-The hashing function used is key mod5

-The rehashing function used is (key+1)mod5

-The key of the record to be inserted has value 12

The following table illustrates the methods by which rehashing handles collisions to find an empty location at which the record can be inserted.

Assume that the hashing function is

Pos(key)= key%4

Using this function on the keys 3,5,8 and 10 the keys get scattered  as shown below

Hashing Collisions

This looks fine, but a problem arises if the keys to be hashed are 3,4,8 and 10 as shown in the figure.

The keys 4 and 8 hash to the same position and these results in a collision

Irrespective of the hashing function used, collisions will occur. A good hashing function is one which minimizes collisions and spreads the records uniformly thought-out the available space

Collision Processing:

Clearly, two records cannot occupy the same position. Hence such a situation has to be taken care of. There are several methods of collision processing.

The low level functions are defined in the header file <io.h>.

These functions do not use file pointer of type FILE to access a particular file, but they use directly the file descriptors, as explained earlier, of type integer. They are also called handles.

Opening and closing of files

The function used to open a file is open( ). Its prototype is:

int open(char *filename, int mode, int access);

Here mode indicates one of the following macros defined in <fcntl.h>.

Mode:
O_RDONLY  Read only
O_WRONLY  Write only
O_RDWR    Read / Write

The access parameter is used in UNIX environment for providing the access to particular users and is just included here for compatibility and can be set to zero.

open() function returns –1 on failure. It is used as:

Code fragment
int fd;
if ((fd=open(filename,mode,0)) == -1)
{ printf(“cannot open file\n”);
exit(1); }

If the file does not exist, open() the function will not create it. For this, the function creat() is used which will create new files and re-write old ones. The prototype is:

int creat(char *filename, int access);

It returns a file descriptor; if successful else it returns –1. It is not an error to create an already existing file, the function will just truncate its length to zero. The access parameter is used to provide permissions to the users in the UNIX environment.

The function close() is used to close a file. The prototype is:

int close(int fd);

It returns zero if successful and –1 if not.

Reading, Writing and Positioning in File

The functions read() and write() are used to read from and write to a file. Their prototypes are:

int read(int fd, void *buf, int size);
int write(int fd, void *buf, int size);

The first parameter is the file descriptor returned by open(), the second parameter holds the data which must be typecast to the format needed by the program, the third parameter indicates the number of bytes to transferred. The return value tells how
many bytes are actually transferred. If this value is –1, then an error must have occurred.

Example
Write a program to copy one file to another to illustrate the use of the above functions. The program should expect two command line arguments indicating the name of the file to be copied and the name of the file to be created.

/* Program to copy one file to another file to illustrate the functions*/
# include<stdio.h>
# include<io.h>
#include<process.h>
typedef char arr[80];
typedef char name[30];
main()
{
arr buf;
name fname, sname;
int fd1,fd2,size;
/* check for the command line arguments */
if (argc!=3)
{ printf("Invalid number of arguments\n");
exit(0);
}
if ((fd1=open(argv[1],O_RDONLY))<0)
{ printf("Error in opening file %s \n",argv[1]);
exit(0);
}
if ((fd2=creat(argv[2],0))<0)
{ printf("Error in creating file %s \n",argv[2]);
exit(0);}
open(argv[2],O_WRONLY);
size=read(fd1,buf,80); /* read till end of file */
while (size>0)
{ write(fd2,buf,80);
size=read(fd1,buf,80);
}
close(fd1);
close(fd2);
} 

OUTPUT
If the number of arguments given on the command line is not correct then output would be:
Invalid number of arguments
One file is opened in the read mode, and another file is opened in the write mode. The output would be as follows is the file to be read is not present (let the file be f1.dat):
Error in opening file f1.dat
The output would be as follows if the disk is full and the file cannot be created (let the output file be f2.dat):
Error in creating file f2.dat
If there is no error contents of f1.dat will be copied to f2.dat.

lseek()

The function lseek() is provided to move to the specific position in a file. Its prototype is:

long lseek(int fd, long offset, int pos);

This function is exactly the same as fseek() except that the file descriptor is used instead of the file pointer.

Using the above defined functions, it is possible to write any kind of program dealing with files.

The function fseek( ) is used to set the file position. Its prototype is:

int fseek(FILE *fp, long offset, int pos);

The first argument is the pointer to a file. The second argument is the number of bytes to move the file pointer, counting from zero. This argument can be positive, negative or zero depending on the desired movement. The third parameter is a flag indicating from where in the file to compute the offset. It can have three values:

SEEK_SET(or value 0) the beginning of the file,
SEEK_CUR(or value 1) the current position and
SEEK_END(or value 2) the end of the file

These three constants are defined in <stdio.h>. If successful fseek( ) returns zero. Another function rewind() is used to reset the file position to the beginning of the file.

Its prototype is:

void rewind(FILE *fp);

A call to rewind is equivalent to the call

fseek(fp,0,SEEK_SET);

Another function ftell() is used to tell the position of the file pointer. Its prototype is:

long ftell(FILE *fp);

It returns –1 on error and the position of the file pointer if successful.

Example
Write a program to search a record in an already created file and update it.

/*Program to search a record in an already created file*/
#include<stdio.h>
#include<stdio.h>
#include<process.h>
#include<string.h>
void main()
{
int r,found;
struct stud
{
char name[30];
int age;
int roll_no;
}st;
FILE *fp;
/* open the file in read/write mode */
if((fp=fopen("f1.dat","r+b"))==NULL)
{ printf("Error while opening the file \n");
exit(0);
}
/* Get the roll_no of the student */
printf("Enter the roll_no of the record to be updated\n");
found=0;
scanf("%d",&r);
/* check in the file for the existence of the roll_no */
while((!feof(fp)) && !(found))
{ fread(&st,sizeof(stud),1,fp);
if(st.roll_no == r)
/* if roll_no is found then move one record backward to update it */
{ fseek(fp,- sizeof(stud),SEEK_CUR);
printf("Enter the new name\n");
scanf("%s",st.name);
fwrite(fp,sizeof(stud),1,fp);
found=1;
}
}
if (!found)
printf("Record not present\n");
fclose(fp);
}

OUTPUT
Let the input file be as follows:
Geeta 18  101
Leena 17  102
Mahesh 23 103
Lokesh 21 104
Amit 19  105

Let the roll_no of the record to be updated be 106. Now since this roll_no is not present the output would be:

Record not present

If the roll_no to be searched is 103, then if the new name is Sham, the output would be the file with the contents:

Geeta 18  101
Leena 17  102
Sham  23  103
Lokesh 21 104
Amit   19 105

C supports two type of files – text and binary files, also two types of file systems – buffered and unbuffered file system. We can also differentiate in terms of the type of file access as Sequential access files and random access files. Sequential access files allow reading the data from the file in sequential manner which means that data can only be read in sequence.

Random access files allow reading data from any location in the file. To achieve this purpose, C defines a set of functions to manipulate the position of the file pointer.

• fread( )
• fwrite( )

These two functions allow reading and writing of blocks of data. Their syntax is:

int fread(void *buf, int num_bytes, int count, FILE *fp);
int fwrite(void *buf, int num_bytes, int count, FILE *fp);

In case of fread(), buf is the pointer to a memory area that receives the data from the file and in fwrite(), it is the pointer to the information to be written to the file.num_bytes specifies the number of bytes to be read or written. These functions are quite helpful in case of binary files. Generally these functions are used to read or write array of records from or to a file. The use of the above functions is shown in the following program.

Example
Write a program using fread( ) and fwrite() to create a file of records and then read and print the same file.

/* Program to illustrate the fread() and fwrite() functions*/
#include<stdio.h>
#include<conio.h>
#include<process.h>
#include<string.h>
void main()
{
struct stud
{
char name[30];
int age;
int roll_no;
}s[30],st;
int i;
FILE *fp;
/*opening the file in write mode*/
if((fp=fopen("sud.dat","w"))== NULL)
{ printf("Error while creating a file\n");
exit(0); }
/* reading an array of students */
for(i=0;i<30;i++)
scanf("%s %d %d",s[i].name,s[i].age,s[i].roll_no);
/* writing to a file*/
fwrite(s,sizeof(struct stud),30,fp);
fclose(fp);
/* opening a file in read mode */
fp=fopen("stud.dat","r");
/* reading from a file and writing on the screen */
while(!feof(fp))
{
fread(&st,sizeof(struct stud),1,fp);
fprintf("%s %d %d",st.name,st.age,st.roll_no);
}
fclose(fp);
}

OUTPUT
This program reads 30 records (name, age and roll_number) from the user, writes one record at a time to a file. The file is closed and then reopened in read mode; the records are again read from the file and written on to the screen.

fscanf() and fprintf()

These functions are used for formatted input and output. These are identical to scanf() and printf() except that the first argument is a file pointer that specifies the file to be read or written, the second argument is the format string. The syntax for these functions is:

int fscanf(FILE *fp, char *format,. . .);
int fprintf(FILE *fp, char *format,. . .);

Both these functions return an integer indicating the number of bytes actually read or written.

Example
Write a program to read formatted data (account number, name and balance) from a file and print the information of clients with zero balance, in formatted manner on the screen.

/* Program to read formatted data from a file */
#include<stdio.h>
main()
{
int account;
char name[30];
double bal;
FILE *fp;
if((fp=fopen("bank.dat","r"))== NULL)
printf("FILE not present \n");
else
do{
fscanf(fp,"%d%s%lf",&account,name,&bal);
if(!feof(fp))
{
if(bal==0)
printf("%d %s %lf\n",account,name,bal);
}
}while(!feof(fp));
}

OUTPUT
This program opens a file “bank.dat” in the read mode if it exists, reads the records and prints the information (account number, name and balance) of the zero balance records.

Let the file be as follows:

101 nuj    1200
102 Raman  1500
103 Swathi 0
104 Ajay   1600
105 Udit   0

The output would be as follows:
103 Swathi 0
105 Udit   0

This approach also involves calculation of a location based on the value of a key, however, instead of inserting a key–offset pair into an index as in the previous method, a whole record is inserted into the calculated position in the data file, i.e., the hash table

In the technique employing hash indexes, two files are used:

- A file containing the data records, and

- A hash index file

Hash Index File			Offset	Data File
Location	Key	Offset		Key	Data
0	3	50	0	6	aaa
1	4	10	10	4	bbb
2	5	30	20	1	ccc
3	6	0	30	5	ddd
4	1	20	40	2	eee
5	2	40	50	3	fff

- The records in the data files exist in random order.

- The hash index file stores the key value and offset of every record.

- Given key, the offset of the record corresponding to it calculated as follows.

- A hashing function is used to calculate the location of the key-offset pair in the hash index file.

- The offset part is then used to retrieve  the record form the file .

This is known as a key to address transformation.

Hence the process of generating the location of a record using a hash function can be summarized as:

• Given a key the hash function converts it into a hash value within in the range 1-n ; where n is the size of the storage (address) space that has been allocated for the records

• The record is then retrieved at the location generated

Two hashing techniques commonly employed will be

• Hash indexes
• Hash Tables

Retrieval of data involves searching the file for the required data. In order to make the search as efficient as possible it is important to property organize the data at the time of storing it.

As we have already seen, two methods of organizing data are:

• Organising  the records in the data file itself, by storing it on the basis of a key  and
• Creating and using an index for retrieval

However in spite of organizing the data well, it would still be necessary to scan through some keys in order to find a record. This process is time consuming optimally, we would like to have an organization in which there are no unnecessary comparisons or searches and by which each key can be retrieved in a single access .This is made possible to a certain by concept known as hashing.

Hashing

To understand the concept of hashing let us look at the various ways of retrieving record.

One method of retrieving the desired record would be to search through the file. But this method is time consuming and slow, especially if the file is very large.

Instead, if there was some method by which we could get to know the offset (relative address of the record from the beginning of the file) retrieval would be vary fast.  Given   the offset of a record, it could easily be retrieving in a single disk access without wasting time in searching.

Let us see if such a method of obtaining the offset is feasible.

As an example assume that the keys in a file are consecutive numbers starting from 0. Then given a key the offset of the record corresponding to it can be easily calculated by the formula.

Key *   Record length

From the above discussion, one can conclude that there does seem to be a method by which the offset can be calculated.

Ideally all key values must begin at 0 and sequentially increase in step of 1. So that given a key the offset can be calculated and the record retrieved in a single disk aces thus eliminating searching. But keys have to be more meaningful thing just consecutive integral numbers.  Fields like client codes product codes and even names are more likely to be used as keys.

For instance a situation might occur in an inventory application where product codes are numbered starting from 10,000 instead of 0. On reflection, it becomes clear that even this is an almost ideal situation since for any given product code, the corresponding key can easily be found at the position given by the relation.

Let us summaries what has been done so far.

A record in a file has to be retrieved.  Hence its offset has to be calculated this is done by converting the key of the record to derive a location which yields the offset of the record. This is the fundamental principle of hashing, i.e. converting a key to an address to retrieve a record. Its main purpose is to eliminate unnecessary searching by using the method of direct addressing and thus cutting down search time. It offers one of the best methods of finding information associated with a unique identifying key.

• fgets( )
• fputs( )

These functions are used to read and write strings. Their syntax is:

int fputs(char *str, FILE *stream);
char *fgets(char *str, int num, FILE *stream);

The integer parameter in fgets( ) is used to indicate that at most num-1 characters are to be read, terminating at end-of-file or end-of-line. The end-of-line character will be placed in the string str before the string terminator, if it is read. If end-of-file is encountered as the first character, EOF is returned, otherwise str is returned. The fputs( ) function returns a non-negative number or EOF if unsuccessful.

Example
Write a program read a file and count the number of lines in the file, assuming that a line can contain at most 80 characters.

/*Program to read a file and count the number of lines in the file */
#include<stdio.h>
#include<conio.h>
#include<process.h>
void main()
{
FILE *fp;
int cnt=0;
char str[80];
/* open a file in read mode */
if ((fp=fopen("lines.dat","r"))== NULL)
{ printf("File does not exist\n");
exit(0);
}
/* read the file till end of file is encountered */
while(!(feof(fp)))
{ fgets(str,80,fp);
/*reads at most 80 characters in str */
cnt++;
/* increment the counter after reading a line */
}
}/* print the number of lines */
printf(“The number of lines in the file is :%d\n”,cnt);
fclose(fp);
}

OUTPUT
Let us assume that the contents of the file “lines.dat” are as follows:
This is C programming.
I love C programming.
To be a good programmer one should have a good logic. This is a must.
C is a procedural programming language.
After the execution the output would be:
The number of lines in the file is: 4

• getc( )
• putc( )

getc( ) is used to read a character from a file and putc( ) is used to write a character to a file. Their syntax is as follows:

int putc(int ch, FILE *stream);
int getc(FILE *stream);

The file pointer indicates the file to read from or write to. The character ch is formally called an integer in putc( ) function but only the low order byte is used. On success putc( ) returns a character(in integer form) written or EOF on failure. Similarly getc( ) returns an integer but only the low order byte is used. It returns EOF when end-of-file is reached. getc( ) and putc( ) are defined in <stdio.h> as macros not functions.

fgetc( ) and fputc( )

Apart from the above two macros, C also defines equivalent functions to read / write characters from / to a file. These are:

int fgetc(FILE *stream);
int fputc(int c, FILE *stream);

To check the end of file, C includes the function feof( ) whose prototype is:
int feof(FILE *fp);
It returns 1 if end of file has been reached or 0 if not. The following code fragment explains the use of these functions.

Example
Write a program to copy one file to another.

/*Program to copy one file to another */
#include <stdio.h>
main( )
{
FILE *fp1;
FILE *fp2;
int ch;
if((fp1=fopen(“f1.dat”,”r”)) == NULL)
{
printf(“Error opening input file\n”);
exit(0);
}
if((fp2=fopen(“f2.dat”,”w”)) == NULL)
{
printf(“Error opening output file\n”);
exit(0);
}
while (!feof(fp1))
{
ch=getc(fp1);
putc(ch,fp2);
}
fclose(fp1);
fclose(fp2);
}

OUTPUT:
If the file ”f1.dat” is not present, then the output would be:
Error opening input file
If the disk is full, then the output would be:
Error opening output file
If there is no error, then “f2.dat” would contain whatever is present in “f1.dat” after the execution of the program, if “f2.dat” was not empty earlier, then its contents would be overwritten.

• Character input/output functions.
• String input/output functions.
• Formatted input/output functions.
• Block input/output functions.

When the processing of the file is finished, the file should be closed using the fclose() function, whose syntax is:

int fclose(FILE *fptr);

This function flushes any unwritten data for stream, discards any unread buffered input, frees any automatically allocated buffer, and then closes the stream. The return value is 0 if the file is closed successfully or a constant EOF, an end-of file marker, if an error occurred. This constant is also defined in <stdio.h>. If the function fclose() is not called explicitly, the operating system normally will close the file when the program execution terminates.

The following code fragment explains how to close a file.

# include <stdio.h>
main ( )
{
FILE *fp;
if ((fp=fopen(“file1.dat”, “r”))==NULL)
{
printf(“FILE DOES NOT EXIST\n”);
exit(0);
}
.................
.................
.................
................
/* close the file */
fclose(fp);
}

Once the file is closed, it cannot be used further. If required it can be opened in same or another mode.

Once a file pointer variables has been declared, the next step is to open a file. The fopen() function opens a stream for use and links a file with that stream. This function returns a file pointer, described in the previous section. The syntax is as follows:

FILE *fopen(char *filename,*mode);

where mode is a string, containing the desired open status. The filename must be a string of characters that provide a valid file name for the operating system and may include a path specification. The legal mode strings are shown below in the table:

Legal values to the fopen( ) mode parameter

Mode	Meaning
“r” / “rt”	opens a text file for read only access
“w” / “wt”	creates a text file for write only access
“a” / “at”	text file for appending to a file
“r+t”	open a text file for read and write access
“w+t”	creates a text file for read and write access,
“a+t”	opens or creates a text file and read access
“rb”	opens a binary file for read only access
“wb”	create a binary file for write only access
“ab”	binary file for appending to a file
“r+b”	opens a binary or read and write access
“w+b”	creates a binary or read and write access,
“a+b”	open or binary file and read access

The following code fragment explains how to open a file for reading.

#include <stdio.h>
main ()
{
FILE *fp;
if ((fp=fopen(“file1.dat”, “r”))==NULL)
{
printf(“FILE DOES NOT EXIST\n”);
exit(0);
}
}

The value returned by the fopen( ) function is a file pointer. If any error occurs while opening the file, the value of this pointer is NULL, a constant declared in <stdio.h>. Always check for this possibility as shown in the above example.

For example, the standard input stream enables a program to read data from the keyboard, and the standard output stream enables to write data on the screen. Opening a file returns a pointer to a FILE structure (defined in <stdio.h>) that contains information, such as size, current file pointer position, type of file etc., to perform operations on the file. This structure also contains an integer called a file descriptor which is an index into the table maintained by the operating system namely, the open file table. Each element of this table contains a block called file control block (FCB) used by the operating system to administer a particular file.

The standard input, standard output and the standard error are manipulated using file pointers stdin, stdout and stderr. The set of functions which we are now going to discuss come under the category of buffered file system. This file system is referred to as buffered because, the routines maintain all the disk buffers required for reading / writing automatically.

To access any file, we need to declare a pointer to FILE structure and then associate it with the particular file. This pointer is referred as a file pointer and it is declared as follows:

FILE *fp;

Open A File Using The Function fopen( )
Close A File Using The Function fclose( )

Each file ends either with an end-of-file marker or at a specified byte number recorded in a system maintained, administrative data structure. C supports two types of files called binary files and text files.

The difference between these two files is in terms of storage. In text files, everything is stored in terms of text i.e. even if we store an integer 54; it will be stored as a 3-byte string – “54\0”. In a text file certain character translations may occur. For example a newline(\n) character may be converted to a carriage return, linefeed pair. This is what Turbo C does. Therefore, there may not be one to one relationship between the characters that are read or written and those in the external device. A binary file contains data that was written in the same format used to store internally in main memory. For example, the integer value 1245 will be stored in 2 bytes depending on the machine while it will require 5 bytes in a text file. The fact that a numeric value is in a standard length makes binary files easier to handle. No special string to numeric conversions is necessary.

The disk I/O in C is accomplished through the use of library functions. The ANSI standard, which is followed by TURBO C, defines one complete set of I/O functions.But since originally C was written for the UNIX operating system, UNIX standard defines a second system of routines that handles I/O operations. The first method,defined by both standards, is called a buffered file system. The second is the unbuffered file system.

In these tutorials, we will first discuss buffered file functions and then the unbuffered file functions.