File Handling in C Language
A file represents a sequence of bytes on the disk where a group of related data is stored. File is created for permanent storage of data. It is a ready made structure.
In C language, we use a structure pointer of file type to declare a file.
FILE *fp;
C provides a number of functions that helps to perform basic file operations. Following are the functions,
| Function | description |
|---|---|
| fopen() | create a new file or open a existing file |
| fclose() | closes a file |
| getc() | reads a character from a file |
| putc() | writes a character to a file |
| fscanf() | reads a set of data from a file |
| fprintf() | writes a set of data to a file |
| getw() | reads a integer from a file |
| putw() | writes a integer to a file |
| fseek() | set the position to desire point |
| ftell() | gives current position in the file |
| rewind() | set the position to the begining point |
Opening a File or Creating a File
The
fopen() function is used to create a new file or to open an existing file.
General Syntax :
*fp = FILE *fopen(const char *filename, const char *mode);
Here filename is the name of the file to be opened and mode specifies the purpose of opening the file. Mode can be of following types,
*fp is the FILE pointer (
FILE *fp), which will hold the reference to the opened(or created) file.| mode | description |
|---|---|
| r | opens a text file in reading mode |
| w | opens or create a text file in writing mode. |
| a | opens a text file in append mode |
| r+ | opens a text file in both reading and writing mode |
| w+ | opens a text file in both reading and writing mode |
| a+ | opens a text file in both reading and writing mode |
| rb | opens a binary file in reading mode |
| wb | opens or create a binary file in writing mode |
| ab | opens a binary file in append mode |
| rb+ | opens a binary file in both reading and writing mode |
| wb+ | opens a binary file in both reading and writing mode |
| ab+ | opens a binary file in both reading and writing mode |
Closing a File
The
fclose() function is used to close an already opened file.
General Syntax :
int fclose( FILE *fp );Here fclose() function closes the file and returns zero on success, or EOF if there is an error in closing the file. This EOF is a constant defined in the header file stdio.h.
Input/Output operation on File
In the above table we have discussed about various file I/O functions to perform reading and writing on file.
getc() and putc() are simplest functions used to read and write individual characters to a file.#include<stdio.h>
#include<conio.h>
main()
{
FILE *fp;
char ch;
fp = fopen("one.txt", "w");
printf("Enter data");
while( (ch = getchar()) != EOF) {
putc(ch,fp);
}
fclose(fp);
fp = fopen("one.txt", "r");
while( (ch = getc()) != EOF)
printf("%c",ch);
fclose(fp);
}
Reading and Writing from File using fprintf() and fscanf()
#include<stdio.h>
#include<conio.h>
struct emp
{
char name[10];
int age;
};
void main()
{
struct emp e;
FILE *p,*q;
p = fopen("one.txt", "a");
q = fopen("one.txt", "r");
printf("Enter Name and Age");
scanf("%s %d", e.name, &e.age);
fprintf(p,"%s %d", e.name, e.age);
fclose(p);
do
{
fscanf(q,"%s %d", e.name, e.age);
printf("%s %d", e.name, e.age);
}
while( !feof(q) );
getch();
}
In this program, we have create two FILE pointers and both are refering to the same file but in different modes. fprintf() function directly writes into the file, while fscanf() reads from the file, which can then be printed on console usinf standard printf() function.
Difference between Append and Write Mode
Write (w) mode and Append (a) mode, while opening a file are almost the same. Both are used to write in a file. In both the modes, new file is created if it doesn't exists already.
The only difference they have is, when you open a file in the write mode, the file is reset, resulting in deletion of any data already present in the file. While in append mode this will not happen. Append mode is used to append or add data to the existing data of file(if any). Hence, when you open a file in Append(a) mode, the cursor is positioned at the end of the present data in the file.
Reading and Writing in a Binary File
A Binary file is similar to the text file, but it contains only large numerical data. The Opening modes are mentioned in the table for opening modes above.
fread() and fwrite() functions are used to read and write is a binary file.
fwrite(data-element-to-be-written, size_of_elements, number_of_elements, pointer-to-file);
fread() is also used in the same way, with the same arguments like fwrite() function. Below mentioned is a simple example of writing into a binary file
const char *mytext = "The quick brown fox jumps over the lazy dog";
FILE *bfp= fopen("test.txt", "wb");
if (bfp) {
fwrite(mytext, sizeof(char), strlen(mytext), bfp) ;
fclose(bfp) ;
}
fseek(), ftell() and rewind() functions
- fseek() - It is used to move the reading control to different positions using fseek function.
- ftell() - It tells the byte location of current position of cursor in file pointer.
- rewind() - It moves the control to beginning of the file.
Some File Handling Program Examples
- Create a File and Store Information in it
- List all the Files present in a Directory
- Finding Size of a File
- Copy Content of one File into Another File
- Reverse the Content of File and Print it
Error Handling
C language does not provide direct support for error handling. However few method and variable defined inerror.h header file can be used to point out error using return value of the function call. In C language, a function return -1 or NULL value in case of any error and a global variable errno is set with the error code. So the return value can be used to check error while programming.C language uses the following functions to represent error- perror() return string pass to it along with the textual represention of current errno value.
- strerror() is defined in string.h library. This method returns a pointer to the string representation of the current errno value.
Example
#include <stdio.h> #include <errno.h> #include <stdlib.h> #include <string.h> extern int errno; main( ) { char *ptr = malloc( 1000000000UL); //requesting to allocate 1gb memory space if ( ptr == NULL ) //if memory not available, it will return null { puts("malloc failed"); puts(strerror(errno)); exit(EXIT_FAILURE); //exit status failure } else { free( ptr); exit(EXIT_SUCCESS); //exit status Success } }Here exit function is used to indicate exit status. Its always a good practice to exit a program with a exit status.EXIT_SUCCESS and EXIT_FAILURE are two macro used to show exit status. In case of program coming out after a successful operation EXIT_SUCCESS is used to show successfull exit. It is defined as 0. EXIT_Failureis used in case of any failure in the program. It is defined as -1.
Dynamic Memory Allocation
The process of allocating memory at runtime is known as dynamic memory allocation. Library routines known as "memory management functions" are used for allocating and freeing memory during execution of a program. These functions are defined in stdlib.h.Function Description malloc() allocates requested size of bytes and returns a void pointer pointing to the first byte of the allocated space calloc() allocates space for an array of elements, initialize them to zero and then return a void pointer to the memory free releases previously allocated memory realloc modify the size of previously allocated space
Memory Allocation Process
Global variables, static variables and program instructions get their memory in permanent storage area whereas local variables are stored in area called Stack. The memory space between these two region is known as Heap area. This region is used for dynamic memory allocation during execution of the program. The size of heap keep changing.
Allocating block of Memory
malloc() function is used for allocating block of memory at runtime. This function reserves a block of memory of given size and returns a pointer of type void. This means that we can assign it to any type of pointer using typecasting. If it fails to locate enough space it returns a NULL pointer.Example using malloc() :int *x; x = (int*)malloc(50 * sizeof(int)); //memory space allocated to variable x free(x); //releases the memory allocated to variable x
calloc() is another memory allocation function that is used for allocating memory at runtime. calloc function is normally used for allocating memory to derived data types such as arrays and structures. If it fails to locate enough space it returns a NULL pointer.Example using calloc() :struct employee { char *name; int salary; }; typedef struct employee emp; emp *e1; e1 = (emp*)calloc(30,sizeof(emp));realloc() changes memory size that is already allocated to a variable.Example using realloc() :int *x; x=(int*)malloc(50 * sizeof(int)); x=(int*)realloc(x,100); //allocated a new memory to variable x
Diffrence between malloc() and calloc()
calloc() malloc() calloc() initializes the allocated memory with 0 value. malloc() initializes the allocated memory with garbage values. Number of arguments is 2 Number of argument is 1 Syntax :(cast_type *)calloc(blocks , size_of_block);Syntax :(cast_type *)malloc(Size_in_bytes);Command Line Argument
Command line argument is a parameter supplied to the program when it is invoked. Command line argument is an important concept in C programming. It is mostly used when you need to control your program from outside. command line arguments are passed to main() method.Syntax :int main( int argc, char *argv[])
Here argc counts the number of arguments on the command line and argv[ ] is a pointer array which holds pointers of type char which points to the arguments passed to the program.
Example for Command Line Argument
#include <stdio.h> #include <conio.h> int main( int argc, char *argv[] ) { int i; if( argc >= 2 ) { printf("The arguments supplied are:\n"); for(i=1;i< argc;i++) { printf("%s\t",argv[i]); } } else { printf("argument list is empty.\n"); } getch(); return 0; }Remember that argv[0] holds the name of the program and argv[1] points to the first command line argument and argv[n] gives the last argument. If no argument is supplied, argc will be one.
Thank You !!
ReplyDelete