Module 5

Structure, Union, and Enumerated Data Type

5.1 Introduction
 Structure is basically a user-defined data type that can store related information (even of different
data types) together.
 The major difference between a structure and an array is that an array can store only information of
same data type.
 A structure is a collection of variables under a single name. The variables within a structure are
of different data types and each has a name that is used to select it from the structure.
 “A Structure is a user defined data type, which is used to store the values of different data types
together under the same name”.

5.1.1 Structure Declaration

 A structure is declared using the keyword struct followed by the structure name.
 All the variables of the structure are declared within the structure.
 A structure type is generally declared by using the following syntax:

struct struct–name
{
data_type var–name;
data_type var–name;
...............
};

For example:
struct student
{
int r_no;
char name[20]; char
course[20];float fees;
};

 A variable of structure student can be defined by writing:

struct student stud1;
struct student is a data type and stud1 is a variable.
 In the following syntax, the variables are declared at the time of structure declaration.
struct student
{
int r_no;
char name[20]; char
course[20];float fees;
} stud1, stud2;
stud1 and stud2 of the structure student.

1
 5.1.2 Typedef Declarations
 The typedef (derived from type definition) keyword enables the programmer to create a new data
type name by using an existing data type alternate name is given to a known data type.
 The general syntax of using the typedef keyword is given as:
typedef existing_data_type new_data_type;
For example: typedef int INTEGER;then INTEGER is the
new name of data type int.
 To declare variables using the new data type name, precede the variable name with the data type name
(new).
 Therefore, to define an integer variable, INTEGER num=5;For
example, consider the following declaration:
typedef struct student
{
int r_no;
char name[20]; char
course[20];float fees;
};

5.1.3 Initialization of Structures

 Initializing a structure means assigning some constants to the members of the structure.
 When the user does not explicitly initialize the structure, then C automatically does it.
 For int and float members, the values are initialized to zero, and char and string members are
initialized to '\0' by default.
 The initializers are enclosed in braces and are separated by commas.
 The general syntax to initialize a structure variable is as follows:
struct struct_name
{
data_type member_name1; data_type
member_name2; data_type member_name3;
.......................
}struct_var = {constant1, constant2, constant3,...};or
struct struct_name
{
data_type member_name1; data_type
member_name2; data_type member_name3;
.......................
};
struct struct_name struct_var = {constant1, constant2, constant 3,...};
 For example, we can initialize a student structure by writing,
struct student
{
int r_no;
char name[20]; char course[20];
float fees;
}stud1 = {01, "Rahul", "BCA", 45000};
Or,

2
by writing,
struct student stud1 = {01, "Rahul", "BCA", 45000};

5.1.4 Accessing the Members of a Structure

 A structure member variable is generally accessed using a '.' (dot) operator. The syntax of accessing
a structure or a member of a structure can be given as:
struct_var. member_name
For example, to assign values to the individual data members of the structure variable studl, we may write
stud1.r_no = 01; stud1.name =
"Rahul";stud1.course = "BCA";
stud1.fees = 45000;
 To input values for data members of the structure variable stud1, we may write
scanf("%d", &stud1.r_no);
scanf("%s", stud1.name);
 Similarly, to print the values of structure variable stud1, we may write
printf("%s", stud1.course);
printf("%f", stud1.fees);

5.1.5 Copying and Comparing Structures

 We can assign a structure to another structure of the same type:
 Then to assign one structure variable to another, we will write
stud2 = stud1;
 C does not permit comparison of one structure variable with
another. However, individual members of one structure can be
compared with individual members of another structure.
 For example, to compare the fees of two students, we will write if(stud1.fees
> stud2.fees) //to check if fees of stud1 is greater than stud2

5.1.6 Finding the Size of the structures

 There are two different ways through which we can find the number of bytes a structure will occupy
in the memory.

1. Simple Addition
 In this techniques, make a list of all data types and add the memory required by each.
 Consider a simple structure of an employee

3
struct Employee
{
int emp_id; char name[20];
double salary;
char designation[20]; float experience;
};
Size = size of emp_id+ size of name + size of salary + size of designation + size of experienceSize of
emp_id = 2
Size of name =20* size of character Size of
salary = 8
Size of designation = 20 * Size of character Size of
experience = 4
Therefore, Size = 2 + 20*1 +8 +20 *1+4
= 2 +20+8+20+4
= 54bytes
2. Using sizeof operator
 The sizeof operator is used to calculate the size of a data type, variable, or an expression.
 This operator can be used as follows:
sizeof(struct_name);Ex:
#include<stdio.h> struct
employee
{
int emp_id; char name[10];
double salary;
char designation [20]; float experience;
};

void main()
{
struct employee e; printf(“%d”,
sizeof(e));
}

Example: C program to read and display the student details using structures.
#include<stdio.h>
struct student
{
int rnum;
char name[20];int marks;
}s[60];

void main()
{
int i,n;
printf("Enter the number of students");

4
scanf("%d",&n);

printf("\nEnter the roll number, Name , Marks\n");

for(i=1;i<=n;i++)
{
printf("\nStudent %d details\n",i);
scanf("%d",&s[i].rnum);
scanf("%s",s[i].name);
scanf("%d",&s[i].marks);
}
printf("\nStudent Details are:");
printf("\nRoll_number\tName\tMarks");for(i=1;i<=n;i++)
printf("\n%d\t\t%s\t%d\n",s[i].rnum,s[i].name,s[i].marks);

}
Output:
Enter the number of students: 5Enter
the roll number,
Name, Marks and Grade of
Student 1 details
14
Dhavan89
Student 2 details
15
Karan55
Student 3 details
11
Deepa45
Student 4 details
12
Lakshmi35
Student 5 details
10
Soma68
Student Details are:
Roll_number Name Marks
14 Dhavan 89
15 Karan 55
11 Deepa 45
12 Lakshmi 35
10 Soma 68

5
 5.2 Structures and Functions
 A function may access the members of a structure in three ways.

1. Passing Individual Members

 To pass any individual member of a structure to a function, we must use the direct selection operator
to refer to the individual members.
#include<stdio.h>typedef
struct
{
int x;int y;
}POINT;

void display(int, int);void

main()
{
POINT p1 = {2, 3};
display(p1.x, p1.y);
}

void display(int a, int b)

{
printf(" The coordinates of the point are: %d %d", a, b);
}
Output: The coordinates of the point are: 2 3

2. Passing the Entire Structure

 The entire structure can be passed as a function argument.
 When a structure is passed as an argument, it is passed using the call by value method, i.e., a copy of
each member of the structure is made.
 The general syntax for passing a structure to a function and returning a structure can be given as,
struct struct_name func_name(struct struct_name struct_var);

#include <stdio.h>typedef
struct
{
int x;int y;
}POINT;

void display(POINT);

6
void main()
{
POINT p1 = {2, 3};
display(p1);
}

void display(POINT p)
{
printf("The coordinates of the point are: %d %d", p.x, p.y);
}

3. Passing Structures through Pointers

 The syntax to declare a pointer to a structure can be given as,

 For the student structure, we can declare a pointer variable by writing

struct student *ptr_stud, stud;
And to assign the address, we will write
ptr_stud = &stud;
 To access the members of a structure, we can write
/* get the structure, then select a member */
(*ptr_stud).roll_no;
This operator is known as ‘pointing-to’ operator (->). It can be used as:ptr_stud ->roll_no
= 01;

Example: Write a program using pointer to structure to initialize the members in thestructure.
#include<stdio.h>struct
student
{
int r_no;
char name[20]; char course[20];
float fees;
};

void main()
{
struct student stud1, *ptr_stud1;ptr_stud1 = &stud1;
ptr_stud1->r_no = 01; strcpy(ptr_stud1->name,
"Rahul");strcpy(ptr_stud1->course, "BCA");

7
 ptr_stud1->fees = 45000;
printf("\n DETAILS OF STUDENT");
printf("\n ");
printf("\n ROLL NUMBER = %d", ptr_stud1->r_no);
printf("\n NAME = %s", ptr_stud1->name); printf("\n
COURSE = %s", ptr_stud1->course); printf("\n FEES
= %f", ptr_stud1->fees);
}

5.3 Union
 Like structure, a union is a collection of variables of different data types. The only difference
between a structure and a union is that in case of unions, you can only store information in one field
at any one time.
 To better understand union, think of it as a chunk of memory that is used to store variables of different
types. When a new value is assigned to a field, the existing data is replaced with the new data.

5.3.1 Declaring a Union

 The syntax for declaring a union is same as that of declaring a structure.
union union-name
{
data_type var-name;data_type var-
name;
……….
};
 Again, the typedef keyword can be used to simplify the declaration of union variables.
 The most important thing to remember about a union is that the size of an union is the size of its largest
field. This is because a sufficient number of bytes must be reserved to store the largest sized field.

5.3.2 Accessing a Member of a Union

 A member of a union can be accessed using the same syntax as that of a structure.
 To access the fields of a union, use the dot operator(.).
 That is the union variable name followed by the dot operator followed by the member name.

5.3.3 Initializing Unions

 It is an error to initialize any other union member except the first member.
 A striking difference between a structure and a union is that in case of a union, the fields share the same
memory space, so fresh data replaces any existing data. Look at the code given below and observe the
difference between a structure and union when their fields are to be initialized.
#include<stdio.h> typedef struct
POINT1
{
int x, y;
};
typedef union POINT2
{
int x;int y;
};

8
void main()
{
POINT1 P1 = {2,3};
// POINT2 P2 ={4,5}; Illegal with unionPOINT2 P2;
P2. x = 4;P2.y = 5;
printf("\n The co-ordinates of P1 are %d and %d", P1.x, P1.y);printf("\n The co-
ordinates of P2 are %d and %d", P2.x, P2.y);
}
Output:
The co-ordinates of P1 are 2 and 3 The co-
ordinates of P2 are 5 and 5

5.4 Unions inside Structures

 Union can be very useful when declared inside a structure. Consider an example in which you want a
field of a structure to contain a string or an integer, depending on what the user specifies. The following
code illustrates such a scenario.
struct student
{
union
{
char name[20];
introll_no;
};

int marks;
};
void main()
{
struct student stud;char
choice;
printf("\n You can enter the name or roll number of the student");printf("\n
Do you want to enter the name? (Yes or No) : "); scanf(&choice);
if(choice=='y' || choice=='Y')
{
printf("\n Enter the name : ");
scanf(“%s”,&stud.name);
}
else

{ printf("\n Enter the roll number : ");

scanf("%d", &stud.roll_no);
}
printf("\n Enter the marks : ");scanf("%d",
&stud.marks); if(choice=='y' || choice=='Y')
printf("\n Name : %s ", stud.name);
else
printf("\n Roll Number : %d ", stud.roll_no);
printf("\n Marks : %d", stud.marks);

9
}

5.5 Enumerated Data Types

 The enumerated data type is a user defined type based on the standard integer type.
 An enumeration consists of a set of named integer constants. That is, in an enumerated type, each
integer value is assigned an identifier. This identifier (also known as an enumeration constant) can be
used as symbolic names to make the program more readable.
 To define enumerated data types, enum keyword is used.
 Enumerations create new data types to contain values that are not limited to the values fundamental
data types may take. The syntax of creating an enumerated data type can be given as below.
enum enumeration_name{ identifier1, identifier2, …..., identifier n };
 Consider the example given below which creates a new type of variable called COLORS to store colors
constants.
enum COLORS {RED, BLUE, BLACK, GREEN, YELLOW, PURPLE, WHITE};
 In case you do not assign any value to a constant, the default value for the first one in the list - RED (in
our case), has the value of 0. The rest of the undefined constants have a value 1 more than its previous
one. So in our example,
RED = 0, BLUE = 1, BLACK = 2, GREEN = 3, YELLOW = 4, PURPLE = 5, WHITE =6
 If you want to explicitly assign values to these integer constants, then you should specifically mention
those values as shown below.
enum COLORS {RED = 2, BLUE, BLACK = 5, GREEN = 7, YELLOW, PURPLE, WHITE
= 15};
 As a result of the above statement, now
RED = 2, BLUE = 3, BLACK = 5, GREEN = 7, YELLOW = 8, PURPLE = 9, WHITE = 15

5.5.1 Enum Variables

 The syntax for declaring a variable of an enumerated data type can be given as,
enum enumeration_name variable_name;
 So to create a variable of COLORS, we may write:
enum COLORS bg_color;
 Another way to declare a variable can be as illustrated in the statement below.
enum COLORS {RED, BLUE, BLACK, GREEN, YELLOW, PURPLE, WHITE}bg_color,
fore_color;

5.5.2 Using the Typedef Keyword

 C permits to use typedef keyword for enumerated data types. For ex, if we write
typedef enum COLORS color;
 Then, we can straight-away declare variables by writing
color forecolor = RED;

5.5.3 Assigning values to Enumerated Variables

 Once the enumerated variable has been declared, values can be stored in it.
 However, an enumerated variable can hold only declared values for the type.
 For example, to assign the color black to the back ground color, we will write,
bg_color = BLACK;
 Once an enumerated variable has been assigned a value, we can store its value in another variable of
the same type as shown below.
enum COLORS bg_color, border_color; bg_color =
BLACK;

10
border_color = bg_color;

5.5.4 Enumeration Type Conversion

 Enumerated types can be implicitly or explicitly cast.
 For ex, the compiler can implicitly cast an enumerated type to an integer when required.
 However, when we implicitly cast an integer to an enumerated type, the compiler will either generate
an error or warning message.
 To understand this, answer one question. If we write:
enum COLORS{RED, BLUE, BLACK, GREEN, YELLOW, PURPLE, WHITE};
enum COLORS c;
c = BLACK + WHITE;
 Here, c is an enumerate data type variable. If we write, c = BLACK + WHITE, then logically, it should
be 2 + 6 = 8; which is basically a value of type int. However, the left hand side of the assignment
operator is of the type enumCOLORS. SO the statement would complain an error.
 To remove the error, you can do either of two things. First, declare c to be an int.
 Second, cast the right hand side in the following manner. :
c = enum COLORS(BLACK + WHITE);

5.5.5 Comparing Enumerated Types

 C also allows using comparison operators on enumerated data type. Look at the following statements
which illustrate this concept.
bg_color = (enum COLORS)6;
if(bg_color == WHITE)
fore_color = BLUE; fore_color
= BLACK; if(bg_color ==
fore_color)
printf("\n NOT VISIBLE");
 Since enumerated types are derived from integer type, they can be used in a switch-case statement.
enum {RED, BLUE, BLACK, GREEN, YELLOW, PURPLE, WHITE}bg_color;
switch(bg_color)
{
case RED: case BLUE:
case GREEN:

printf("\n It is a primary color");

case default: break;

printf("\n It is not a primary color");

} break;

11
 5.5.6 Input/Output Operations on Enumerated Types
 Since enumerated types are derived types, they cannot be read or written using formatted I/O
functions available in C. When we read or write an enumerated type, we read/write it as an integer.
The compiler would implicitly do the type conversion as discussed earlier.
enum COLORS(RED, BLUE, BLACK, GREEN, YELLOW, PURPLE, WHITE};
enum COLORS c; c =
RED;
printf("\n Color = %d", c);

5.5.7 Differences between structure and union

Structure Union
The struct keyword is used to define it. The union keyword is used to define it.
Syntax: Syntax:
struct struct–name union union-name
{ {
data_type var–name; data_type var-name;
data_type var–name; data_type var-name;
............... ……….
}; };
Example: Example:
struct student union student
{ {
int r_no; int r_no;
char name[20]; char char name[20]; char
course[20];float fees; course[20];float fees;
}; };

A variable of structure student can be defined by A variable of union student can be defined by
writing: writing:
struct student stud1; union student stud1;
Several members of a structure can be initialized at Individual members of a structure can be initialized
once. one by one.
Ex: Ex:
struct student stud1 = {01, "Rahul", "BCA", union student stud1;
45000}; stud1. r_no=01;
stud1. name= "Rahul";
stud1. course="BCA";
stud1. fees =45000;
Each member within structure is assigned unique The members or fields share the same memory
storage area of location. space, so fresh data replaces any existing data.
The size of the structure is the sum of all members The size of the union is the size of the largest
or fields. member or field.
Altering the value of a member will not affect other Altering any value of a member will alter other
members of the structure. member values.

12
 Module 5
Files
5.6 Introduction to Files

 A file is a collection of data stored on a secondary storage device like hard disk.
 A file is basically used because real life applications involve large amounts of data and in such situations
the console oriented I/O operations pose two major problems:
 First, it becomes cumbersome and time consuming to handle huge amount of data through
terminals.
 Second, when doing I/O using terminal, the entire data is lost when either the program is
terminated or computer is turned off. Therefore, it becomes necessary to store data on a
permanent storage (the disks) and read whenever necessary, without destroying the data.

5.6.1 Streams in C
 In C, the standard streams are termed as pre-connected input and output channels between a text
terminal and the program (when it begins execution).
 Therefore, stream is a logical interface to the devices that are connected to the computer.
 Stream is widely used as a logical interface to a file where a file can refer to a disk file, the computer
screen, keyboard, etc.
 Although files may differ in the form and capabilities, all streams are the same.
 The three standard streams (figure 16.1) in C languages are- standard input (stdin), standard output
(stdout) and standard error (stderr).
 Standard input (stdin): Standard input is the stream from which the program receives its data.
The program requests transfer of data using the read operation. However, not all programs require
input. Generally, unless redirected, input for a program is expected from the keyboard.
 Standard output (stdout): Standard output is the stream where a program writes its output
data. The program requests data transfer using the write operation. However, not all programs
generate output.
 Standard error (stderr): Standard error is basically an output stream used by programs to
report error messages or diagnostics. It is a stream independent of standard output and can be
redirected separately. No doubt, the standard output and standard error can also be directed to the
same destination.
 A stream is linked to a file using an open operation and disassociated from a file using a close operation.

Figure 16.1 Standard Streams

13
5.6.2 Buffer Associated with File Stream
 When a stream linked to a disk file is created, a buffer is automatically created and associated
with the stream.
 A buffer is nothing but a block of memory that is used for temporary storage of data that has to
be read from or written to a file.
 Buffers are needed because disk drives are block oriented devices as they can operate efficiently when
data has to be read/ written in blocks of certain size. The size of ideal buffer size is hardware dependant.
 The buffer acts as an interface between the stream (which is character-oriented) and the disk
hardware (which is block oriented).
 When the program has to write data to the stream, it is saved in the buffer till it is full. Then the entire
contents of the buffer are written to the disk as a block as shown in figure 16.2.

Figure 16.2 Buffers associated with streams

 Similarly, when reading data from a disk file, the data is read as a block from the file and written into
the buffer. The program reads data from the buffer. The creation and operation of the buffer is
automatically handled by the operating system. However, C provides some functions for buffer
manipulation. The data resides in the buffer until the buffer is flushed or written to a file.

5.6.3 Types of Files

 In C, the types of files used can be broadly classified into two categories- text files and binary files.

1. ASCII Text files

 A text file is a stream of characters that can be sequentially processed by a computer in forward
direction. For this reason a text file is usually opened for only one kind of operation (reading, writing,
or appending) at any given time.
 Because text files only process characters, they can only read or write data one character at a time.
 In a text file, each line contains zero or more characters and ends with one or more characters that
specify the end of line. Each line in a text file can have maximum of 255 characters.
 A line in a text file is not a C string, so it is not terminated by a null character.
 When data is written to a text file, each newline character is converted to a carriage return/line feed
character. Similarly, when data is read from a text file, each carriage return/ line feed character is
converted in to newline character.
 Another important thing is that when a text file is used, there are actually two representations of data-
internal or external. For ex, an int value will be represented as 2 or 4 bytes of memory internally but
externally the int value will be represented as a string of characters representing its decimal or
hexadecimal value. To convert internal representation into external, we can use printf and fprintf
functions. Similarly, to convert an external representation into internal scanf and fscanf can be used.

14
 2. Binary Files
 A binary file is a file which may contain any type of data, encoded in binary form for computer
storage and processing purposes.
 Like a text file, a binary file is a collection of bytes.
 Note that in C a byte and a character are equivalent. Therefore, a binary file is also referred to as a
character stream with following two essential differences.
 A binary file does not require any special processing of the data and each byte of data is
transferred to or from the disk unprocessed.
 C places no constructs on the file, and it may be read from, or written to, in any manner the
programmer wants.
 Binary files store data in the internal representation format. Therefore, an int value will be stored I
binary form as 2 or byte value. The same format is used to store data in memory as well as in file. Like
text file, binary file also ends with an EOF marker.
 Binary files can be either processed sequentially or randomly.
 In a text file, an integer value 123 will be stored as a sequence of three characters- 1, 2 and 3. So each
character will take 1 byte and therefore, to store the integer value 123 we need 3 bytes. However, in a
binary file, the int value 123 will be stored in 2 bytes in the binary form. This clearly indicates that
binary files takes less space to store the same piece of data and eliminates conversion between
internal and external representations and are thus more efficient than the text files.

5.7 Using Files in C

 To use files in C, we must follow the steps given below.
 Declare a file pointer variable
 Open the file
 Process the file
 Close the file

1. Declaring a File Pointer Variable

 There can be a number of files on the disk. In order to access a particular file, you must specify the
name of the file that has to be used.
 This is accomplished by using a file pointer variable that points to a structure FILE (defined in
stdio.h).
 The file pointer will then be used in all subsequent operations in the file.
 The syntax for declaring a file pointer is
FILE *file_pointer_name;
 For example, if we write
FILE *fp;
Then, fp is declared as a file pointer.
 An error will be generated if you use the filename to access a file rather than the file pointer

2. Opening a File
 A file must be first opened before data can be read from it or written to it.
 In order to open a file and associate it with a stream, the fopen() function is used.
 The prototype of fopen() can be given as:
FILE *fopen(const char *file_name, const char *mode);
 Using the above prototype, the file whose pathname is the string pointed to by file_name is opened in
the mode specified using the mode.

15
  If successful, fopen() returns a pointer-to-structure and if it fails, it returns NULL.

File Name
 Every file on the disk has a name associated with it.
 In DOS the file name can have one to eight characters optionally followed by a period and an
extension that has one to three characters.
 Windows and UNIX permit filenames having maximum of 256 characters.
 In C, fopen() may contain the path information instead of specifying the filename. The path gives
information about the location of the file on the disk.

File Mode
 Mode conveys to C the type of processing that will be done with the file.
 The different modes in which a file can be opened for processing are given in Table below:
MODE DESCRIPTION
r Open a text file for reading. If the stream (file) does not exist then an error will be reported.
Open a text file for writing. If the stream does not exist then it is created otherwise if the file
w
already exists, then its contents would be deleted
a Append to a text file. if the file does not exist, it is created.
Open a binary file for reading. B indicates binary. By default this will be a sequential file in
rb
Media 4 format
wb Open a binary file for writing
ab Append to a binary file
Open a text file for both reading and writing. The stream will be positioned at the beginningof
r+ the file. When you specify "r+", you indicate that you want to read the file before you write
to it. Thus the file must already exist.
Open a text file for both reading and writing. The stream will be created if it does not exist,
w+
and will be truncated if it exists.
Open a text file for both reading and writing. The stream will be positioned at the end of the
a+
file content.
r+b/ rb+ Open a binary file for read/write
w+b/wb+ Create a binary file for read/write
a+b/ab+ Append a binary file for read/write

 The fopen() can fail to open the specified file under certain conditions that are listed below:
 Opening a file that is not ready for usage.
 Opening a file that is specified to be on a non-existent directory/drive.
 Opening a non-existent file for reading.
 Opening a file to which access is not permitted.

Ex:
FILE *fp;
fp = fopen("Student.DAT", "r"); if(fp==NULL)
{
printf("\n The file could not be opened");exit(1);
} OR
char filename[30];FILE *fp;
gets(filename);
fp = fopen(filename, "r+");

16
if(fp==NULL)
{
printf("\n The file could not be opened");exit(1);
}

3. Closing a File Using fclose()

 To close an opened file, the fclose() function is used which disconnects a file pointer from a file.
 After the fclose() has disconnected the file pointer from the file, the pointer can be used to access a
different file or the same file but in a different mode.
 The fclose() function not only closes the file but also flushes all the buffers that are maintained for
that file
 If you do not close a file after using it, the system closes it automatically when the program exits.
However, since there is a limit on the number of files which can be open simultaneously; the
programmer must close a file when it has been used.
 The prototype of the fclose() function can be given as,
int fclose(FILE *fp);
Here, fp is a file pointer which points to the file that has to be closed. The function returns an integer value
which indicates whether the fclose() was successful or not. A zero is returned if the function was successful;
and a non-zero value is returned if an error occurred.

5.8 Read Data from Files

 C provides the following set of functions to read data from a file.
 fscanf()
 fgets()
 fgetc()
 fread()

1. fscanf()
 The fscanf() is used to read formatted data from the stream.
 The syntax of the fscanf() can be given as,
int fscanf(FILE *stream, const char *format,…);
 The fscanf() is used to read data from the stream and store them according to the parameter
format into the locations pointed by the additional arguments.
Ex:
#include<stdio.h>
void main()
{
FILE *fp;
char name[80];int roll_no;
fp = fopen("Student.DAT", "r");
if(fp==NULL)
{
printf("\n The file could not be opened");exit(1);
}
printf("\n Enter the name and roll number of the student : ");
fscanf(stdin, "%s %d", name, &roll_no); /* read from keyboard */

17
printf(“\n NAME : %s \t ROLL NUMBER = %d", name, roll_no); // READ FROM FILE-
Student.DAT
fscanf(fp, "%s %d", name, &roll_no);
printf(“\n NAME : %s \t ROLL NUMBER = %d", name, roll_no);fclose(fp);
}

2. fgets()
 fgets() stands for file get string.
 The fgets() function is used to get a string from a stream.
 The syntax of fgets() can be given as:
char *fgets(char *str, int size, FILE *stream);
 The fgets() function reads at most one less than the number of characters specified by size (gets
size - 1 characters) from the given stream and stores them in the string str. The fgets() terminates
as soon as it encounters either a newline character or end-of-file or any other error. However, if a
newline character is encountered it is retained. When all the characters are read without any error, a '\0'
character is appended to end the string.
Ex:
#include<stdio.h>
void main()
{
FILE *fp; char str[80];
fp = fopen("Student.DAT", "r");
if(fp==NULL)
{
printf("\n The file could not be opened");exit(1);
}
while (fgets(str, 80, fp) != NULL)printf("\n
%s", str);
printf("\n\n File Read. Now closing the file");fclose(fp);
}

3. fgetc()
 The fgetc() function returns the next character from stream, or EOF if the end of file is reached
or if there is an error.
 The syntax of fgetc() can be given as
int fgetc( FILE *stream );
 fgetc returns the character read as an int or return EOF to indicate an error or end of file.
 fgetc() reads a single character from the current position of a file (file associated with stream). After
reading the character, the function increments the associated file pointer (if defined) to point to the next
character. However, if the stream has already reached the end of file, the end-of-file indicator for the
stream is set.
Ex: Write a C program to copy a text file to another, read both the input file name and target file name.

#include <stdio.h>
#include <stdlib.h>

18
void main()
{
FILE *fptr1, *fptr2;
char filename1[100], filename2[100],ch;

printf("Enter the filename to open for reading: \n");

scanf("%s", filename1);

fptr1 = fopen(filename1, "r");if (fptr1

== NULL)
{
printf("Error in opening the file");exit(0);
}

printf("Enter the filename to open for writing: \n");scanf("%s",

filename2);

fptr2 = fopen(filename2, "w");if (fptr2

== NULL)
{
printf("Error in opening the file");exit(0);
}

while (!feof(fptr1))
{
ch=fgetc(fptr1);
fputc(ch,fptr2);
}

printf("\n Contents copied to %s", filename2);

fclose(fptr1);
fclose(fptr2);
}

4. fread()
 The fread() function is used to read data from a file.
 Its syntax can be given as
int fread( void *str, size_t size, size_t num, FILE *stream );
 The function fread() reads num number of objects (where each object is size bytes) and places them
into the array pointed to by str. The data is read from the given input stream.
 Upon successful completion, fread() returns the number of bytes successfully read. The number
of objects will be less than num if a read error or end-of-file is encountered. If size or num is 0, fread()

19
will return 0 and the contents of str and the state of the stream remain unchanged. In case of error, theerror
indicator for the stream will be set.
 The fread() function advances the file position indicator for the stream by the number of bytes read.
Ex:
#include <stdio.h>void
main()
{
FILE *fp; char str[10];
fp = fopen("Letter.TXT", "r+");
if(fp==NULL)
{
printf("\n The file could not be opened");exit(1);
}
fread(str, 1, 10, fp);
str[10]= '\0';
printf("\n First 9 characters of the file are : %s", str);fclose(fp);
}

5.9 Writing Data to Files

 C provides the following set of functions to read data from a file.
 fprintf()
 fputs()
 fputc()
 fwrite()

1. fprintf()
 The fpritnt() is used to write formatted output to stream.
 Its syntax can be given as,
int fprintf ( FILE * stream, const char * format, ... );
 The function writes to the specified stream, data that is formatted as specified by the format argument.
After the format parameter, the function can have as many additional arguments as specified in format.
 The parameter format in the fprintf() is nothing but a C string that contains the text that has to be written
on to the stream.
Ex:
#include <stdio.h>void
main()
{
FILE *fp;int i;
char name[20];float salary;
fp = fopen("Details.TXT", "w");
if(fp==NULL)
{
printf("\n The file could not be opened");

20
exit(1);
}
for(i=0;i<10;i++)
{
printf ("\n Enter your name : ");gets(name);
printf ("\n Enter your salary : ");scanf("%f",
&salary);
fprintf(fp, " NAME : %s \t SALARY: %f", name, salary);
}
fclose(fp);
}

2. fputs()
 The fputs() is used to write a line into a file.
 The syntax of fputs() can be given as
int fputs( const char *str, FILE *stream );
 The fputs() writes the string pointed to by str to the stream pointed to by stream.
 On successful completion, fputs() returns 0. In case of any error, fputs() returns EOF.
Ex:
#include<stdio.h>void
main()
{
FILE *fp;
char feedback[100];
fp = fopen("Comments.TXT", "w");
if(fp==NULL)
{
printf("\n The file could not be opened");exit(1);
}
printf("\n Kindly give the feedback on this book : ");
gets(feedback);
fputs(feedback, fp);fclose(fp);
}

3. fputc()
 The fputc() is used to write a character to the stream.
 The syntax of fputc() can be given as,
int fputc(int c, FILE *stream);
 The fputc() function will write the byte specified by c (converted to an unsigned char) to the output
stream pointed to by stream. Upon successful completion, fputc() will return the value it has written.
Otherwise, in case of error, the function will return EOF and the error indicator for the stream will be
set.
Ex: #include<stdio.h>
void main()
{
FILE *fp;
char feedback[100];

21
int i;
fp = fopen("Comments.TXT", "w");
if(fp==NULL)
{
printf("\n The file could not be opened");exit(1);
}
printf("\n Kindly give the feedback on this book : ");
gets(feedback);
for(i=0;i<feedback[i];i++)
fputc(feedback[i], fp);
fclose(fp);
}

4. fwrite()
 The fwrite() is used to write data to a file.
 The syntax of fwrite() can be given as,
int fwrite(const void *str, size_t size, size_t count, FILE *stream);
 The fwrite() function will write, from the array pointed to by str, up to count objects of size specified
by size, to the stream pointed to by stream.
 The file-position indicator for the stream (if defined) will be advanced by the number of bytes
successfully written. In case of error, the error indicator for the stream will be set.
Ex: #include<stdio.h>
void main()
{
FILE *fp; size_t count;
char str[] = "GOOD MORNING ";
fp = fopen("Welcome.txt", "wb");
if(fp==NULL)
{
printf("\n The file could not be opened");exit(1);
}
count = fwrite(str, 1, strlen(str), fp);
printf("\n %d bytes were written to the files”, count);fclose(fp);
}
 fwrite() can be used to write characters, integers, structures, etc to a file. However, fwrite() can be
used only with files that are opened in binary mode.

5.10 Detecting the End-Of-File

 In C, there are two ways to detect the end-of-file.
1. While reading the file in text mode, character by character, the programmer can compare the
character that has been read with the EOF, which is a symbolic constant defined in stdio.h with a
value -1.
while(1)
{
c = fgetc(fp); // here c is an int variable

22
if (c==EOF) break;
printf("%c", c);
}
2. The other way is to use the standard library function feof() which is defined in stdio.h. The feof()
is used to distinguish between two cases
 When a stream operation has reached the end of a file
 When the EOF ("end of file") error code has been returned as a generic error indicator even
when the end of the file has not been reached
 The prototype of feof() can be given as:
int feof(FILE *fp);
 feof() returns zero (false) when the end of file has not been reached and a one (true) if the end-of-filehas
been reached.
while( !feof(fp)
{ fgets(str, 80, fp);
printf("\n %s", str);
}