II

PROGRAMMING - ADVANCED FEATURES

Structures – Union – Enumerated Data Types – Pointers: Pointers to Variables, Arrays
and Functions – File Handling – Preprocessor Directives.

1.1 INTRODUCTION
 Structures, unions and enumerations are known as user defined data types.
 These data types are used to create a flexible new data type.
 Structure can be used for the storage of different data types. The similarity
between structure and array is both contain a finite number of elements.
 Union is similar to structures in all aspects except the manner in which their
constituent elements are stored.
 In structures, separate memory is allocated to each element, while in unions all
the elements are share the same memory.
 Enumeration helps to define a data type whose objects can take a limited set of
values.

1.2 STRUCTURE
Definition
 A Structure is a collection of variables of different data types under a single name
and provides a convenient way of grouping several of related information
together.
 Unlike arrays, it can be used for the storage of heterogeneous data (data of
different data types).

1.2.1 Three main aspects of working with structure

1. Defining a structure type (Creating a new type)
2. Initializing structure elements
 3. Declaring variables and constants (objects) of the newly created type.

1.2.1.1 Defining Structure

Syntax struct
structure_name
{
element-1; element-2;
Example
element-3; //Variable declarations
...
...
element-n;
} v1,v2. ...... vn;
Where element1, element2, element3 are variables of any primitive or derived
data types and v1,v2, .. vn are structure variable.

struct book
{
char author[40];
float price;
int page;
}b1,b2;

Rules for defining structure

 Structure definition consists of the keyword struct followed by a structure tag
name and a structure declaration list enclosed within braces.
 The structure declaration list consists of one or more variables declaration,
possibly of different data types. The variable names declared in the structure
declaration list are known as structure members.
 Structure members can be variables of the basic types( eg: char, float, int) or
pointer type(eg: char *, int *) or aggregate type(eg: array).
  A structure declaration list cannot contain a member of void type or incomplete
type or function type.
 Self referential structure: a structure may contain a pointer to an instance of itself
is known as self referential structure.

1.2.1.2 Initializing Structure Elements

Syntax
Struct book
{
int page;
char author[10];
float price;
}b1;
Example
void main()
{
b1.author=”Kalam”;
printf(“Enter price:”);
scanf(“%f”,&b1.price);
b1.page=178;
}
1.2.1.3 Declaring Structure Objects
 Variables (or) constants of the created structure type can be created either at the
time of structure definition (or) after the time of structure definition.
Syntax
[type qualifier] structure type identifier name [= initialization list]; (or)
variables;
Example
struct book b1={3,2,1}; // it contains the initialization list struct
book b1,b2,b3; // it contains the variable
Rules for declaring structure objects:
 It is important to note that the structure members cannot be initialized during the
structure definition; however the members of a structure object can be initialized
by providing an initialization list.

1.2.2 Operations on Structures

 Aggregate operations
 Segregate operations

1.2.2.1 Aggregate Operations

 An aggregate operation treats an operand as an entity and operates on the entire
operand as whole instead of operating on its constituent members.
Types
a) Accessing members of an object of a structure
b) Assigning a structure object to a structure variables
c) Address of a structure object
d) Size of a structure.
a) Accessing members of an object of a structure :
The members of a structure object can be accessed by using:
(i) Direct member access operator (dot operator) (ii)
Indirect member access operator(arrow operator)
(i) Direct member access operator (dot operator):
Syntax:
struct variable-name.struct-element-name
Example Program 2.1
//C program to print student details using structure
#include <stdio.h>
struct student
{
char name[50];
int roll;
float marks;
};
int main()
{
struct student s;

printf("Enter The Information of Students :\n\n");

printf("Enter Name : ");

scanf("%s",s.name);

printf("Enter Roll No. : ");

scanf("%d",&s.roll);

printf("Enter marks : ");

scanf("%f",&s.marks);

printf("\nDisplaying Information\n");

printf("Name: %s\n",s.name);
 printf("Roll: %d\n",s.roll);
printf("Marks: %.2f\n",s.marks);
return 0;
}
OUTPUT
Enter the Information of the Student:
Enter the name: Sheela
Enter the roll no:123
Enter the mark:78

Displaying Information
Name:Sheela
Roll no:123
Marks:78

Example Program 2.2

/*C program to calculate the student‟s average marks and student details using structure*/
#include stdio.h //put is <>in header
file
#include conio.h
struct student
{
int rollno,tot;
char name[25];
int mark[5];
};
void main()
{
struct student s[5]; //Data type of
„*s‟ is struct student
int i,n,j;
clrscr();
printf(“Enter the number of
students:”);
scanf(“%d”,&n);
printf(“\t*Students Records*\n”);
//take input from user
for(i=0;i<n;i++)
{
printf("\nEnter Student Roll
Number: ");
scanf("%d",&s[i].rollno);
printf("\nEnter Student name: ");
scanf("%s",s[i].name);
printf("\nEnter Student 3 subject's
marks: ");
for(j=0;j<3;j++)
scanf("%d",&s[i].mark[j]);
}
//calculation
for(i=0;i<n;i++)
{
s[i].tot=0;
for(j=0;j<3;j++)
s[i].tot = s[i].tot+ s[i].mark[j];
}
//Display result
for(i=0;i<n;i++)
{
printf("\t*Students Records*\n");
printf("\n====================
==============\n");
printf("\nStudent's Roll no. – %d",
s[i].rollno);
printf("\nStudent's Name – %s",
s[i].name);
printf("\nStudent's Total Marks –
%d", s[i].tot);
}
getch();
}
OUTPUTEnter the number of
students:2
*Students Records*
Enter Student Roll Number: 01
Enter Student name: rathi
Enter Student 3 subject‟s marks:
12
67
89
Enter Student Roll Number: 02
Enter Student name: kishore
Enter Student 3 subject‟s marks:
56
89
90
*Students Records*
 ===========================
=======
Student‟s Roll no. – 1
Student‟s Name – rathi
Student‟s Total Marks – 168
*Students Records*
===========================
=======
Student‟s Roll no. – 2
Student‟s Name – kishore
Student‟s Total Marks – 235

Example Program 2.3

#include<stdio.h>
struct book // structure data type declaration
 {
int x,y;
};
struct book *b1; //pointer to structure
void main()
{
printf(“enter the values”);
scanf(“%d”, &b1->x);
scanf(“%d”,&b1->y); //-> operator used
printf(“\nx=%d”, b1->x);
printf(“\ny=%d”, *b1.y);
}
Output:

Enter the values 10 20

x=10 y=20
b) Assigning a structure object to a structure variables
 Assignment operator (=) is used to assign the values of one variable to another
variable. When assignment operator (=) is applied on structure variables, it performs
member by member copy.

Example Program 2.4

#include<stdio.h>
struct book // struct datatype is declared
{
char title[25], author[20];
int price;
};
 void main()
{
struct book b1,b2,b3; //structure variables are declared
b1={“ cutting stone”, “Abraham”,400};
b2.author=b1.author;
b3=b1; // b1 variable values are assigned to b3
printf(“%s by %s is of Rs. %d \n”, b1.title,b1.author,b1.price);
printf(“%s is the author of second book”,b2.author);
printf(“%s by %s is of Rs. %d \n”, b3.title,b3.author, b3.price);
}
OUTPUT
cutting stone by Abraham is of Rs.400
Abraham is the author of second book
cutting stone by Abraham is of Rs. 400

c) Address of a structure object

 The address of operator (&) when applied to a structure object gives its base address.
It can also be used to find the address of the constituting members of a structure
object.

d) Size of a structure.
 When the sizeof operator is applied to an operand of a structure type it will produce
the result as how much memory space is occupied by that particular object.
Syntax: sizeof
(expression); sizeof type
Example:
sizeof (struct book); // use structure‟s name sizeof
b1 // use variable
Program 2.5
#include<stdio.h>
struct book //structure type declaration
{
char a; // elements are declared
int b; char c; float d;
}; //structure type declarations are terminated
void main()
{
struct book var; //variable declaratio
printf(“obj of struct book will take %d bytes\n”,sizeof(struct book));
printf(“structure variable var takes %d bytes\n”, sizeof var);
}
OUTPUT
obj of struct pad will take 8 bytes
structure variable var takes 8 bytes

1.2.2.2 Segregate Operations

 A segregate operation operates on the individual members of a structure object.
Program 2.8
#include<stdio.h>
struct book
{
char title[25], author[20];
int page; float price;
};
void main() {
struct book b1;
 printf(“enter title, author, page, price”);
scanf(“%s, %s, %d, %f”,& b1.title,&b1.author,&b1.page, &b1.price);
printf(“title is %s, author is %s, page no %d, price %d”,b1.title, b1.author,
b1.page, b1.price); // operations on individual element b1.page+=100;
b1.price+=10;
printf(“title is %s, author is %s, page no %d”,b1.title, b1.author, b1.page);
printf(“price %d”,b1.price);
}
Output
Enter title, author, page, price
Principles of life, prabhu, 145, 200.00
Title is principles of life, author is prabhu, page no 145, price 200.00
Title is principles of life, author is prabhu, page no 245, price 210.00

1.3 UNION
 Union can be defined as a user-defined data type which is a collection of different
variables of different data types in the same memory location. The union can also
be defined as many members, but only one member can contain a value at a
particular point in time. Unions provide an efficient way of using the same
memory location for multiple-purpose.
 Union is a user-defined data type, but unlike structures, they share the same
memory location.
Defining a Union
 To define a union, you must use the union statement in the same way as did while
defining a structure. The union statement defines a new data type with more than
one member for your program. The format of the union statement is as follows:
union [union tag] {
member definition;
member definition;
...
 member definition;
}
[one or more union variables];
 The union tag is optional and each member definition is a normal variable
definition, such as int i; or float f; or any other valid variable definition. At the end
of the union's definition, before the final semicolon, you can specify one or more
union variables but it is optional. Here is the way you would define a union type
named Data having three members i, f, and str.
union Data {
int i;
float f;
char str[20];
}
data;
 Now, a variable of Data type can store an integer, a floating-point number, or a
string of characters. It means a single variable, i.e., same memory location, can be
used to store multiple types of data. You can use any built-in or user defined data
types inside a union based on your requirement.
Example Program 2.9 Illustration of Union
#include <stdio.h>
#include <string.h>
union Data {
int i;
float f;
char str[20];
};
void main( )
{
union Data data;
data.i = 10;
 printf( "data.i : %d\n", data.i);
data.f = 220.5;
printf( "data.f : %f\n", data.f);
strcpy( data.str, "Charulatha publication");
printf( "data.str : %s \n", data.str);
}
OUTPUT
data.i : 10
data.f : 220.500000
data.str : Charulatha publication
Difference between Structure and Union
Sl.No Structure Union
1 The member of a structure occupies The member of union share same
its own memory space. memory space.
2 The keyword struct is used to define The keyword union is used to define a
a structure structure
3 All the members of a structure can Only the first member of a union can
be initialized. be initialized.
4 In structure, each member is stored In union, all memb ers are stored in
in a separate memory location. So the same memory locations. So, need
need more memory space. less memory space.

1.4 POINTERS
1.4.1 Pointers to Variables
 A pointer is a variable that stores an address of another variable of same type.
 Pointer can have any name that is legal for other variable.
 Pointer variables are declared with prefix of „*‟ operator.
 Using a pointer variable, we can access the value of another variable assigned to
it.
Syntax
data_type *pointer_name;
Example
int *a;
Example
 variable *a can store the address of any integer type variable.
 A pointer is a variable whose value is also an address.
 Each variable has two attributes
 Value
 Address
We can define pointers in two ways.
i) First a pointer is a variable and assigns different values to a pointer variable.
ii) Second the value contained by a pointer must be an address w hich indicates the
location of another variable in the memory. So, pointer is called as “address
variable”.

int a=50;
int *ptr;
ptr=&a;

 Here „a‟ is a variable holds a value 50 and stored in a memory location 1001.
„*ptr‟ is pointer variable holds a address of a variable „a‟.
Advantages of Using Pointers
 Pointers are more compact and efficient code.
  Pointers can be used to achieve clarity and simplicity.
 Pointers are used to pass information between function and its reference point.
 A pointer provides a way to return multiple data items from a function using its
function arguments.
 Pointers also provide an alternate way to access an array element.
 A pointer enables us to access the memory directly.
Example Program 2.10
/*C program for printing value and address of a variable using pointer variable*/
#include<stdio.h>
#include<conio.h>
void main()
{
int i=3;
int *ptr;
ptr=&i;
clrscr();
printf(“Address of i=%u\n”,ptr);
printf(“value of i=%d\n”,*ptr);
getch();
}
Output:
Address of i=65524

value of i=3

Example Program 2.11

/*C program for printing value and address of a variable using pointer variable by
various methods*/
#include<stdio.h>
#include<conio.h>
void main()
 {
int i=4;
int *j;
j=&i;
clrscr();
printf(“Address of i=%u\n”,&i);
printf(“Address of i=%u\n”,j);
printf(“Address of j=%u\n”,&j);
printf(“value of j=%u\n”,j);
printf(“value of i=%d\n”,i);
printf(“value of i=%d\n”,*(&i));
printf(“value of i=%d\n”,*j);
getch();
}
OUTPUT
Address of i=65524
Address of i=65524
Address of j=65522
value of j=65524
value of i=4
value of i=4
value of i=4

Example Program 2.12

/*C program to add two numbers using pointers*/
#include<stdio.h>
#include<conio.h>
void main()
{
 int a,b,*p,*q,sum;
clrscr();
printf(“Enter two integers”);
scanf(“%d %d”,&a,&b);
p=&a; q=&b;
Output
sum=* p+*q;
printf(“sum=%d”,sum);
getch();
}

OUTPUT
Enter two integers 2 3
sum=5
1.4.2 Pointer operators
a) Referencing a pointer
 A pointer variable is made to refer to an object.
 Reference operator(&) is used for this.
 Reference operator is also known as address of (&) operator.
Example
float a=12.5; float
*p;
p=&a;

b) Dereferencing a pointer
 • The object referenced by a pointer can be indirectly accessed by
dereferencing the pointer.
• Dereferencing operator (*) is used for this.
• This operator is also known as indirection operator or value- at-operator.
Example program 2.13
#include<stdio.h>
void main()
{
int a=12;
int *p;
int **pptr;
p=&a;
pptr=&p;
printf(“Value=%d”,a);
printf(“value by dereferencing p is %d \n”,*p);
printf(“value by dereferencing pptr is %d \n”,**pptr);
printf(“value of p is %u \n”,p);
printf(“value of pptr is %u\n”,pptr);
}
Output
Value=12 value by
dereferencing p is 12 value by
dereferencing pptr is 12 value
of p is 1000 value of pptr is
2000
1.4.3 Arrays and pointers
 Array elements are always stored in consecutive memory locations according to
the size of the array.
 The size of the variable with the pointer variables refers to, depends on the data
type pointed by the pointer.
  A pointer when incremented, always points to a location after skipping the number
of bytes required for the data type pointed to by it. Example
int a[5]={10,20,30,40,50};
a[5] means the array „a‟ has 5 elements and of integer data type
Program 2.14
/*C program to print the value and address of an array elements*/
#include<stdio.h>
#include<conio.h>
void main()
{
int a[5]={10,20,30,40,50};
int i;
clrscr();
for(i=0;i<5;i++)
{
printf(“The value of a[%d]=%d\n”,i,a[i]);
printf(“Address of a[%d]=%u\n”,i,&a[i]);
} getch();
}
Output
The value of a[0]=10
Address of a[0]=4000
The value of a[1]=20
Address of a[1]=4002
The value of a[2]=10
Address of a[2]=4004
The value of a[3]=10
Address of a[3]=4006
Example Program 2.15
Program to print the value and address of elements of an array using pointer
notation
#include<stdio.h>
int main( )
{
int arr[5];
int i;
printf("Enter the array 5 elements : ");
for(i=0; i<5; i++)
{
scanf("%d", &arr[i]);
}
printf("\nArray elements with their addresses using pointers : \n");

for(i=0; i<5; i++)

{
printf("Value of arr[%d] = %d\t", i,*(arr+i));
printf("Address of arr[%d] = %p\n",i,arr+i);
}

return 0;
}

OUTPUT
Enter the array 5 elements :
6
2
9
1
7

Array elements with their addresses using pointers :

Value of arr[0] = 6 Address of arr[0] = 000000000062FE30

Value of arr[1] = 2 Address of arr[1] = 000000000062FE34
Value of arr[2] = 9 Address of arr[2] = 000000000062FE38
Value of arr[3] = 1 Address of arr[3] = 000000000062FE3C
Value of arr[4] = 7 Address of arr[4] = 000000000062FE40
Example Program 2.16
/*C program to add sum of elements of an array using pointer*/
#include<stdio.h> main()
{
int i,sum;
int arr[5];
int *ptr;
for(i=0;i<5;i++)
{
printf (“Enter the number”);
scanf(“%d”,&arr[i]);
}
ptr=arr;
for(i=0;i<5;i++)
{
sum=sum+*ptr
Functions and Pointers 3.29

ptr=ptr+1;
}
 printf(“Total=%d”,sum);
}
Output
Enter the number
10
20
30
40
50
Total= 150

1.4.3.1 Pointers with Multi-Dimensional Array

 A multi-dimensional array can also be represented with an equivalent pointer
notation. A two dimensional array can be considered as a collection of
onedimensional arrays.
Syntax
data_type (*pointer variable) [expression];
data_type array name[expression 1][expression 2];

Example Program 2.17

/*C program to print the value and address of the element using array of

#include<stdio.h>
#include<conio.h>
void main()
{
int * int *a[3];
int b=10,c=20,d=30,i;
a[0]=&b; a[1]=&c; a[2]=&d;
clrscr();
for(i=0;i<3;i++)
{
printf(“Address=%u\n”,a[i]);
printf(“Value=%d\n”,*(a[i]));
}
getch();
}
Output
Address=4000
Value=10
Address=5000
Value=20
Address=6000
Value=30

1.4.4 Functions Pointers

 Function pointers in C can be used to create function calls to which they point.
This allows programmers to pass them to functions as arguments. Such functions
passed as an argument to other functions are also called callback functions.
 In C programming, it is also possible to pass addresses as arguments to functions.
To accept these addresses in the function definition, we can use pointers. It's
because pointers are used to store addresses.
Example Program 2.18
Write a C Program for Swapping of two numbers using function pointers.
#include <stdio.h>
void swap(int *n1, int *n2);
int main()
{
int num1 = 5, num2 = 10;
 // address of num1 and num2 is passed
swap( &num1, &num2);
printf("num1 = %d\n", num1);
printf("num2 = %d", num2);
return 0;
}
void swap(int* n1, int* n2)
{
int temp;
temp = *n1;
*n1 = *n2;
*n2 = temp;
}
Output
num1 = 10
num2 = 5

 The address of num1 and num2 are passed to the swap() function using
swap(&num1, &num2);
 When *n1 and *n2 are changed inside the swap() function, num1 and num2
inside the main() function are also changed.
 Inside the swap() function, *n1 and *n2 swapped. Hence, num1 and num2 are
also swapped.

1.5 ENUMERATED DATA TYPES

 Enumeration or Enum in C is a special kind of data type defined by the user. It consists
of constant integrals or integers that are given names by a user. The use of enum in C to
name the integer values makes the entire program easy to learn, understand, and maintain
by the same or even different programmer. Syntax to Define Enum in C
• An enum is defined by using the „enum‟ keyword in C, and the use of a comma
separates the constants within. The basic syntax of defining an enum is:
 enum enum_name{int_const1, int_const2, int_const3, …. int_constN};
• In the above syntax, the default value of int_const1 is 0, int_const2 is 1, int_const3
is 2, and so on. However, you can also change these default values while declaring
the enum.

Example
• Below is an example of an enum named cars and how you can change the default
values.
enum cars{BMW, Ferrari, Jeep, Mercedes-Benz}; o
Here, the default values for the constants are:
BMW=0, Ferrari=1, Jeep=2, and Mercedes-Benz=3. However, to change
the default values, you can define the enum as follows:
enum cars{
BMW=3,
Ferrari=5,
Jeep=0,
Mercedes-Benz=1
};

1.5.1 Enumerated Type Declaration to Create a Variable

 Similar to pre-defined data types like int and char, you can also declare a variable
for enum and other user-defined data types. Here‟s how to create a variable for
enum.
 enum condition (true, false); //declaring the enum
 enum condition e; //creating a variable of type condition
 Suppose we have declared an enum type named condition; we can create a
variable for that data type as mentioned above. We can also converge both the
statements and write them as: enum condition (true, false) e;
 For the above statement, the default value for true will be 1, and that for false will
be 0.
1.5.2 Implementing enum using C Program
Example program 2.19: Printing the Values of Weekdays
#include <stdio.h>
enum days{Sunday=1, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday};

int main()
{
// printing the values of weekdays

for(int i=Sunday;i<=Saturday;i++)
{

printf("%d, ",i);
}
return 0;
}

Output

1.6 FILE HANDLING

 A file is a collection of bytes stored on a secondary storage device, which is
generally a disk of some kind. The collection of bytes may be interpreted, for
example, as characters, words, lines, paragraphs and pages from a textual
document; fields and records belonging to a database; or pixels from a graphical
image.
 The meaning attached to a particular file is determined entirely by the data
structures and operations used by a program to process the file. It is conceivable
(and it sometimes happens) that a graphics file will be read and displayed by a
program designed to process textual data.
  The result is that no meaningful output occurs (probably) and this is to be
expected. A file is simply a machine decipherable storage media where programs
and data are stored for machine usage.

1.6.1 Why we need file?

 When a program is terminated, the entire data is lost. Storing in a file will preserve
your data even if the program terminates.
 If you have to enter a large number of data, it will take a lot of time to enter them
all. However, if you have a file containing all the data, you can easily access the
contents of the file using few commands in C. It is possible easily move your data
from one computer to another without any changes.
1.6.2 File Operations
 In programming, we may require some specific input data to be generated several
numbers of times. Sometimes, it is not enough to only display the data on the
console. The data to be displayed may be very large, and only a limited amount of
data can be displayed on the console, and since the memory is volatile, it is
impossible to recover the programmatically generated data again and again.
 However, if we need to do so, we may store it onto the local file system which is
volatile and can be accessed every time. Here, comes the need of file handling in
C.
 File handling in C enables us to create, update, read, and delete the files stored on
the local file system through our C program. The following operations can be
performed on a file.
• Creation of the new file
• Opening an existing file
• Reading from the file
• Writing to the file
• Deleting the file

1.6.2.1 Types of Files

 There are two kinds of files in which data can be stored in two ways either in
characters coded in their ASCII character set or in binary format. They are
1. Text Files (or) ASCII file
 2. Binary Files Text Files (or) ASCII
file
 The file that contains ASCII codes of data like digits, alphabets and symbols is
called text file (or) ASCII file. Binary Files
 A binary file is a file that uses all 8 bits of a byte for storing the information .It is
the form which can be interpreted and understood by the computer.
 The only difference between the text file and binary file is the data contain in text
file can be recognized by the word processor while binary file data can‟t be
recognized by a word processor.
1. wb(write)
This opens a binary file in write mode.
SYNTAX: fp=fopen(“data.dat”,”wb”);
2. rb(read)
This opens a binary file in read mode
SYNTAX:fp=fopen(“data.dat”,”rb”);
3. ab(append)
This opens a binary file in a Append mode i.e. data can be added at the end
of file.
SYNTAX: fp=fopen(“data.dat”,”ab”);
4. r+b(read+write)
This mode opens preexisting File in read and write mode.
SYNTAX: fp=fopen(“data.dat”,”r+b”);
5. w+b(write+read)
This mode creates a new file for reading and writing in Binary mode.
SYNTAX: fp=fopen(“data.dat”,”w+b”);
6. a+b(append+write)
This mode opens a file in appen d mode i.e. data can be written at the end of
file.
SYNTAX: fp=fopen(“data.dat”,”a+b”);
Opening Modes in Standard I/O
 r Open for reading If the file does not exist, fopen() returns
NULL
rb Open for reading in binary If the file does not exist, fopen() returns
mode. NULL.
w Open for writing. If the file exists, its contents are overwritten. If
the file does not exist, it will be created.
wb Open for writing in binary If the file exists, its contents are overwritten. If
mode. the file does not exist, it will be created.
a Open for append. i.e, Data is If the file does not exists, it will be created.
added to the end of file.
ab Open for append in binary If the file does not exists, it will be created.
mode. i.e, Data is added to end
of file.
r+ Open for both reading and If the file does not exist, fopen() returns
writing. NULL.
rb+ Open for both reading and If the file does not exist, fopen() returns
writing in binary file. NULL
w+ Open for both reading and If the file exists, its contents are overwritten. If
writing. the file does not exist, it will be created.
wb+ Open for both reading and If the file exists, its contents are overwritten. If
writing in binary mode. the file does not exist, it will be created.
a+ Open for both reading and If the file does not exists, it will be created.
appending.
ab+ Open for both reading and If the file does not exists, it will be created.
appending in binary mode.

Closing a File: fclose(fptr);

 The file (both text and binary) should be closed after reading/writing.
Closing a file is performed using library function fclose(). Reading
and writing to a text file
  The functions fprintf() and fscanf() are used to read or write the file
They are just the file versions of printf() and scanf(). The only
difference is that, fprint and fscanf expects a pointer to the structure
FILE.
Writing to a text file
Program 2.20: Write to a text file using fprintf()

1. #include <stdio.h>
2. main(){
3. FILE *fp;
4. fp = fopen("file.txt", "w");//opening file
5. fprintf(fp, "Hello file by fprintf...\n");//writing data into file
6. fclose(fp);//closing file
7. }

Reading and writing to a binary file

 Functions fread() and fwrite() are used for reading from and writing to a file on the
disk respectively in case of binary files.
Writing to a binary file
 To write into a binary file, you need to use the function fwrite(). The functions
takes four arguments: Address of data to b e written in disk, Size of data to be
written in disk, number of such type of data and pointer to the file where you
want to write.
fwrite(address_data,size_data,numbers_data,pointer_to_file);
Program 2.22: Writing to a binary file using fwrite()
#include <stdio.h>
struct threeNum
{
int n1, n2, n3;
};
int main()
 {
int n;
struct threeNum num; FILE
*fptr;
if ((fptr = fopen(“C:\\program.bin”,”wb”)) == NULL)
{
printf(“Error! opening file”);
// Program exits if the file pointer returns NULL.
exit(1);
}
for(n = 1; n < 5; ++n)
{
num.n1 = n; num.n2 = 5n; num.n3 = 5n
fwrite(&num, sizeof(struct threeNum), 1,fptr);
}
fclose(fptr);
return 0;
}
 We declare a structure three Num with three numbers - n1, n2 and n3, and define
it in the main function as num. Now, inside the for loop, we store the value into
the file using fwrite.
 The first parameter takes the address of num and the second parameter takes the
size of the structure three Num. Since, we‟re only inserting one instance of num,
the third parameter is 1. And, the last parameter *fptr points to the file we‟re
storing the data. Finally, we close the file.
Reading from a binary file
 Function fread() also take 4 arguments similar to fwrite() function as above.
fread(address_data,size_data,numbers_data,pointer_to_file);
Program 2.23: Reading from a binary file using fread()
 #include <stdio.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”);
// Program exits if the file pointer returns NULL.
exit(1);
}
for(n = 1; n < 5; ++n)

{
fread(&num, sizeof(struct threeNum), 1, fptr);
printf(“n1: %d\tn2: %d\tn3: %d”, num.n1, num.n2, num.n3);
}
fclose(fptr);
return 0;
}
TEXT FILE
This program will start reading the records from the file program.bin in the
reverse order (last to first)
 In C, all components are files, each with a different behavior based on the
attached devices. To enable the I/O functions, se veral standard built-in functions
were created and stored in libraries.
 Some of the high level file I/O functions are given in Table 2 .1
 Table 2.1 High level file I/O functions
S.No Function Description
1 fopen() opens new or existing file
2 fprintf() write data into the file
3 fscanf() reads data from the file
4 fputc() writes a character into the file
5 fgetc() reads a character from file
6 fclose() closes the file
7 fseek() sets the file pointer to given position
8 fputw() writes an integer to file
9 fgetw() reads an integer from file
10 ftell() returns current position
11 rewind() sets the file pointer to the beginning of the file

1. fopen () : It creates a new file for use or opens an existing file for use.
2. fclose (): It closes a file which has been opened for use.
3. fscanf( file pointer, format string, address of the variable)
Example: fscanf(fptr,”%d”, &num);
4. fprintf(console output, “format string”, file pointer);
Example: fprintf(stdout, “%f \n”, f); /*note: stdout refers to screen */
5. getw (): This function returns the integer value from a given file and increment the
file pointer position to the next message.
Syntax: getw (fptr);
Where fptr is a file pointer which takes the integer value from file.
6. putw (): This function is used for writing an integer value to a given file. Syntax:
putw (value,fptr);
Where fptr is a file pointer Value is an integer value which is written to a given file.
Example Program for getw() and putw()
Program 2.24: Write a program to read integer data from the user and write it into
the file using putw() and read the same integer data from the file using getw() and
display it on the output screen.
#include<stdio.h>
#include<conio.h>
void main()
{
FILE *fp;
int n; clrscr();
fp=fopen(“c.dat”, “wb+”);
printf(“Enter the integer
data”); scanf(“%d”,&n);
while(n!=0)
{ putw(n,fp);
scanf(“%d”,&n);
}
rewind(fp);
printf(“Reading data from file”);
while((n=getw(fp))!=EOF)
{
printf(“%d\n”,n);
}
fclose(fp);
getch();
}
7. fwrite()
 This function is used for writing an entire block to a given file.
 Syntax:
fwrite(ptr,size,nst,fptr);
ptr is a pointer ,it points to the array of structure. Size is the size of
the structure nst is the number of the structure fptr is a filepointer.
8. fread()
 fread(ptr,size,position,fptr);similar to fwrite
9. fflush(stdin);To clean the input stream
Program 2.25: program for fwrite():
Write a program to read an employee details and write them into the file at a time
using fwrite().
#include<stdio.h>
#include<conio.h>
void main()
{
struct emp

{
int eno;
char ename[20];
float sal;
}e;
FILE *fp;
fp=fopen(“emp.dat”, “wb”);
clrscr();
printf(“Enter employee number”);
scanf(“&d”,&e.eno);
printf(“Enter employee name”);
fflush(stdin);
scanf(“%s”,e.ename);
 printf(“Enter employee salary”);
scanf(“%f”,&e.sal); fwrite(&e,sizeof(e),1,fp);
printf(“One record stored successfully”);
getch();
}
Operations for Search data in a file
1. fseek()
2. ftell()
3. rewind()
When many records inside a file and need to access a record at a specific position, you
need to loop through all the records before it to get the record. This will waste a lot of
memory and operation time. An easier way to get to the required data can be achieved
using fseek().

Syntax of fseek()
fseek(FILE * stream, long int offset, int whence)
fseek(file pointer, displacement, pointer position);
 The first parameter stream is the pointer to the file. The second parameter is the
position of the record to be found, and the third parameter specifies the location
where the offset starts.
 This function is used for seeking the pointer position in the file at the specified
byte.
Syntax: fseek( file pointer, displacement, pointer position);
file pointer - It is the pointer which points to the file.
displacement -It is positive or negative.
 This is the number of bytes which are skipped backward (if negative) or forward
(if positive) from the current position. This is attached with L because this is a
long integer.
Pointer position: This sets the pointer position in the file.

Value Pointer position Value Pointer position

0 Beginning of file.
1 Current position
2 End of file
Example:
1. fseek( p,10L,0)
 This 0 means pointer position is on beginning of the file, from this statement
pointer position is skipped 10 bytes from the beginning of the file.

2. fseek( p,5L,1)
 This 1 means current position of the pointer position. From this statement pointer
position is skipped 5 bytes forward from the current position.
3. fseek(p,-5L,1):
From this statement pointer position is skipped 5 bytes backward from the current
position.
 Program 2.26: for fseek()
#include <stdio.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”);
// Program exits if the file pointer returns NULL.
exit(1);
}
// Moves the cursor to the end of the file
fseek(fptr, sizeof(struct threeNum), SEEK_END);
for(n = 1; n < 5; ++n)
{
fread(&num, sizeof(struct threeNum), 1,fptr);
printf(“n1: %d\tn2: %d\tn3: %d”, num.n1, num.n2, num.n3);
 }
fclose(fptr);
return 0;
}
ftell()
 This function is used to move the file pointer to the beginning of the given file. This
function returns the value of the current pointer position in the file. The value is
count from the beginning of the file.
Syntax: ftell(fptr); fptr is a file pointer. rewind()
Syntax: rewind( fptr); fptr is a file pointer.
Program 2.27: program for fseek():
Write a program to read last ‘n’ characters of the file using appropriate file
functions(Here we need fseek() and fgetc()).
#include<stdio.h>
#include<conio.h>
void main()
{
FILE *fp; char ch;
clrscr();
fp=fopen(“file1.c”,“r”);
if(fp==NULL)
printf(“file cannot be opened”);
else {
printf(“Enter value of n to read last „n‟ characters”);
scanf(“%d”,&n); fseek(fp,-n,2);
while((ch=fgetc(fp))!=EOF)
 {

printf(“%c\t”,ch);
}
}
fclose(fp);
getch();
}

1.7 PREPROCESSOR DIRECTIVES

 The C preprocessor is a microprocessor that is used by compiler to transform
your code before compilation. It is called micro preprocessor because it allows
us to add macros.
 Note: A macro is a segment of code which is replaced by the value of macro.
Macro is defined by #define directive.

 All preprocessor directives starts with hash # symbol Let's see a list of
preprocessor directives.
#define: It substitutes a preprocessor using macro.
#include: It helps to insert a certain header from another file.
#undef: It undefines a certain preprocessor macro.
#ifdef: It returns true if a certain macro is defined.
#ifndef: It returns true if a certain macro is not defined.
• #if, #elif, #else, and #endif: It tests the program using a certain condition; these
directives can be nested too.
• #line: It handles the line numbers on the errors and warnings. It can be used
to change the line number and source files while generating output during
compile time.
• #error and #warning: It can be used for generating errors and warnings.
• #error can be performed to stop compilation.
• #warning is performed to continue compilation with messages in the console
window.
• #region and #endregion: To define the sections of the code to make them more
understandable and readable, we can use the region using expansion and
collapse features.