File in C

DISK I/O

Files :-

            Files are used for permanent data storage.  File is nothing but collection of data or information.  We need files because we know that when we will close the program all the contents O/S the variable will be lost.  & next time we will not get those values.

            In many situations such as maintaining data of students. Etc we need to store the data permaantly & files provide the way of storing data permanently.

            Files are stored on the dist (eg. Floppy, hard, etc) so file I/O is also known as disk I./O. is also known as disk I/o. have a file pointer which points to that file.  For creating a file pointer we use “FILE”.  The general format is,

            File name;

            Where File is the required key word,

·                     Indicates a pointer & ptrname is a name of file  pointer.  Which can be any valid identifier.

Ex.-     FILE * fp;

            FILE * Pl5*pr, *p3;

fopen ( ) –

            Before performing any operations ( such as read, write, modify, etc ) on the files we must open that file.  Without opening it we cannot perform any operations on file.

            For openening a file we use fopen ( ) the general format of fopen ( ) is,

Fileptr =

            fopen ( “filename” ,“mode”);

            Where filename is the file which we want to open.

            Mode means the type of such as read, write, append.

            The filename & mode must be in double quotes.

            Modes

            “r”                   read

            “w”                  write

            “a”                   append

           

            We are opening a file in read mode means we can only read the data from it.

            For opening the file in read mode first we must have that file already created.

            When we open the file is write mode every time a new file is created if the file already exists then compiler will overwrite it if not, a new file will be created.

            When we select the mode as append, the data can be added at the end of already created file.  If the file doesn’t exists. Like in write mode compiler also creates a new file in append mode

Ex-      fp: fopen (“rest”, “W”)

            Pt: fopen (“mydoc”, “r”)

            P1: fopen (“Infor.Txt”, “O”,)

·                     Single character I/O

1)            fputc ( ) :-

It is used for putting a character into the file at the position given by file ptr.  In other words we can write a single character into the file using fputc ( ).  The general form of fputc ( ) is as,

fputc ( Character, fileptr );

Where character is the character which we want to put in file.

And fileptr is the file pointer pointing to that particular position.

Ex. Char ch = *;

            fputc ( ch, fp );

      fputc ( ‘A’, p1 );

                        In the first example the value of ch i.e. * will be put at the position pointed by the file ptr fp.

                        In the second ex. Char ‘A’ will be put at the position pointed by P1.

·                     fgetc ( ) :-

It is used for getting a char from the file i.e. using fgetc ( ) we can input a single character at a time form the file.

            Syntax is,

fgetc ( fileptr );

Where fileptr is the file pointer which determines the position from where the character is to input.

            fgetc ( ) gives a character so to receive it we must have character exprenion.

Ex.

            fh = fgetc (fp);

            In the above ex. The char. From the file is read & will be stored in ch.

/*fputc demo*/

#include<stdio.h>

#include<conio.h>.

void main ( )

{

 FILE *fp; /*fileptr declaration */.

char ch;

cursor ( );

Ff=fopen (“test.txt”, “w”); /* opening file */.

if (fp=NULL)

}

printf (“\n Error in openng the file exit (0); * terminate the program */

}

printf (“\n Enter the character. 0 to stop )

while ( ‘) /*infinite loup */

{

ch = gevche ( );

fputc ( ch, fp ); /* writing to file */.

if ( ch = = 0)

Break;

} /End of while */.

Fclose (fp); /* closes the file */

}

/* fgetc demo*/

#include<stdio.h>

#include<conio.h>.

main ( )

{

file * fp;

char ch;

fp = fopen (“test.txt”, “r”);

if (fp == NULL)

{

printf ( “\n Error in opening files”);

exit (0);

}

printf (“)” The contents of file are \n );

While (1)

{

ch = fgetc (fp);

If (ch= = ‘0’)

break;

putch (on);

}

fclose (fp);

}

1.            Commandline arguments –

We know that we can pass the arguments to any user defined fun.  We have not assed any arguments to the main ( ).  But it is also possible to pass the arguments or parameters to main ( ).  These arguments can’t be passed in the C editor for passing arguments to main ( ) we have to run the program from Dos prompt or Command prompt or line.  As we are passing the arguments from command line, they are also known as command line arguments.

                       

                  There are two arguments of main ( ) one is integer & another is array of character ptrs. We can give any valid name to these arguments, but generally we have the name as argc & argv [ ] as,

                  Main ( int argc, char * argv [10] )

                  Where argc stores the total no. of arguments passed from command line. And argv stores the actual values of the arguments.

                  Running a program from command line means we have to run the exe file of that program.

/* command line arguments */

# include <stdio.h>

# include < conio.h>

void main ( int argc, char *argv [10%),

{

int i;

clescr ( );

printf (“\n total arguments = % d”, argc);

print (“|n The arguments are : \n”);

for (i=0, i<argc; i++)

                  printf ( “\n %s”, argv [i]);

}

                  In the above program first we have to make the exe, of it.  Suppose we have stored program as friend.c then the exe file will be friend. Exe.  We have to run this file from command prompt as,

                  Friend MANJITA SONALI SUJATA SAYALI

                  Then the argc will have the value 5 & argv will contain all these string.

                  Everything will be stored in the form of string though we have given no.

·         WAP to add to no’s the no’s are given from command line.

·         String I/O in file –

      Instead of having character by character input / output it is better to have string I/O. i.e. reading a whole string as well as writing a whole string at a time for this we can use fgets ( ) & fputs ( )

fputsc ( )-

      It is used for putting or writing the whole string in to the file.  The syntax is

      Fputs ( string, fileptr );

     

Where the string is which we want to put or write in the file.

String should specify the address of the containts which we want to put in file.

      And fileptr is the file pointer pointing to that file.

Ex.

      Char name [20] = “YASH CHOPRA”

fputs (name.fe);

                 

                  The above statements writes the name YASH CHOPRA at the location pointed by fp. Nere name specifies the starting address of array name.

fgets ( ) –

                  It is used for reading a string from the file. Here also like fputs we have to provide a string variable & file pointer with this we have to provide the no. of characters we want to read from the file.  The syntax is,

fgets ( String, n, fileptr );

                  Where a string is which we want to get.

                  & n is no. of characters we want to read from the file.

Ex.

                  fgets ( name, 10, fp )

                  The above statement will read 10 characters from the file & will store them in name.

·         WAP

1)      Writing a name in the file.

2)      Reading the same name from that file.

                 

·         fprintf ( ) & fspnf ( ) –

      Like the formatted I/O fun } printf ( ) & scanf ( ) we can also have formatted I/O fun’s for file as fscanf ( ) & fprintf ( ).

fscanf ( ) –

      It is used for reading or input the values from file.

      It is similar to scanf ( ) statement here the input values will be taken from the file.  The syntax is,

      fscanf ( fileptr, control string, list of arg );

      Where fileptr is the file pointer which points to the file from which we want to input the values.

      Control string is the string having format specifiers.

      List of arguments is the different arguments in which use we want to store the values.

Ex.

      Int rno; char name [20];

      fscanf (fp, “%d%s”, & rno, name );

·         fprintf ( )

      If is used for writing or putting the data into the file the syntax is,

      fprintf ( fileptr, control string, list of arg );

Ex.

      Int rno = 20;

      Char name [20] = “JAGRUTI”;

      fprintf (fp, “%d%S”, rno, name );

     

      The above statement writs the value 20 & JAGRUTI in the file pointed by fp.

/*PROGRAME FOR fprint ( ) demo */

#include <stdio.h>

#include<conio.h>

void main ( )

{

ink rno;

char name [20];

FILE * fp; /* file ptr decl^ */

Clrsor ( );

fp = fopen (“testr.txt”, “w”); /*opening file in write mod /.

if (fp = = NULL )

      {printf ( “\n Error in opening the file”);

      exit (0); /* terminates the program */

}

printf (“\n Enter roll no & name : ‘);

scanf (“%d%s”, & rno, name);

fprintf (fp, “%d%s”, rno. Name );

/*writing to file */

fclose (fp); closes the file */

}

/*PROGRAM FOR fscanf ( ) demo ^/

# include <stdio.h>

#I include <conio.h>

void main ( )

{

int rno;

char name [20];

FILE *fp;

Clrscr ( );

fp = fopen ( “test2.txt”, “?”);

if (fp = = NULL)

{printf (“\n Error in opening the file”);

exit (0);

}

fscanf (fp, “%d%s”, &r no, name);

printf (“\n Roll no : % d \n Name: % s” , rno, name);

fclose (fp);

}

fwrite ( ) –

      It is used for writing a fixed block of data into the file.  It is mainly used when we want to write the data from structures into file.  The general format of furite( ) is,

      Where address specifies the location from where the data stored.

      Which we want to write in file.

      Size specifies the size of every block.

      N specifies the no. of blocks of the size.

      Fileptr is the file pointer pointing to that file where we want to write the data.

Ex 1) struct student S;

      Fwrite ( &s, size of (struct student, 1, fp);

     

3)      int a[10];

fwrite (a, size of (int), 10, fp1);

                  The first example writes one block of size equal to the size of student structures at the location & s in the file pointed by fp.

                  The second example writes ten blocks of size equal to the size of into at the location a in the file pointed by fp1.

fread ( )-

                  fread ( ) is used for reading the fixed block of data from the file.  If we want to use fread ( ) for reading the data from file, the file shold be created by using fwrite ( ) otherwise we may get unwanted results.

                  The syntax is, similar to furite ( ) as,

                  fread ( address, size, n, fileptr );

Ex.

                  struct student s;

                  fread ( & s, size of (struct student), 1, fp );

                  The above statements reads one block of size equal to size of structure student from the file pointed by fp & stores the data at the location pointed by &s.