Structure In C Programming
Arrays are used to store large set of data and manipulate them but the
disadvantage is that all the elements stored in an array are to be of the same
data type. If we need to use a collection of different data type items it is
not possible using an array. When we require using a collection of different
data items of different data types we can use a structure. Structure is a
method of grouping data of different types. A structure is a convenient
method of handling a group of related data items of different data
types.
Structure declaration:
General
format:
struct
tag_name{
data
type member1;
data
type member2;
…
};
Example:
struct
lib_books
{
char title[20];
char
author[15];
int
pages;
float
price;
};
the
keyword struct declares a structure to holds the details of four fields namely
title, author pages and price. These are members of the structures. Each member
may belong to different or same data type. The tag name can be used to define
objects that have the tag names structure. The structure we just declared is
not a variable by itself but a template for the structure. We can declare
structure variables using the tag name anywhere in the program. For example the
statement,
struct
lib_books book1, book2, book3;
declares
book1, book2, book3 as variables of type struct lib_books each declaration has
four elements of the structure lib_books. The complete structure
declaration might look like this
struct lib_books
{
char
title[20];
char
author[15];
int
pages;
float
price;
};
struct lib_books,
book1, book2, book3;
structures
do not occupy any memory until it is associated with the structure variable
such as book1. The template is terminated with a semicolon. While the entire
declaration is considered as a statement, each member is declared independently
for its name and type in a separate statement inside the template. The tag name
such as lib_books can be used to declare structure variables of its data type
later in the program. We can also combine both template declaration and
variables declaration in one statement, the declaration
struct
lib_books
{
char
title[20];
char
author[15];
int
pages;
float
price;
}
book1, book2, book3;
is
valid. The use of tag name is optional for example
struct
{
…
…
…
}
book1, book2, book3;
declares
book1, book2, book3 as structure variables representing 3 books but does not
include a tag name for use in the declaration.
A
structure is usually defining before main along with macro definitions. In such
cases the structure assumes global status and all the functions
can access the structure.
Giving values to members
As
mentioned earlier the members themselves are not variables they should be
linked to structure variables in order to make them meaningful
members. The link between a member and a variable is established
using the member operator „. ‟ which is known as dot operator or
period operator. For example:
Book1.price
Is
the variable representing the price of book1 and can be treated like any other
ordinary variable. We can use scanf statement to assign values
like
scanf(“%s”,book1.file);
scanf(“%d”,& book1.pages);
Or
we can assign variables to the members of book1
strcpy(book1.title,”basic”);
strcpy(book1.author,”Balagurusamy”);
book1.pages=250;
book1.price=28.50;
Assignment to Students
Explain
how to access array elements and to display those elements under two topics:
(i) Accessing array elements (ii) displaying array
elements.
Functions and structures
We
can pass structures as arguments to functions. Unlike array names however,
which always point to the start of the array, structure names are
not pointers. As a result, when we change structure parameter
inside a function, we don‟t affects its corresponding argument.
Passing structure to elements to
functions
A
structure may be passed into a function as individual member or a separate
variable. A program example to display the contents of a
structure passing the individual elements to a function is shown
below.
#include
#include
void
fun(float,int);
void
main()
{
struct
student
{
float
marks;
int
id;
};
struct
student s1={67.5,14};
fun(s1.marks,s1.id);
getch();
}
void
fun(float marks,int id)
{
printf("\nMarks:%f",marks);
printf("\nID:%d",id);
}
It
can be realized that to pass individual elements would become more tedious as
the number of structure elements go on increasing a better way would be to pass the entire
structure variable at a time.
Passing entire structure to functions
In
case of structures having to having numerous structure elements passing these
individual elements would be a tedious task. In such cases we may
pass whole structure to a function as shown below:
#
include stdio.h>
{
int
emp_id;
char
name[25];
char
department[10];
float
salary;
};
void
main()
{
static
struct employee emp1= { 12, “sadanand”, “computer”, 7500.00 };
/*sending
entire employee structure*/
display(emp1);
}
/*function
to pass entire structure variable*/
display(empf)
struct
employee empf
{
printf(“%d%s,%s,%f”,
empf.empid,empf.name,empf.department,empf.salary);
}
Arrays of structure
It
is possible to define an array of structures for example if we are maintaining
information of all the students in the college and if 100 students are studying
in the college. We need to use an array than single variables. We can define an
array of structures as shown in the following example:
structure information
{
int
id_no;
char
name[20];
char
address[20];
char
combination[3];
int
age;
}
student[100];
An
array of structures can be assigned initial values just as any other array can.
Remember that each element is a structure that must be assigned
corresponding initial values as illustrated
below.
#include<
stdio.h >
void
main()
{
struct
info
{
int
id_no;
char
name[20];
char
address[20];
char
combination[3];
int
age;
};
struct
info std[100];
int
i,n;
printf(“Enter
the number of students”);
scanf(“%d”,&n);
for(i=0;i
< n;i++)
{
printf(“
Enter Id_no,name address combination age\m”);
scanf("%d%s%s%s%d”,&std[I].id_no,std[I].name,std[I].address,std[I].
combination,&std[I].age);
}
printf(“\n
Student information”);
for
(I=0;I< n;I++)
{
printf(“%d%s%s%s%d\n”,
std[I].id_no,std[I].name,std[I].address,std[I].combination,std[I].age);
}
}
Structure within a structure
A
structure may be defined as a member of another structure. In such structures, the declaration of the embedded structure must appear before the declarations of other structures. struct date int id_no;
{
char
name[20];
int
day;
char
address[20];
int
month;
char
combination[3];
int
year; int age;
};
structure
date def;
struct
student structure date doa;
{
}oldstudent, newstudent;
the
structure student contains another structure date as its one of its
members.
Comments
Post a Comment
Subscribe Us and Thanks for visiting blog.