UNIT 5 FILE HANDLING AND GRAPHICS

File Management in C – Input / Output Operations on Files- Sequential Access - Text

File- Random Access - Binary File- The ‘C’ Pre-processor- Macro Substitution-
Command Line Arguments- Introduction to C Graphics- Sample Programs
5.1 Files Management in C

FILES

⚫ Files are places where data can be stored permanently.

⚫ In C, each file is simply a sequential stream of bytes. C imposes no structure on a
file.
⚫ A file must first be opened properly before it can be accessed for reading or writing.
When a file is opened, a stream is associated with the file.

Defining and opening file:

In order to define and open file we need

⚫ Filename (e.g. sort.c, input.txt)
⚫ Data structure (e.g. FILE)
Purpose (e.g. Reading, Writing, Appending)
Filename: String of characters that make up a valid file name.
May contain two parts
◆ Primary
◆ Optional period with extension
⚫ Examples: a.out, prog.c, temp, text.out

Data Structure:
FILE *fptr1, *fptr2 ;
The above statement declares that
⚫ fptr1 and fptr2 are pointer variables of type FILE.
⚫ They will be assigned the address of a file descriptor, that is, an area of memory
that will be associated with an input or output stream.

Purpose:
General format for opening file:
⚫ FILE *fp; /*variable fp is pointer to type FILE*/
⚫ fp = fopen(“filename”, “mode”); /*opens file with name filename , assigns
identifier to fp */
fp
contains all information about file
Communication link between system and program
Various modes of operation on files
⚫ r open file for reading only
⚫ w open file for writing only
⚫ a open file for appending (adding) data

5.2 Various modes of operations on files:

Writing mode
◆ If the file already exists then contents are deleted,
◆ Else a new file with specified name is created
Appending mode
◆ If the file already exists then the file is opened with contents and further updated.
◆ Else new file created
Reading mode
◆ If the file already exists then it is opened with contents.
◆ Else error occurs.
Ex:
FILE *p1, *p2, *p3;
p1 = fopen(“data”,”r”);
p2= fopen(“results”, w”);
p3= fopen(“results”, a”);

Closing a File:
File must be closed as soon as all operations on it completed.
Ensures
◆ All outstanding information associated with file flushed out from buffers
◆ All links to file broken
If we want to change mode of file, then first close and then open again.
Syntax: fclose(file_pointer);
Example:
FILE *p1, *p2;
p1 = fopen(“INPUT.txt”, “r”);
p2 =fopen(“OUTPUT.txt”, “w”);
……..
……..
fclose(p1);
fclose(p2);

5.3 SEQUENTIAL ACCESS FILE-TEXT FILE

The data items in a sequential access file are arranged one after another in a sequence.
Each data item can be accessed in the same order in which they have been stored. It is
only possible to read a sequential file from the beginning. To access a particular data
within the sequential access file, data has to be read one data at a time, until the required
data is reached. Reading data from a sequential file can be done using the various C
functions like fscanf(),fgets(), fgetc(), fread(). Writing data to a sequential file can be
done using the various C functions like fprintf(), fputs(), fputc(), fwrite().
Input and Output Operations with Files:

C provides several different functions for reading/writing in to files.

Some of them are
⚫ getc() – read a character
⚫ putc() – write a character
⚫ fprintf() – write set of data values
⚫ fscanf() – read set of data values

getc() and putc():

This function handles one character at a time.
Syntax: putc(c,fp1);
c : a character variable
fp1 : pointer to file opened with mode w
Syntax: c = getc(fp2);
c : a character variable
fp2 : pointer to file opened with mode r
File pointer moves by one character position after every getc() and putc()
getc() returns end-of-file marker EOF when file end reached

//Program for file manipulation using getc() and putc();

#include <stdio.h>
void main()
{
FILE *fp1;
char c;
f1= fopen(“INPUT”, “w”); /* open file for writing */
while((c=getchar()) != EOF) /*get char from keyboard until CTL-Z*/
putc(c,f1); /*write a character to INPUT */
fclose(f1); /* close INPUT */
f1=fopen(“INPUT”, “r”); /* reopen file */
 while((c=getc(f1))!=EOF) /*read character from file INPUT*/
printf(“%c”, c);/* print character to screen */
fclose(f1);
}

fprintf() and fscanf():

⚫ Syntax of fprintf():
fprintf(FILE *fp,"format-string",var-list);
⚫ Syntax of fscanf():
fscanf(FILE *fp,"format-string",var-list);

//Program for file manipulation using fprintf()

#include<stdio.h>
void main()
{
FILE *fp;
int roll;
char name[25];
float marks;
char ch;
fp = fopen("file.txt","w"); //Statement 1
if(fp == NULL)
{
printf("\nCan't open file or file doesn't exist.");
exit(0);
}

do
{
printf("\nEnter Roll : ");
scanf("%d",&roll);
printf("\nEnter Name : ");
 scanf("%s",name);
printf("\nEnter Marks : ");
scanf("%f",&marks); fprintf(fp,"%d%s%f",roll,name,marks);
printf("\nDo you want to add another data (y/n) : ");
ch = getche();
}while(ch=='y' || ch=='Y');
printf("\nData written successfully...");
fclose(fp);
}

Output :
Enter Roll : 1
Enter Name : Nilo
Enter Marks : 78.53
Do you want to add another data (y/n) : y
Enter Roll : 2
Enter Name : Nafees
Enter Marks : 89.62
Do you want to add another data (y/n) : n
Data written successfully…

//Program for file manipulation using fscanf()

#include<stdio.h>
void main()
{
FILE *fp;
char ch;
fp = fopen("file.txt","r"); //Statement 1
if(fp == NULL)
{
printf("\nCan't open file or file doesn't exist.");
exit(0);
}
 printf("\nData in file...\n");
while((fscanf(fp,"%d%s%f",&roll,name,&marks))!=EOF) //Statement 2
{
printf("\n%d\t%s\t%f",roll,name,marks);
}
fclose(fp);
}
Output :
Data in file...
1 Nilo 78.53
2 Nafees 89.62

EXAMPLE PROGRAM:
Finding average of numbers stored in sequential access file
#include <stdio.h>
#include <math.h>
// Read the numbers and return average
float average(FILE *input)
{
float term,sum;
int n;
sum = 0.0;
n = 0;
while(!feof(input))
{
fscanf(input,"%f",&term);
sum = sum + term;
n = n + 1;
}
return sum/n;
}
int main ()
{
FILE *input;
float avg;
}
input = fopen("data.txt","r");
avg = average(input);
fclose(input);
printf("The average of the numbers is %f.\n",avg);
return 0;
}
Output:
/* Data in data.txt
10 11 12 13 14 15. */
The average of the numbers is 12.5

5.4 Random File Access-Binary File

Random access files provide a robust mechanism for effectively manipulating data in
the C programming language. In contrast to sequential access files, which limit data
operations to sequential reading or writing, random access files allow direct access to
specific positions within the file. This unique capability empowers us to perform
various operations, including updating, inserting, or deleting data at any desired
location within the file.

FREAD():
fread in C is a standard library function used for reading binary data from a file. It is
part of the stdio.h library.

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

⚫ ptr: A pointer to the data buffer where the read data will be stored.
⚫ size: The size (in bytes) of each element to be read.
⚫ nmemb: The number of elements to read.
⚫ stream: A pointer to the FILE structure that represents the file from which data will
be read.
⚫ The function returns the number of elements successfully read, which may be less
than nmemb if there's an error or if the end of the file is reached.
⚫ fread is generally used for reading binary data, and if you want to read text data
from a file, you should use functions like fgets or fscanf.

FWRITE()
⚫ fwrite in C is a standard library function used for writing binary data from a file. It
is part of the stdio.h library.
⚫ fwrite is generally used for reading binary data, and if you want to read text data
from a file, you should use functions like fputs or fprintf.

size_t fwrite(void *ptr, size_t size, size_t nmemb, FILE *stream);

FSEEK()
fseek is a standard library function in C used for repositioning the file pointer within a
file. It allows you to move the file pointer to a specific location, enabling you to read
from or write to a particular position in the file.

int fseek(FILE *stream, long offset, int whence);

stream: A pointer to the FILE structure that represents the file you want to manipulate.
offset: The number of bytes to offset the file pointer from the position specified by the
whence parameter. It can be a positive or negative value.
whence: An integer that specifies the reference position for the offset. It can take one
of the following three values:
SEEK_SET (or 0): The offset is relative to the beginning of the file.
SEEK_CUR (or 1): The offset is relative to the current file position.
SEEK_END (or 2): The offset is relative to the end of the file.
fseek is useful when you need to read or write data at a specific location in a file or
when you want to skip a certain portion of the file.

Ftell():
ftell is a standard library function in C used to get the current file position indicator's
value for a given file stream. It allows you to determine the current offset of the file
pointer within the file.

long ftell(FILE *stream);

Frewind():
frewind is a standard library function in C used to reset the file position indicator to the
beginning of the file. It allows you to move the file pointer back to the start of the file,
effectively resetting its position.

void frewind(FILE *stream);

/ C Program to Read from a binary file using fread()

#include <stdio.h>
#include <stdlib.h>
struct threeNum
{
int n1, n2, n3;
}
int main()
{
int n;
struct threeNum num;
FILE* fptr;
if ((fptr = fopen("C:\\program.bin", "rb")) == NULL) {
printf("Error! opening file");
// If file pointer will return NULL
// Program will exit.
exit(1);
}
// else it will return a pointer to the file.
for (n = 1; n < 5; ++n)
{
fread(&num, sizeof(struct threeNum), 1, fptr);
printf("n1: %d\tn2: %d\tn3: %d\n", num.n1, num.n2, num.n3);
}
fclose(fptr);
return 0;
}
5.5 The C Pre-processor:

The C preprocessor is a program that processes C source code before it's compiled. It's
a text substitution tool that transforms the source code according to the preprocessor
directives.

How Does the C Preprocessor Work?

Here's a step-by-step overview:
Text Input: The preprocessor reads the C source code file.
Preprocessing: The preprocessor analyzes the code for directives.
Transformation: The preprocessor applies transformations based on directives.
Output: The transformed code is generated.

Preprocessor Directives:

Preprocessor directives start with the # symbol and are processed before compilation.
Some common directives include:
⚫ #include: Includes header files or other source files.
⚫ #define: Defines macros.
⚫ #undef: Undefines macros.
⚫ #ifdef: Conditional compilation based on macro definition.
⚫ #ifndef: Conditional compilation based on macro non-definition.
⚫ #if: Conditional compilation based on constant expressions.
⚫ #else: Specifies alternative code for conditional compilation.
⚫ #elif: Combines #else and #if.
⚫ #endif: Ends conditional compilation.
⚫ #pragma: Specifies implementation-defined behavior.

It operates under the following directives

⚫ File Inclusion
⚫ Macro substitution
⚫ Conditional inclusion

File Inclusion:
It is used to include some file that contains functions or some definitions.
Syntax:
#include<filename> (or)
#include“filename”
Eg: #include<stdio.h>
#include “ex.c”

Example:
#include<stdio.h>
#include<conio.h>
#include "addition.txt"
void main()
{
int a,b;
printf("\nEnter the numbers:");
scanf("%d%d",&a,&b);
printf("The Value is %d",add(a,b));
getch();
}
addition.txt:
int add(int a,int b)
{
return(a+b);
}
Output:
Enter the numbers:7
4
The Value is 11.
 Example:
#include<stdio.h>
#include<conio.h>
#include "fact.c"
void main()
{
int a;
printf("\nEnter the number:");
scanf("%d",&a);
printf("The factorial of %d! is %d",a,rec(a));
getch();
}

5.6 Macro Substitution:

It is used to define and use integer, string, or identifier in the source program
The three forms of macros are
⚫ Simple Macro
⚫ Argumented Macro
⚫ Nested Macro

Simple Macro:
⚫ It is used to define some constants
Syntax
# define identifier string/integer
Eg:
#define pi 3.14
#define CITY “chennai”

Example:
#include<stdio.h>
#include<conio.h>
#define pi 3.14
#define CITY "chennai"
void main()
{
printf("The Value is %f",2*pi);
printf("\nThe Value CITY is %s",CITY);
getch();
}
Output:
The Value is 6.280000
The Value CITY is chennai.

Argumented Macro:
It is used to define some complex forms in the source program.
Syntax:
#define identifier (v1,v2,….) string/integer
Eg:
#define cube(n) (n*n*n)

#include<stdio.h>
#include<conio.h>
#define cube(n) (n*n*n)
void main()
{
printf("The Value of 3 cube is %d",cube(3));
getch();
}

Output:
The Value of 3 cube is 27.

Nested Macro

• Here one macro is used by another macro.

• Eg:
#define a 3
#define sq a*a
Example:
#include<stdio.h>
#include<conio.h>
#define a 3
#define sq a*a
void main()
{
printf("The Value is %d",sq);
getch();
}
Output:
The Value is 9

Conditional Inclusion:
• It is used to include some conditional statements.

#include<stdio.h>
#include<conio.h>
#define a 3
#ifdef a
#define c a+5
#endif
void main()
{
printf("\nThe value C is %d",c);
getch();
}
Output:
The value C is 8
5.7 Command Line Arguments:

Instead of invoking the input statement from inside the program, it is possible to pass
data from the command line to the main() function when the program is executed. These
values are called command line arguments.
Command line arguments are important for your program, especially when you want to
control your program from outside, instead of hard coding those values inside the code.
to write a C program "hello.c" that prints a "hello" message for a user. Instead of
reading the name from inside the program with scanf(), we wish to pass the name from
the command line as follows −

C:\users\user>hello Prakash

The string will be used as an argument to the main() function and then the "Hello
Prakash" message should be displayed.
argc and argv

To facilitate the main() function to accept arguments from the command line, you
should define two arguments in the main() function – argc and argv[].

argc refers to the number of arguments passed and argv[] is a pointer array that points
to each argument passed to the program.

int main(int argc, char *argv[]) {

...
...
return 0;
}
The argc argument should always be non-negative. The argv argument is an array of
character pointers to all the arguments, argv[0] being the name of the program. After
that till "argv [argc - 1]", every element is a command-line argument.

Open any text editor and save the following code as "hello.c" −

#include <stdio.h>
int main (int argc, char * argv[]){
printf("Hello %s", argv[1]);
return 0;
}
The program is expected to fetch the name from argv[1] and use it in the printf()
statement.

5.8 Graphics Program in C:

Graphics programming in C opens up a realm of creative possibilities, allowing
developers to generate visual representations, animations, and interactive applications.
Whether creating simple graphics or user interfaces, mastering the principles of
graphics programming is essential.
Syntax of Graphics Program in C

initgraph(int *gm, int *gm, char *driverDirectoryPath);

Explanation of Syntax
This function initializes the graphics driver and sets the graphics mode. The first
parameter (gd) is a pointer to the graphics driver, which is set to DETECT to detect the
graphics driver automatically. The second parameter (gm) is the graphics mode, which
specifies the resolution and color depth of the screen. The last parameter is a string that
can be used to pass additional arguments to the graphics driver, but in this case, it’s left
empty.

Example:
#include<graphics.h>
#include<conio.h>
void main()
{
intgd=DETECT,gm;
initgraph (&gd,&gm,"c:\\tc\\bgi");
setbkcolor(GREEN);
printf("\t\t\t\n\nLINE");
line(50,40,190,40);
printf("\t\t\n\n\n\nRECTANGLE");
rectangle(125,115,215,165);
printf("\t\t\t\n\n\n\n\n\n\nARC");
arc(120,200,180,0,30);
printf("\t\n\n\n\nCIRCLE");
circle(120,270,30);
printf("\t\n\n\n\nECLIPSE");
ellipse(120,350,0,360,30,20);
getch();
}

Output: