Unit 5

Structure
 Syllabus
• Structures: Defining structures and Array of Structures,
• Pointers: Idea of pointers, Defining pointers, Use of Pointers
in self-referential structures, notion of linked list (no
implementation), bit-fields.
• File handling: concept of a file, text files and binary files,
Formatted I/O, file I/O operations(functions), example
programs
 Structures
• Array is a collection of same type of elements but in many real life
applications we may need to group different types of logically related data.
• For example if we want to create a record of a person that contains name,
age and height of that person, then we can't use array because all the three
data element are of different types.

• To store these related fields of different data types we can use a structure,
which is capable of store heterogeneous data. Data of different types can be
grouped together under a single name using structure. The data elements of
a structure are referred to as members.
 DEFINING A STRUCTURE
• Definition of a structure creates a template or format that describes the
characteristics of its members.
• All the variables that would be declared of this structure type, will take the
form of this template, general syntax of a structure definition is
struct tagname {
data type memberl;
datatype member2;
….………………
….……………….
datatype memberN;
};

• Here struct is a keyword, which tells the compiler that a structure is being
defined. member1, member2...............memberN are known as members of the
structure and are declared inside curly braces.
• These members can be of any data type like int, char, float, array, pointers or
another structure type. tagname is the name of the structure and it is used
further in the program to declare variables of this structure type.
 Example
Let us take an example of defining a structure template.
struct student{
char name [20] ;
int rollno;
float marks;
};

Here student is the structure tag and there are three members of this
structure viz name, rollno and marks.
Structure template can be defined globally or locally i.e. it can be
placed before all functions in the program or it can be locally present in
a function.
If the template is global then it can be used by all functions while if it is
local then only the function containing it can use it.
 DECLARING STRUCTURE VARIABLES
• By defining structure we have only created a format, the actual
use of structures will be when we declare variables based on
this format. We can declare structure variables in two ways
– With structure definition
– Using the structure tag
 With Structure Definition
struct student{
char name [20] ;
int rollno;
float marks;
}stu1,stu2,stu3;
Here stu1, stu2 and stu3are variables of type struct student. When we declare a
variable while defining the structure template, the tagname is optional. So we can
also declare them as-
• structure{
char name [20] ;
int rollno;
float marks;
}stul,stu2,stu3;
If declare variables in this way, then we'll not be able to declare other variables of
this structure type anywhere else in the program nor can we send these structure
variables to functions. If a need arises to declare a variable of this type in the
program then we'll have to write the whole template again. So although the
tagname is optional it is always better to specify a tagname for the structure.
 Using Structure Tag
We can also declare structure variables using structure tag. This can be written
as-
– struct student{
– char name [20] ;
– int rollno;
– float marks;
– };
• struct student stu1, stu2;
• struct student stu3;

• Here stu1, stu2 and stu3 are structure variables that are declared using the
structure tag student. Declaring a structure variable reserves space in
memory.
• Each structure variable declared to be of type struct student has three
members viz. name, rollno and marks.
• The compiler will reserve space for each variable sufficient to hold all the
members. For example each variable of type struct student will occupy 26
(20+2+4) bytes.
 INITIALIZATION OF STRUCTURE
VARIABLES
The syntax of initializing structure variables is similar to that of arrays. All the
values are given in curly braces and the number, order and type of these values
should be same as in the structure template definition. The initializing values
can only be constant expressions.

struct student {
char name [20] ;
int rollno;
float marks;
}stu1={"Mary”,25,98};
struct student stu2={ "John”, 24, 67. 5};

Here value of members of stu1 will be "Mary" for name, 25 for rollno, 98 for
marks. The value of members of stu2will be "John"for name, 24 for rollno,
67.5 for marks.
We cannot initialize members while defining the structure.
 Initialization
struct student {
char name [20] ;
int rollno;
float marks=99; / * Invalid * /
}stu;

This is invalid because there is no variable called marks, and no memory is

allocated for structure definition. If the number of initializers is less than the
number of members then the remaining members are initialized with zero. For
example if we have this initialization

Struct student stu1 = {"Mary"};

Here the members rollno and marks of stul will be initialized to zero. This is
equivalent to the initialization

struct student stul = {"Mary", 0, 0};

 ACCESSING MEMBERS OF A STRUCTURE
For accessing any member of a structure variable, we use the dot (.) operator which is
also known as the period or membership operator. The format for accessing a structure
member is
struct [Link]
For example consider the following structure-
struct student {
char name [20] ;
int rollno;
float marks;
};
struct student stul,stu2;

name of stu1 is given by - [Link]

rollno of stu1 is given by - [Link]
marks of stu1 is given by - [Link]
name of stu2 is given by - [Link]
rollno of stu2 is given by - [Link]
marks of stu2 is given by - [Link]
 Program 1
//Program to display the values of structure members.
#include<stdio.h>
#include<string.h>
struct student{
char name[20] ;
int rollno;
float marks;
};
int main()
{
struct student stul= {"Mary" ,25,68};
struct student stu2, stu3;
strcpy([Link], "John");
[Link]=26;
[Link]=98;
printf("Enter name, rollno and marks for stu3 : ");
scanf("%s %d %f",[Link],&[Link],&[Link]);
printf("stul : %s %d %.2f\n",[Link],[Link],[Link]);
printf("stu2: %s %d %.2f\n", stu2. name, stu2. rollno,[Link]) ;
printf("stu3 : %s %d %.2f\n", stu3 .name, stu3. rollno,[Link]);
 ASSIGNMENT OF STRUCTURE
VARIABLES
We can assign values of a structure variable to another structure variable, if both variables are
defined of the same structure type. For example-
Program 2: Program to assign a structure variables to another structure variable.
#include<stdio.h>
struct student {
char name[20];
int rollno;
float marks;
};
main ( )
{
struct student stul={"Oliver",12,98};
struct student stu2;
stu2=stul;
printf("stul %s %d %.2f\n", [Link], stul. rollno, [Link]) ;
printf("stu2 %s %d %.2f\n", stu2 .name, stu2. rollno, stu2 .marks) ;
}

Output:
 STORAGE OF STRUCTURES IN
MEMORY
The members of structures are stored in consecutive memory locations.
Program 3: Program to show that members of structure are stored in consecutive
memory locations.
#include<stdio.h>
main()
{
struct student {
char name[5];
int rollno;
float marks;
}stu;
printf("Address of name = %u \n",[Link]);
printf("Address of rollno = %u\n",&[Link]);
printf("Address of marks = %u\n" ,&[Link]);
}

Output:
 ARRAY OF STRUCTURES
• We know that array is a collection of elements of same
datatype. We can declare array of structures where each
element of array is of structure type. Array of structures can
be declared as

• struct student stu[10];

• stu is an array of 10 elements, each of which is a structure

of type struct student, means each element of stu has 3
members, which are name, rollno and marks.
• These structures can be accessed through subscript notation.
• To access the individual members of these structures we
will use the dot operator as usual.
ARRAY OF STRUCTURES
 Program
//Program to understand array of structures.
4
#include<stdio.h>
struct student {
char name[20];
int rollno;
float marks;
};
main()
{
int i;
struct student stuarr[4] ;
for(i=0;i<4;i++)
{
printf ("Enter name, ro1lno and marks ");
scanf("%s%d%f",stuarr[i].name,&stuarr[i].rollno,&stuarr[i].marks);
}
for(i=0;i<4;i++)
printf("%s %d %f \n",stuarr[i].name,stuarr[i].rollno,stuarr[i].marks);
}
Output:
 ARRAYS WITHIN STRUCTURES
We can have an array as a member of structure.
In structure student, we have taken the member name as an array of characters. Now we'll declare
another array inside the structure student.
struct student {
char name [20] ;
int rollno;
int submarks [4] ;
};
The array submarks denotes the marks of students in 4 subjects.
If stu is a variable of type struct student then-
[Link][0] - Denotes the marks of the student in first subject
[Link][l] - Denotes the marks in second subject.
[Link][0] - Denotes the first character of the name member.
[Link][4] - Denotes the fifth character of the name member.

If arr[10] is an array of type struct student then

stuarr[0].submarks[0] - Denotes the marks of first student in first subject
stuarr[4].submarks[3] -Denotes the marks of fifth student in fourth subject.
stuarr[0].name[0] - Denotes the first character of name member of first student
stuarr[5].name[7] - Denotes the eighth character of name member of sixth student
 Program 5
Program to understand arrays within structures.
#include<stdio.h>
struct student {
char name[20];
int rollno;
int submarks[4];
};
int main()
{
int i;
struct student stu;
printf ("Enter name: ") ;
scanf("%s",[Link]);
printf ("Enter roll: ") ;
scanf (" %d", &[Link]) ;
for(i=0;i<4;i++)
{
printf ("Enter marks for subject %d:",i+ 1) ;
scanf("%d",&[Link][i]);
}
printf("student detail is\n");
printf("Name: %s\nRoll: %d\nMarks :", [Link],[Link]);
for(i=0;i<4;i++)
printf("%d ",[Link][i]);
 Program 6
//Program to understand arrays within
structures. for(j=0;j<4;j++)
#include<stdio.h> {
struct student {
printf ("Enter marks for subject %d:",j + 1)
char name[20];
;
scanf("%d",&stuarr[i].submarks[j]);
int rollno;
}
int submarks[4];
}
}; for(i=0;i<3;i++)
main() {
{ printf("Data of student %d\n", i+1);
int i,j; printf("Name %s, Roll number %d\nMarks
struct student stuarr[3] ; :", stuarr[i].name,stuarr[i].rollno);
for(i=0;i<3;i++) for(j=0;j<4;j++)
{ printf("%d ",stuarr[i].submarks[j]);
printf("Enter data for student %d\n", i+1); printf ("\n");
printf ("Enter name ") ; }
scanf("%s",stuarr[i].name); }
printf ("Enter roll number ") ;
scanf (" %d", &stuarr[i].rollno) ;
Output
Write a program which will take the details of 50 employees as input and display
the same. The details include eid and name
#include<stdio.h>
struct Employee
{
char eid[20] ;
char name[30];
char department[20] ;
};
main()
{
int i;
struct Employee E[50] ;
for(i=0;i<50;i++)
{
printf ("Enter eid, name and department ");
scanf("%s%s%s",E[i].eid,E[i].name,E[i].department);
}
for(i=0;i<50;i++)
printf("%s %s %s\n",E[i].eid,E[i].name,E[i].department);
}
Output:
 WAP to define a structure employee having fields empid, empname, salary, store
the record for n employees and only display records of those employees who have
salary max than 10000.
for(i=0;i<n;i++)
#include<stdio.h> {
struct employee printf("Employee Number: ");
{ scanf("%d",&emp[i].eno);
int eno;
char ename[20];
printf("Name : ");
int salary; scanf("%s",emp[i].ename);
}emp[10]; printf("Salary : ");
int main() scanf("\n %d",&emp[i].salary);
{ printf("-----------------------------\n");
int i,n; }
printf("/*How many employee info\nyou printf("Highest salary employee details:");
want to accept : ");
printf("Enter Limit: "); printf("\n-----------------------------\n");
scanf("%d",&n); printf("EMPNO NAME SALARY\n");
printf("-----------------------------\n"); for(i=0;i<n;i++)
printf("Enter details for %d {
employees:",n); if(emp[i].salary>10000)
printf("\n-----------------------------\n");
printf("%d\t%s\t%d",emp[i].eno,emp[i].ename,emp[i]
.salary);
}
return 0;
}
Output :
Create a structure student to store the name, roll no and percentage of a student.
Populate the structure array with the details of fifty students and print the details of
the student with maximum marks.
#include<stdio.h>
struct student {
char name[20];
int rollno;
float percentage;
};
main()
{
int i,j;
struct student stuarr[50] ;
for(i=0;i<50;i++){
printf ("Enter name, ro1lno and percentage ");
scanf("%s%d%f",stuarr[i].name,&stuarr[i].rollno,&stuarr[i].percentage);}
for(i=0;i<50 ;i++){
printf("%f",stuarr[i].percentage);
if(stuarr[0].percentage<stuarr[i].percentage)
{
stuarr[0].percentage=stuarr[i].percentage;
} }
printf("%f ",stuarr[0].percentage);}

Output :
Pointers
 POINTER CONCEPT
• C is a very powerful language and the real power of C lies in
pointers.
• The concept of pointers is interesting as well as challenging.
• It is very simple to use pointers provided the basics are understood
thoroughly.
• So it is necessary to visualize every aspect of pointers instead of
just having a superficial knowledge about their syntax and usage.
• The use of pointers makes the code more efficient and compact.

• Some of the uses of pointers are- -

(i) Accessing array element.
(ii) Returning more than one value from a function.
(iii) Accessing dynamically allocated memory.
(iv) Implementing data structures like linked lists, trees, and graphs.
 About Memory
• Before studying pointers it is important to understand how memory is
organized in a computer.
• The memory in a computer is made up of bytes arranged in a sequential
manner.
• Each byte has an index number, which is called the address of that byte.
The address of these bytes start from zero and the address of last byte is
one less than the size of memory. Suppose we have 64 MB of RAM, then
memory will consist of 64 * 220 = 67108864 bytes.
• The address of these bytes will be from 0 to 67108863.

• Now let us see what happens when we declare a variable. Suppose we

declare a variable age of type int
• int age;
• The compiler reserves 2 consecutive bytes from memory for this variable
and associates the name age with it. The address of first byte from the two
allocated bytes is known as the address of variable age.
 Address Operator
• C provides an address operator ‘&’ which returns the address,
of a variable when placed before it.
• This operator can be read as "the address of ", so &age means
address of age, similarly &sal means" address of sal.
 Program 1
//Program to print the address of variables using address operator.

#include<stdio.h>
void main( )
{
int age=30;
float sal=1500.50;
printf ("Value of age=%d,Address of age= %u\n",age,&age);
printf ("Value of sal=%f, Address of sal= %u\n",sal,&sal);
}

Output:
 POINTER VARIABLE
• A pointer is a variable that stores memory address.
• Like all other variables it also has a name, has to be declared
and occupies some space in memory.
• It is called pointer because it points to a particular location in
memory by storing the address of that location.
 Declaration of Pointer Variables
• Like other variables, pointer variables should also be declared before being used.
The general syntax of declaration is
• data_ type *pname;
Here,
• pname → is the name of pointer variable, which should be a valid C identifier.
• asterisk * → preceding this name informs the compiler that the variable is declared
as a pointer.
Here data type is known as the base type of pointer. Let us take some pointer
declarations
• int *iptr;
• float *fptr;
• char *cptr;
• Here iptr is a pointer that should point to variables of type int, similarly fptr and
cptr should point to variables of float and char type respectively.
• Pointers are also variables so compiler will reserve space for them and they will
also have some address.
• All pointers irrespective of their base type will occupy same space in memory since
all of them contain addresses only.
 Initialization of pointer variables
• When we declare a pointer variable it contains garbage value i.e, it may be pointing
anywhere in the memory.
• So we should always assign an address before using it in the program. The use of
an unassigned pointer may give unpredictable results and even cause the program to
crash.
• Pointers may be assigned the address of a variable using assignment statement.

For example:
• int *ptr, age = 30;
• float *fptr, sal = 1500.50;
• iptr = &age;
• ptr = &sal;

• Now iptr contains the address of variable age i.e. it points to variable age, similarly
fptr points to variable sal. Since iptr is declared as a pointer of type, int, we should
assign address of only integer variables to it.
• If we assign address of some other data type then compiler won't show any
error ,but the output will be incorrect.
Example
 Initialization of pointer variables
• We can also initialize the pointer at the time of declaration.
But in this case the variable should be declared before the
pointer. For example
• int age = 30, *iptr = &age;
• float sal = 1500.50, *fptr = &sal;

• It is also possible to assign the value of one variable to the

other, provided their base type is same. For example if we
have an integer pointer p1 then we can assign the value of
iptr to it as:
• p1=iptr;
• Now both pointer variables iptr and p1 contain the address
of variable age and point to the same variable age.
Example
 Continued...........
• We can assign constant zero to a pointer of any type.
• A symbolic constant NULL is defined in stdio.h, which
denotes the value zero.
• The assignment of NULL to a pointer guarantees that it does
not point to any valid memory location. This can be done as

• ptr = NULL;
 Dereferencing Pointer Variables
• Till now we have done a lot of programming and in all our
programs we have used the name of a variable for accessing it.
• We can also access a variable indirectly using pointers.
• For this we will use the indirection operator(*).
• By placing the indirection operator before a pointer variable,
we can access the variable whose address is stored in the
pointer. Let us take an example
• int a = 87
• float b= 4.5;
• int *p1 = &a;
• float *p2 = &b;
 Continued….
• The indirection operator can be read as 'value at the
address'.
• For example *pl can be read as value at the address p1.
• This indirection operator (*) is different from the asterisk that
was used while declaring the pointer variable.
 Continued….
• In our program, if we place ‘*’ before p1 then we can access the variable
whose address is stored in p1.
• Since p1 contains the address of variable a, we can access the variable a by
writing *p1.
• Similarly we can access variable b by writing *p2. So we can use *pl and
*p2 in place of variable names a and b anywhere in program.
•
 Program 2
//Program to dereference pointer variables.
#include<stdio.h>
void main()
{
int a=87;
float b=4.5;
int *p1=&a;
float *p2=&b;
printf ("Value of pl =Address of a=%u\n",p1);
printf ("Value of p2 =Address of b=%u\n",p2);
printf ("Address of pl %u \n" ,&p1) ;
printf ("Address of p2 %u \n", &p2) ;
printf( "Value of a=%d %d %d\n",a,*p1,*(&a)) ;
printf ("Value of b=%f %f %f\n",b,*p2,*(&b)) ;
}

Output:
 Self Referential Structures
• Self Referential structures are those structures that have one or
more pointers which point to the same type of structure, as
their member.
 Continued…
• In other words, structures pointing to the same type of
structures are self-referential in nature.
• Example:

struct node {
int data1;
char data2;
struct node* link;
};

int main()
{
struct node ob;
return 0;
}
 Continued…
• In the above example ‘link’ is a pointer to a structure of type
‘node’.
• Hence, the structure ‘node’ is a self-referential structure with
‘link’ as the referencing pointer.
•
An important point to consider is that the pointer should be
initialized properly before accessing, as by default it contains
garbage value.
 Types of Self Referential Structures

• Self Referential Structure with Single Link

• Self Referential Structure with Multiple Links
 Self Referential Structure with Single
Link:
• These structures can have only one self-pointer as their
member.
• The following example will show us how to connect
the objects of a self-referential structure with the single
link and access the corresponding data members.
• The connection formed is shown in the following
figure.
 Program 3
#include <stdio.h>
struct node ob2; // Node2
struct node {
int data1; // Initialization
char data2; [Link] = NULL;
struct node* link; ob2.data1 = 30;
}; ob2.data2 = 40;

int main() // Linking ob1 and ob2

{ [Link] = &ob2;
struct node ob1; // Node1
// Accessing data members of ob2 using ob1
// Initialization printf("%d", [Link]->data1);
[Link] = NULL; printf("\n%d", [Link]->data2);
ob1.data1 = 10; return 0;
ob1.data2 = 20; }

Output:30 40
 Self Referential Structure with
Multiple Links
• Self referential structures with multiple links can have more
than one self-pointers.
• Many complicated data structures can be easily constructed
using these structures.
• Such structures can easily connect to more than one nodes at a
time.
• The following example shows one such structure with more
than one links.
• The connections made in the above example can be understood
using the following figure.
Continued….
 Bit Fields
• In C, we can specify size (in bits) of structure and union
members.
• The idea is to use memory efficiently when we know that the
value of a field or group of fields will never exceed a limit or
is within a small range.
• For example, consider the following declaration of date
without the use of bit fields.
 Program 4
#include <stdio.h>
struct date
{
unsigned int d;
unsigned int m;
unsigned int y;
};
int main()
{
printf("Size of date is %lu bytes\n",sizeof(struct date));
struct date dt = { 31, 12, 2014 };
printf("Date is %d/%d/%d", dt.d, dt.m, dt.y);
}}

Output: Size of date is 12 bytes Date is 31/12/2014

 Continued….
• The above representation of ‘date’ takes 12 bytes on a
compiler where an unsigned int takes 4 bytes.
• Since we know that the value of d is always from 1 to 31, the
value of m is from 1 to 12, we can optimize the space using bit
fields.
 Program 5
#include <stdio.h>
// Space optimized representation of the date
struct date {
// d has value between 1 and 31, so 5 bits
// are sufficient
unsigned int d : 5;
// m has value between 1 and 12, so 4 bits
// are sufficient
unsigned int m : 4;
unsigned int y;
};
int main()
{
printf("Size of date is %lu bytes\n", sizeof(struct date));
struct date dt = { 31, 12, 2014 };
printf("Date is %d/%d/%d", dt.d, dt.m, dt.y);
return 0;
}
Output: Size of date is 8 bytes Date is 31/12/2014
FILE HANDLING
 FILE HANDLING
• The input and output operations that we have performed so far
were done through screen and keyboard only.
• After termination of program, all the entered data is lost
because primary memory is volatile. If the data has to be used
later, then it becomes necessary to keep it in permanent storage
device.
• C supports the concept of files through which data can be
stored on the disk or secondary storage device. The stored data
can be read whenever required.
• A file is a collection of related data placed on the disk.
 FORMAT FOR STORING DATA IN FILES

There are two ways of storing data in files,

• Binary format and
• Text format
Difference between Text format and
Binary format
Difference between Text format and
Binary format
 STEPS FOR FILE OPERATIONS

Steps for file operations in C programming are as follows-

• Open a file
• Read data from a file or Write data to a file
• Close a file
 Opening a File
• A file must be opened before any I/O operations can be performed on that
file.
• The process of establishing a connection between the program and file is
called opening the file.
• A structure named FILE is defined in the file stdio.h that contains all
information about the file like name, status, buffer size, current position,
end of file status etc. All these details are hidden from the programmer and
the operating system takes care of all these things.
• A file pointer is a pointer to a structure of type FILE. Whenever a file is
opened, a structure of type FILE is associated with it, and a file pointer that
points to this structure identifies this file.
 fopen()
• The function fopen( ) is used to open a file.
Declaration:
FILE *fopen( const char *filename, const char *mode);
fopen( ) → function takes two strings as arguments.
• The first one is the name of the file to be open and the second one is the
mode that decides which operations(read, write, append etc) are to
performed on the file.
• On success, fopen( ) returns a pointer of type FILE and on error it returns
NULL. The return value of fopen( ) is assigned to a FILE pointer declared
previously.
For example:
FILE *fpl, *fp2; . ,
• fp1 = fopen( "myfile. txt", "w" );
• fp2 = fopen( "yourfile:dat", "r" );
 FILE OPENING MODES
• To open a file in binary mode we can append 'b' to the mode, and to open
the file in text mode 't' can be appended to the mode.
• But since text mode is the default mode, 't' is generally omitted while
opening files in text mode.
• For example-

“wb” Binary file opened in write mode

“ab+” or "a+b" Binary file opened in append mode
"rt+” or "r+t"" Text file opened in update mode
“w” Text file opened in write mode
 FILE OPENING MODES
“w” (write): If the file doesn't exist then this mode creates a new file for writing, and
if the file already exists then the previous data is erased and the new data entered is
written to the file.
"a"(append): If the file doesn't exist then this mode creates a new file, and if the file
already exists then the new data entered is appended at the end of existing data. In this
mode, the data existing in the file is not erased as in “w” mode.
"r" (read): This mode is used for opening an existing file for reading purpose only.
The file to be opened must exist and the previous data of file is not erased.
"w+" (write+read ): This mode is same as "w" mode but in this mode we can also
read and modify the data. If the file doesn't exist then a new file is created and if the file
exists then previous data is erased.
"r+" (read+write): This mode is same as "r" mode but in this mode we can also write
and modify existing data. The file to be opened must exist and the previous data of file
is not erased. Since we can add new data modify existing data so this mode is also
called update mode.
“a+" (appeand+read): This mode is same as the "a" mode but in this mode we can
also read the data stored in the file. If the file doesn't exist, a new file is created and if
the file already exists then new data is appended at the end of existing data. We cannot
modify existing data in this mode.
 Program 1: w mode
#include <stdio.h>
int main ()
{
char ch[80]="We are in 2021";
FILE * fp;
fp = fopen ("[Link]", "w");
fprintf(fp, "%s", ch);
fclose(fp);
}

Output:
 Program 2: r mode
#include<stdio.h>
int main()
{
FILE *fp;
char ch;
fp = fopen("[Link]","r");
while(fscanf(fp,"%c",&ch)!=EOF)
printf("%c",ch) ;
fclose(fp);
return(0);
}

output:
 Program 3: a mode
#include <stdio.h>
int main ()
{
FILE * fp;
fp = fopen ("[Link]", "a");
fprintf(fp, "%s ", "We are going in 2022”);
fclose(fp);
return(0);
}

Output :
 Program 4: r+ mode
#include <stdio.h>
int main() {
FILE *fp;
char ch;
fp = fopen("[Link]","r+");
while(fscanf(fp,"%c",&ch)!=EOF)
printf("%c",ch) ;
fprintf(fp, "%s", "We are indians");
fclose(fp);
return(0);
}

Output:
 Program 5: a+ mode
#include <stdio.h>
int main() {
FILE *fp;
char ch;
fp = fopen("[Link]","a+");
while(fscanf(fp,"%c",&ch)!=EOF)
printf("%c",ch) ;
fprintf(fp, "%s %s %s %d", "We", "are", "in", 2019);
fclose(fp);
return(0);
}

Output:
 Program 6: w+ mode
#include <stdio.h>
int main() {
FILE *fp;
char ch;
fp = fopen("[Link]","w+");
fprintf(fp, "%s", "We are in 2019");
fseek(fp,0L,0);
while(fscanf(fp,"%c",&ch)!=EOF)
printf("%c",ch) ;
fclose(fp);
return(0);
}
Output :
 Closing a File
• The file that was opened using fopen () function must be closed when no more operations are
to be performed on it. After closing the file, connection between file and program is broken.

Declaration:
• int fclose(FILE *fptr);

• Although all the files are closed automatically when the program terminates normally, but
sometimes it may be necessary to close the file by fclose( ).
• If more than one files are opened, then we can close all the files by calling fclose( ) for each
• fclose(fptrl) ;
• fclose(fptr2) ;
 I/O OPERATIONS/FUNCTIONS

• The functions used for file I/O are

Character I/O fgetc(), fputc( )

Integer I/O getw( ), putw( )
String I/O fgets( ), fputs( )
Formatted I/O fscanf( ), fprintf( )
Record I/O fread( ), fwrite( )
 Character I/O

fputc ( )
• Declaration: int fputc( int c, FILE *fptr);
• The function writes a character to the specified file at the
current file position and then increments the file position
pointer.
• On success it returns an integer representing the character
written, and on error it returns EOF.
 Program 7
//Program to understand the use of fputc() function.
#include<stdio.h>
int main()
{
FILE *fptr;
int ch;
fptr=fopen("[Link]","w");
printf("enter text:\n");
while ((ch=getchar())!=EOF)
fputc(ch,fptr);
fclose(fptr);
}
Output:
 fgetc()

Declaration: int fgetc( FILE *fptr );

• This function reads a single character from a given file and increments the file
pointer position.
• On success it returns the character after converting it to an int.
• On error it returns EOF.
 Program 8
//Program to understand the use of fgetc() function.

#include<stdio.h>
main()
{
FILE *p;
int ch;
p=fopen("[Link]","r");
while((ch=fgetc(p))!=EOF)
printf("%c",ch);
fclose(p);
}

Output:
 Integer I/O

• putw ( )
Declaration: int putw(int value, FILE *fp)
• putw function is used to write an integer into a
file.
• In a C program, we can write integer value in a
file as below.
putw(i, fp);
• where
i – integer value
fp – file pointer
 Program 9
//Program to understand the use of putw() function.
#include<stdio.h>
main()
{
FILE *fptr;
int value;
fptr=fopen("[Link]","w");
value=65;
putw(value,fptr);
fclose(fptr);
}
Output:
 getw()

Declaration: int getw( FILE *fp );

• getw function reads an integer value from a
file pointed by fp. In a C program, we can read
integer value from a file as below.
getw(fp);
 Program 10
//Program to understand the use of getw() function.
#include<stdio.h>
main()
{
FILE *fptr;
int value;
fptr=fopen("[Link]","r");
while((value=getw(fptr))!=EOF)
printf("%d\t",value);
fclose(fptr);
}
Output:
 String I/O

• fputs()
• Declaration: int fputs(const char *str, FILE *fptr);
• This function writes the null terminated string pointed to by str
to a file.
• The null character that marks the end of string is not written to
the file.
• On success it returns the last character written and on error it
returns EOF.
 Program 11
Program to understand the use of fputs() function.
#include<stdio.h>
main()
{
FILE *fptr;
char str[80]= "Tom and Jerry are Good Friends..";
fptr=fopen("[Link]","w");
fputs(str,fptr);
fclose(fptr);
}
Output :
 fgets( )

• Declaration: char *fgets(char *str, int n, FILE *fptr);

• This function is used to read characters from a file and these
characters are stored in the string pointed by str.
• It reads at most n-1 characters from the file where n is the
second argument.
• fptr is a file pointer which points to the file from which
characters are read.
• This function returns the string point to by str on success, and
on error or end of file it returns NULL.
 Program 12
//Program to understand the use of fgets() function.
#include<stdio.h>
main()
{
FILE *fptr;
char str[80];
fptr=fopen("[Link]","r");
while((fgets(str,80,fptr))!=NULL)
puts(str);
fclose(fptr);
}

Output:
 Formatted I/O

• fprintf ( )
• fprintf ( FILE *fptr, const char *format [, argument, ... ] );
• This function is same as the printf ( ) function but it writes formatted data
into the file instead of standard output (screen). This function has same
parameters as in printf( ) but it has one additional parameter which is a
pointer of FILE type, that points to the file to which the output is to be
written. It returns the number of characters· output to the file on success,
and EOF on error.
 Program 13
//Program to understand the use of fprintf() function.

#include<stdio.h>
main()
{
FILE *fp;
char name[10];
int age;
fp=fopen("[Link]","w") ;
printf("Enter your name and age");
scanf("%s%d",name,&age) ;
fprintf(fp,"My name is %s and age is %d",name,age);
fclose(fp) ;
}

Output:
 Program
Program to understand the use of fprintf() function.
14
#include<stdio.h>
struct student{
char name[20];
float marks;
}stu;
main()
{
FILE *fp;
int i,n;
fp=fopen("[Link]","w");
printf("Enter number of records ");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
printf("Enter name and marks");
scanf("%s%f",[Link],&[Link]);
fprintf(fp,"%s %f",[Link],[Link]);
}}
Output:
 fscanf ( )

• Declaration: fscanf ( FILE *fptr, const char

*format [, address, ... ] );
• This function is similar to the scanf ( ) function
but it reads data from file instead of standard
input, so it has one more parameter which is a
pointer of FILE type and it points to the file from
which will be read. It returns the number of
arguments that were assigned some values on
success, and at the end of file.
 Program 15
//Program to understand the use of fscanf() function.

#include<stdio.h>
struct student{
char name[20];
float marks;
}stu;
main()
{
FILE *fopen(),*fp;
fp=fopen("[Link]","r");
printf ("NAME\tMARKS\n");
while(fscanf(fp,"%s%f",[Link],&[Link])!=EOF)
printf("%s\t%f\n",[Link],[Link]) ;
fclose(fp) ;
}

Output:
 Record I/O
fwrite( ): The fwrite() function is used to write records (sequence of
bytes) to the file. A record may be an array or a structure.

Declaration: size_t fwrite( const void *ptr, size_t size, size_t n, FILE *fptr );

size_t→ is defined in stdio.h as

typedef unsigned int size_t ;

ptr→ is a pointer which points to the block of memory that contains

the information to be written to the file,
Size→ denotes the length of each item in bytes,
n→ is the number of items to be written to the file, and
→ fptr is a FILE pointer which points to the file to which the data is
written.
•
Program 16
#include<stdio.h> printf( "Enter number of records");
struct record{ scanf("%d",&n);
char name[20]; for (i=0;i<n;i++)
int roll; {
float marks; printf ( "Enter name: " ) ;
}student; scanf("%s",[Link]) ;
main() printf ("Enter roll no: ") ;
{ scanf("%d",&[Link]);
int i,n; printf ("Enter marks: ") ;
FILE *fp; scanf("%f",&[Link]);
fp=fopen("[Link]","w"); fwrite(&student,sizeof(student),1,fp);
if(fp==NULL) }
{ fclose(fp) ;
printf("Error in opening file\n"); }
exit(1) ; Output:
}
 fread()
• This function is used to read bytes form the file.
• Declaration: size_t fread(void *ptr, size_t size, size_t n,
FILE *fptr);
• Here,
– Ptr→ is a pointer which points to the block of
memory which receives the data read from the file
– Size→is the length of each item in bytes, n is the
number of items to be read from the file and
– fptr →is a file pointer which points to the file from
which data is read.
 Program 17
#include<stdio.h>
struct record{
char name[20];
int roll;
float marks;
}student;
main()
{
FILE *fp;
fp=fopen("[Link]","r");
if (fp==NULL)
{
printf("Error in opening file\n");
exit(1) ;
}
printf("\nNAME\tROLLNO\tMARKS\n");
while(fread(&student,sizeof(student),1,fp))
{
printf("%s\t",[Link]) ;
printf("%d\t",[Link]) ;
printf("%f\n",[Link]) ;
}
fclose(fp) ;
}
•
• Output:
 RANDOM ACCESS TO FILE
• We can access the data stored in the file in two ways, sequentially or
randomly.
• So far we have use only sequential access in our programs. For
example if we want to access the forty-fourth record the first forty-
three records should be read sequentially to reach the forty-fourth
record.
• In random access data can be accessed and processed randomly i.e.
in this case the forty-fourth record can be accesses directly. There is
no need to read each record sequentially, if we want to access a
particular record. Random access takes less time than the sequential
access.

C supports these functions for random access file processing-

• fseek( )
• ftell()
• rewind( )
 fseek ( )
• This function is used for setting the file position pointer at the specified
byte.
• Declaration: int fseek( FILE *fp, long displacement, int origin );
• Here,
• fp→ is a file pointer,
• Displacement→ is a long integer which can be positive or negative and it
denotes the number of bytes which are skipped backward ( if negative,) or
forward ( if positive ) from the position specified in the third argument.
This argument is declared as long integer so that it is possible to move in
large files.
• Origin→The third argument named origin is the position relative to which
the displacement takes place. It can have one of these three values.
 Example of fseek()
Some examples of usage of fseek( ) function are
i. fseek( p, l0L, 0); Origin is 0, which means that displacement will be
relative to beginning of file so position pointer is skipped 10 bytes
forward from the beginning of the file. Since the second argument is a
long integer, so L is attached with it.
ii. fseek ( p, 5L , 1 ); Position pointer is skipped 5 bytes forward from
the current position.
iii. fseek ( p, 8L , SEEK_SET ); Position pointer is skipped 8 bytes forward
from the beginning of file.
iv. fseek ( p , -5L , 1); Position pointer is skipped 5 bytes backward from the
current position.
v. fseek (p, 0L , 2); Origin is 2 which represents end of file and
displacement is 0 which means that 0 bytes are skipped from end of file.
So after this statement position pointer will point to the end of file.
vi. fseek( p, -6L, SEEK_END ); Position pointer is skipped 6 bytes backward
from the end of file.
vii. fseek ( p, 0L , 0 ); This means 0 bytes are skipped from the beginning of
file. After this statement position pointer points to the beginning of file.
 Program 18
#include <stdio.h>

int main () {
FILE *fp;

fp = fopen("[Link]","w+");
fputs("This is [Link]", fp);

fseek( fp, 7, SEEK_SET );

fputs(" C Programming Language", fp);
fclose(fp);

return(0);
}

Output:
 ftell( )

• Declaration: long ftell( FILE *fptr);

• This function returns the current position of
the file position pointer. The value is counted
from beginning of the file.
 Program 19
#include <stdio.h>
#include<conio.h>
void main () {
FILE *ptr;
int len;
ptr= fopen("[Link]", "r");
fseek(ptr, 0, SEEK_END);
len = ftell(ptr);
fclose(ptr);
printf("Size of file: %d bytes", len);
}
Output :
 rewind( )
• Declaration: rewind(FILE *fptr);

• This function is used to move the file position pointer to the beginning of
the file. Here fptr is a pointer of FILE type. The function rewind( ) is useful
when we open a file for update.
 Program 20
#include<stdio.h>
#include<stdlib.h>
main()
{
FILE *fp;
fp=fopen(“[Link]","r");
printf("position pointer->%ld\n",ftell(fp));
fseek(fp,0,2);
printf("position pointer->%ld\n",ftell(fp));
rewind(fp);
printf("Position pointer ->%ld\n",ftell(fp));
fclose(fp);
}
Output:
 Merge contents of two files into a
third file
• Let the given two files be [Link] and [Link].
• The following are steps to merge.
1) Open [Link] and [Link] in read mode.
2) Open [Link] in write mode.
3) Run a loop to one by one copy characters of [Link] to [Link].
4) Run a loop to one by one copy characters of [Link] to [Link].
5) Close all files.
 Program 21
//Program that concatenate two files which appends the content of one file to the end of another file and write the result in third file.
#include <stdio.h>

int main()
{
// Open two files to be merged
FILE *fp1 = fopen("[Link]", "r");
FILE *fp2 = fopen("[Link]", "r");

// Open file to store the result

FILE *fp3 = fopen("[Link]", "w");
char c;

if (fp1 == NULL || fp2 == NULL || fp3 == NULL)

{
puts("Could not open files");
exit(0);
}

// Copy contents of first file to [Link]

while ((c = fgetc(fp1)) != EOF)
fputc(c, fp3);

// Copy contents of second file to [Link]

while ((c = fgetc(fp2)) != EOF)
fputc(c, fp3);

printf("Merged [Link] and [Link] into [Link]");

fclose(fp1);
fclose(fp2);
fclose(fp3);
return 0;
}

Output :