Unit v

UNIT V
194
Unit – V
Files – operations on a file – Random access to files – command line
arguments Introduction to preprocessor – Macro substitution
directives – File inclusion directives – conditional compilation
directives – Miscellaneous directives
FILE
 Group of related record form a FILE.
 FILE is a place on the disk where group of related data is
stored.
 DATA FILE is used to store information in floppy disk, hard
disk.
 Field is a data item used to store a single unit. Group of related field
constitute a RECORD.
FILE is classified into three types. They are
• Numeric file
It contains numeric data.
• Text file
It consists of text data.
• Data files
It consists of data grouped in the form of structure. It may have
text,numeric data or both.
C supports a number of functions that have the ability to perform basic
file operations, which include:
1. Naming a file
2. Opening a file
3. Reading from a file
4. Writing data into a file
5. Closing a file
FILE OPERATION LEVELS
There are two FILE operation levels. They are
1. Low level Input/Output operations
 It uses system calls.
2. High level Input/Output operations
 It uses functions in standard C Input Output Library.

UNIT V
195
File operation functions in C:
FILE data type
FILE is a structure data type. It is used to establish file buffer area.
To get buffer area
The syntax is
FILE *fp;
where fp is a file pointer or stream pointer. fp contains all the information
about file. It serves as link between system and program. FILE is a keyword.
It refers to the file control structure for streams.
Opening a file
“fopen” function is used to open a stream or data file. File should be
opened before reading or writing from it. If a file is opened ‘fopen’

UNIT V
196
functions returns FILE pointer to the beginning of buffer area. If file is not
opened NULL value is returned.
The Syntax of fopen is
FILE *fopen(“filename”,“mode”);
 fopen() function returns pointer to structure associated with the file.
 fopen() function needs two arguments of type string.
 First argument filename refers to the name of file which is to be
opened.
 Second argument mode refers to file mode.

UNIT V
197
Closing a file
 File is closed when all input output operations are completed.
 fclose() function is used to close opended file.
 This function makes all buffers associated with the file empty and all
links to the file broken. Whenever we want to reopen the same file we
have to close all other file.
The syntax for closing a file is
fclose(fp);
#include<stdio.h>
void main()
{
FILE *f1;
clrscr();
printf(“Data input output”);
f1=fopen(“Input”,”w”); /*Open the file Input*/
while((c=getchar())!=EOF) /*get a character from key board*/
putc(c,f1); /*write a character to input*/
fclose(f1); /*close the file input*/
printf(“nData outputn”);
f1=fopen(“INPUT”,”r”); /*Reopen the file input*/
while((c=getc(f1))!=EOF)
printf(“%c”,c);
fclose(f1);
}
The program shown below displays use of a file operations. The data enter
through the keyboard and the program writes it. Character by character, to
the file input. The end of the data is indicated by entering an EOF character,
which is control-z. the file input is closed at this signal.
OUTPUT
Data input output
All cse students are bright students^Z
Data output
All cse students are bright students

UNIT V
198
Operations on Files
There are eight operations on files. They are
• putc()
• getc()
• getw()
• putw()
• fscanf()
• fread()
• fprintf()
• fwrite()
putc()
This function operates on file that is copied in writing mode.
The syntax for putc() is
putc(int ch, FILE *fp);
getc()
This function operates on file that is opened in reading mode.
The syntax for getc() is
getc(FILE *fp);
Reads character from file pointed by file pointer fp and displays on it screen.
Now file pointer moves by one character position for every getc() function
and returns EOF (end-of-file). EOF is a constant that indicates the end-of-
file reached on a file. To get character from a file terminating character(^z)
is entered.
getw()
Reads an integer value from file pointed by file pointer.
The syntax for getw() is
int getw(FILE *fp);
Returns next integer from input output stream.
/*Example program for using getw and putw functions*/
#include<stdio.h>
main()
{
FILE *f1,*f2,*f3;
int number,I;
printf(“Text inside the data filenn”);
f1=fopen(“DATA”,”W”);
for(I=1;I< 30;I++)
{
scanf(“%d”,&number);
if(number==-1)

UNIT V
199
break;
putw(number,f1);
}
fclose(f1);
f1=fopen(“DATA”,”r”);
f2=fopen(“ODD”,”w”);
f3=fopen(“EVEN”,”w”);
while((number=getw(f1))!=EOF)/* Reading data from the file*/
{
if(number%2==0)putw(number,f3);/*Write to even Numbers file*/
else
putw(number,f2);/*write to odd Numbers file*/
}
fclose(f1);
fclose(f2);
fclose(f3);
f2=fopen(“ODD”,”r”);
f3=fopen(“EVEN”,”r”);
printf(“nnData From the odd filenn”);
while(number=getw(f2))!=EOF)
printf(“%d”,number);
printf(“nnData from the even file”);
while(number=getw(f3))!=EOF)
printf(“%d”,number);
fclose(f2);
fclose(f3);
}
OUTPUT
Contents of the data file
12
13
14
15
-1
Contents of the odd file
13
15
Contents of the even file
12

UNIT V
200
14
putw()
This function is used to write integer value on file pointed by file pointer.
The syntax for putw() is
putw(int w, FILE *fp);
Here fp is a file pointer and w is an integer variable.
fscanf()
The syntax for fscanf() is
fscanf(FILE *fp, format-specification, list of variables);
fprintf()
This function is used to work with file.
The syntax for fprintf() is
int fprintf(FILe *fp, format specification, list of variables);
where fp is a file pointer. Format specification specifies the format for
output variables to be stored. List of variables are those variables written to
file pointed by fp.
Example for Mixed data type in files
#include <stdio.h>
main()
{
FILE *fp;
int number, quantity, i;
float price, value;
char item[10], filename[10];
printf("Input file namen");
scanf("%s", filename);
fp = fopen(filename, "w");
printf("Input inventory datann");
printf("Item name Number Price Quantityn");
for(i = 1; i <= 3; i++)
{
fscanf(stdin, "%s %d %f %d",
item, &number, &price, &quantity);
fprintf(fp, "%s %d %.2f %d",

UNIT V
201
item, number, price, quantity);
}
fclose(fp);
fprintf(stdout, "nn");
fp = fopen(filename, "r");
printf("Item name Number Price Quantity Valuen");
for(i = 1; i <= 3; i++)
{
fscanf(fp, "%s %d %f d",item,&number,&price,&quantity);
value = price * quantity;
fprintf(stdout, "%-8s %7d %8.2f %8d %11.2fn",
item, number, price, quantity, value);
}
fclose(fp);
}
OUTPUT
Input file name
t
Input inventory data
Item name Number Price Quantity
fan 12 2400 12
light 23 100 10
switch 12 20 100
Item name Number Price Quantity Value
fan 12 2400.00 100 240000.00
12light 23 100.00 100 10000.00
10switch 12 20.00 100 2000.00
fread()
This function reads data from stream of any data type.
The syntax for fread() is
size_t fread(void *ptr, size_t size,size_t n, FILE *fp);
size_t used for memory objects and repeats count.
fwrite()
This function writes to a stream or specified file.
The syntax for fwrite() is
size_t fwrite(const void *ptr,size_t size,size_t n,FILE *fp);

UNIT V
202
where n is the number of elements written to that file.
Example for fread and fwrite
#include <stdio.h>
#define NELEM 3
int main(void)
{
FILE *fp;
struct product {
int cat_num;
float cost;
};
typedef struct product product;
product productarr[NELEM] = {{2,20.1},{4,40.1},{6,60.1}};
product one_product, *product_ptr = &one_product;
int i, irc;
fp = fopen("c11-struct-file","w+");
if (fp != NULL);
irc = fwrite(productarr, sizeof(product), NELEM, fp);
printf(" fwrite return code = %dn", irc);
rewind(fp);
for (i=0; i<NELEM; i++) {
fread(product_ptr, sizeof(product), 1, fp);
printf(" product %d) cat_num=%d, cost=%fn",i,product_ptr->cat_num,
product_ptr->cost);
}
return 0;
}
OUTPUT
fwrite return code = 3
product 0) cat_num=2, cost=20.100000
RANDOM ACCESS TO A FILE
Used when programmer want to process or access file randomly. Functions
used for Random access of file are
 fseek(),
 ftell().
fseek()
 This function moves file pointer to desired location in file.
 It is used to index a file. it seeks specific location in file.

UNIT V
203
 The syntax for fseek() is
int fseek(FILE *fp, long offset,int whence);
here fp is a file pointer, offset refers to number of bytes from whence
to determine new current position. whence is a positive integer number.
ftell()
 This function returns the current position of file pointer in the
form of number.
 The number is of type long.
 The syntax for ftell() is
ftell(FILE *fp);
where fp is the file pointer. It refers to the current file pointer.
If fp points beginning byte
ftell() returns value 0.
rewind()
 This function reset file pointer to the beginning of the file.
 The syntax for rewind() is
void rewind(FILE *fp);
where fp is a file pointer.
FILE SYSTEM FUNCTIONS
 These functions are used to work with file systems.
1. rename(),
2. rewind(),
3. remove() and
4. chmod() are file system functions.
rename()
 This function is used to rename file in argument.

UNIT V
204
 The syntax for rename() is
int rename(const char *oldname, const char *newname);
where oldname is the current name of the file and newname is the proposed
name of the file. rename() function return 0 if success.
remove()
 This function deletes a file. Macro translates a call to unlink.
 The syntax for remove() is
remove(filename);
unlink()
 The syntax for unlink() is
int unlink(const char* filename);
This function is used to delete a file. If the file is deleted value 0 is returned.
If the file is not deleted value -1 is returned.
chmod()
 This function changes the access mode of file.
 The syntax is
int chmod(const char *filename,int amode);
COMMAND LINE ARGUMENTS
 Command line argument is a parameter supplied to a program when
the program is invoked.
 This parameter represents filename of the program that should process.
 In general, execution of C program starts from main() function. It has
two arguments like argc and argv.
o The argc is an argument counter that counts the number of
arguments on the command line.
o The argv is an argument vector. It represents an array of
character pointer that point to command line arguments.
To access command line arguments, declare the main function and
parameter as main(int argc, char *argv[ ])
{
……..
}
Eg
#include <stdio.h>
main( int argc, char *argv[] )
{
if( argc == 2 )
printf("The argument supplied is %sn", argv[1]);
else if( argc > 2 )

UNIT V
205
printf("Too many arguments supplied.n");
else
printf("One argument expected.n");
}
OUTPUT
Type EXIT to return to Turbo C. . .Microsoft(R) Windows DOS
(C)Copyright Microsoft Corp 1990-2001.
C:TURBOC2>F 2
The argument supplied is 2
C:TURBOC2>F1
'F1' is not recognized as an internal or external command,
operable program or batch file.
C:TURBOC2>F 1
C:TURBOC2>F 4
C:TURBOC2>F 10
C:TURBOC2>F
One argument expected.
C:TURBOC2>
Rewrite the program which copies files, ie, FCOPY.C to accept the source and
destination filenames from the command line. Include a check on the number
of arguments passed.
Example
#include<stdio.h>
int main(int argc,char *argv[])
{
FILE *fp1,*fp2;
char ch ;
fp1 = fopen(argv[1],"r");
if(fp1 == NULL)
{
printf("Error in opening the filen");

UNIT V
206
exit(0);
}
fp2 = fopen(argv[2],"w");
if(fp2 == NULL)
{
printf("Error in opening the filen");
exit(0);
}
while((ch = getc(fp1))!=EOF) //Copying the contents of src.txt to dst.txt
{
putc(ch,fp2);
}
fclose(fp1);
fclose(fp2);
}
PREPROCESSOR
o Preprocessor is a program that process source program before it
passes through the compiler.
o Preprocessor is system software that consists of special
statements called directives.
o It operates under the control of directives known as preprocessor
command lines.
o Preprocessor directives are placed in the source program before the
main line.
o Whenever a C program is compiled, source program runs through
preprocessor.
Preprocessor
o Executed at the beginning of compilation process.
o Do not change Original C program but creates new file.
o Appear in the beginning of C program.
o It can be included in any part of a program. If it appear in the middle
then the directive is applied to portion of program.
o Preprocessor symbol should not be enclosed within quotes and should
not be enclosed with semicolon.
o #define directive increases the readability of the C program. It
is used to create function like macros.
Rules for defining preprocessor
• All preprocessor directives begin with sharp sign. i.e.,(#)
• It starts in first column.
• It should not terminate with semicolon.

UNIT V
207
• It may appear at any place in the source file. i.e., Outside the
function, inside the function or inside compound statements.
• Preprocessor directives begin with the symbol #.
• It does not require semicolon at the end.
TYPES OF PREPROCESSOR DIRECTIVES
The types of preprocessor directives are
• File Inclusion
• Macro Definition
• Conditional Compilation
 These facilities are controlled in a program by pre processor control
lines on Directives.
 Generally, the Preprocessor directives appear before the function main
( ).
 But they many appear anywhere in the C Program.
 Preprocessor Directives follow special syntax rules.
 They all begin with the symbol # in column one and do not require a
semicolon at the end.
A set of commonly use pre processor Directives and their
functions
Directives Function
# define Defines a macro substitution
#undef undefines a macro
# include Specifies the files to be included
#ifdef Test for a macro definition
#endif specifies the end of # if

UNIT V
208
#ifmdef Test whether a macro is not defined
#if Test a compile time condition
#else Specifies alternatives when # if test fails.
File Inclusion Directives
 It is the first type.
 This directive is used for including one or more files in the
program.
 It instructs the compiler to make a copy of specified file to be
included in place of the directive.
The general form is
#include<filename> - It make preprocessor to look for file with
specified filename in special directories set aside for files.
#include“filename” - It preprocessor to look for file with specified
filename in Current working directory.
Macro Substitution Directives
 Macro definition is the second type of preprocessor directives.
 The #define directive is used here.
 It is also used to define symbolic constant and assign value.
The general form is
#define identifier set-of-characters
where identifier also known as “macro name” or “macro template”.
#define FIVE 5
#define SIX FIVE+1
#define SEVEN SIX+1
#include<stdio.h>
#include<conio.h>
void main()
{
clrscr();
printf("%d t %d t %d",FIVE,SIX,SEVEN);
getch();
}
OUTPUT
5 6 7
CONDITIONAL COMPILATION
 Directives permit certain segment of source code to be
selectively compiled.
 Directives are also called as Conditional Compilation.

UNIT V
209
 The Conditional directives are
• #if
• #else
• #elif
• #endif
• #ifdef
• #ifndef
Format of #if and #endif directive
The format of #if and #endif directive is
#if constant expression
sequence of statements
#endif
If the value of constant expression is true sequence of statements are
executed. if the expression value is false compiler skip the statements.
int main(void)
{
#if 1
printf("CSE WINSn");
#else
printf("CSE ROCKSn");
#endif
return 0;
}
OUTPUT
# if 1
CSE WINS
# if 0
CSE ROCKS
Format of #if and #else directive
 #else statement helps to terminate #if statement.
 If the given constant or expression is false #else block is executed.
The general form is
#if constant expression
Sequence of statements
#else
Sequence of statements
#endif

UNIT V
210
Here for nested if statements #elif directives can be used.
The general format of #elif is
#if constant expression1
statements
#elif constant expression2
statements
……………
#endif
Here if expression1 is true it is executed and all other expressions are
skipped.#ifdef directive is used for conditional compilation. The general
form is
#ifdef macroname
statements
#endif
int main(void)
{
#if 1
printf("Checkpoint1n");
#elif 1
printf("Checkpoint2n");
#endif
return 0;
}
OUTPUT
#if 1
Checkpoint1
#if 0
Checkpoint2
#include directive
#include directive has two forms. They are
1. #include<filename>
This directive instruct compiler to search for file in the directory that
contains header
file.
Eg: #include<stdio.h>
#include<conio.h>
2. #include“filename”
This instruct compiler to search for file in the current directory.

UNIT V
211
Eg: #include“stdio.h”
#include“conio.h”
#define A "X is Big"
#define B "Y is Big"
#include<stdio.h>
void main()
{
int x,y;
clrscr();
printf("n Enter value for X and Y : ");
scanf("%d%d",&x,&y);
if(x>y)
printf(A);
else
printf(B);
getch();
OUTPUT
Enter value for X and Y : 23 12
X is Big
MEMORY FUNCTIONS
malloc
 Used to allocate contiguous block of memory in bytes.
 Allocates memory size in bytes. If memory allocated success it
returns starting address else returns NULL.
 Returns starting address of memory through pointer variable .
 Memory space is not initialized.
The general form of malloc function is
pointer variable=(cast-type *)malloc(size);
where pointer variable is a valid variable. cast-type is type of pointer
returned by malloc() such as int, char, etc,. size is required size of memory
in bytes.
#include<alloc.h>
void main()
{
int *a;
int i,n,sum=0;
printf(“Enter size of array :”);
scanf(“%d”,&n);
a=(int *)malloc(sizeof(int)*n); // ( Or ) a=malloc(sizeof(int)*n);

UNIT V
212
if(a!=NULL)
{
printf(“Enter %d elements :”,n);
for(i=0;i<n;i++)
{
scanf(“%d”,&a[i]);
sum=sum+a[i];
}
printf(“Sum of given integers is %d”,sum);
}
else
printf(“Memory cannot be allocated”);
}
Output:
Enter size of array : 5
Enter 5 elements : 8 8 8 8 8
Sum of given integers is 40
Memory cannot be allocated
calloc() function
 Used to allocate multiple blocks of contiguous memory in bytes.
 All blocks are of same size. If memory allocated success it
returns starting address else returns NULL.
 Allocates n blocks of memory space of size in bytes and returns
starting address of memory through pointer variable of type cast-type.
 Allocated memory space is filled with zeros if memory is initialized.
The general form of calloc function is
pointer variable=(cast-type *)calloc(n,size);
where pointer variable is a valid variable. cast-type is type of pointer
returned by calloc() such as int, char, etc,. n is the number of blocks and
size is required size of memory in bytes.
#include<stdio.h>
#include<alloc.h>
void main()
{
int *ptr;
int i,n;
printf(“Enter size of array :”);
scanf(“%d”,&n);

UNIT V
213
ptr=(float *)calloc(n,sizeof(float));
if(ptr==NULL)
{
printf(“Memory cannot be allocated”);
exit(0);
}
printf(“Value in the allocated memory area”);
for(i=0;i<n;i++)
printf(“n ptr[%d] = %5.2f”,i,ptr[i]);
}
Output:
Value in the allocated memory area
ptr[0] = 0.00
ptr[1] = 0.00
ptr[2] = 0.00
Memory cannot be allocated
Difference Between Malloc and Calloc
There are two differences.
First, is in the number of arguments.
 Malloc() takes a single argument (memory required in bytes), while
calloc() needs two arguments.
 Secondly, malloc() does not initialize the memory allocated, while
calloc() initializes the allocated memory to ZERO.
 calloc() allocates a memory area, the length will be the product of its
parameters. calloc fills the memory with ZERO's and returns a pointer
to first byte. If it fails to locate enough space it returns a NULL
pointer.
Syntax: ptr_var=(cast_type *)calloc(no_of_blocks , size_of_each_block);
i.e. ptr_var=(type *)calloc(n,s);
 malloc() allocates a single block of memory of REQUSTED SIZE and
returns a pointer to first byte. If it fails to locate requsted amount of
memory it returns a null pointer.
Syntax: ptr_var=(cast_type *)malloc(Size_in_bytes);
realloc() function
 Used to increase or decrease size of memory previously allocated.
 All blocks are of same size. If memory allocated success it returns
address of new area through pointer variable else returns NULL.

UNIT V
214
 Original block of data is lost or freed.
 Allocates n blocks of memory space of size in bytes and returns
starting address of memory through pointer variable of type cast-type.
 Allocated memory space is filled with zeros if memory is initialized.
The general form of realloc function is
r=realloc(old_ptr,new_size);
where r is valid C variable already defined. old_ptr is the pointer variable
used in malloc() or calloc() function. new_size is the size of new memory
needed.
#include<stdio.h>
#include<alloc.h>
void main()
{
int *marks,i,n=0,add1,sum=0;
char ch;
printf(“Enter Number of subject for calculating total mark :”);
scanf(“%d”,&n);
printf(“Enter marks for %d subjects: ”,n);
marks=malloc(sizeof(int) *n);
for(i=0;i<n;i++)
{
scanf(“%d”,&marks[i]);
sum=sum+marks[i];
}
for(i=0;i<n;i++)
printf(“n Subject %d mark = %d”,i+1,marks[i]);
printf(“n Total marks of %d subjects are %d”,n,sum);
printf(“n Do u want to add some more subjects to the Previous list y/n:”);
if((ch=getche())!=’n’)
{
printf(“n Enter the additional number of subjects :”);
scanf(“%d”,&add1);
marks=realloc(marks,n *sizeof(int));
printf(“n Enter marks for additional %d subjects :”,add1);
for(i=0;i<add1;i++)
{ scanf(“%d”,&marks[n+i]);
sum=sum+marks[n+i];
}
n=n+add1;

UNIT V
215
}
for(i=0;i<n;i++)
printf(“n Subject %d mark = %df”,i+1,marks[i]);
printf(“n Total marks of %d subjects are %d”,n,sum);
free(marks);
}
Output
Enter Number of subject for calculating total mark : 3
Enter marks for 3 subjects: 85 78 93
Subject 1 mark = 85
Subject 2 mark = 78
Subject 3 mark = 93
Total marks of 3 subjects are 256
Do u want to add some more subjects to the Previous list y/n: y
Enter the additional number of subjects: 2
Enter marks for additional 2 subjects: 100 68
Subject 1 mark = 85
Subject 2 mark = 78
Subject 3 mark = 93
Subject 4 mark = 100
Subject 5 mark = 68
Total marks of 5 subjects are 424
free() function
Used to free (release or deallocate) block of unused / used memory. The
general form of realloc function is
free(pointer_variable);
where pointer_variable is a pointer to memory block which has been
already created by malloc() or calloc() function.

Unit v

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (20)

Similaire à Unit v

Similaire à Unit v (20)

Unit v