-
Structure is usually a collection of
dissimilar data types; unlike an array which is a collection of
similar data types. Usually a structure is declared first followed by
definition of a structure variable as shown
below:
/* declaration of a structure */ struct
book { char name[20] ;
int numpages ; float price ; } ;
/*
definition of a structure variable */ struct book b ;
-
A structure variable can be initialized at
the same place where it is being defined, as in struct book b = {
"Basic", 425, 135.00 } ;
-
Declaration of a structure and definition
of a structure variable can be combined into one. When this done
mentioning the structure name is
optional.
struct { char name[20]
; int numpages ; float price
; } b = { "Basic", 425, 135.00 } ;
-
Size of a structure variable is sum of
sizes of its individual elements. For example, size of
b in (c) above is: 20 + 2 + 4 = 26 bytes.
-
Elements of a structure are stored in
adjacent memory locations. For example, the following program would
produce the output 4001, 4021, 4023.
-
struct book {
char name[20] ; int numpages
; float price ; } ; struct book b = {
"Basic", 425, 135.00 } ; printf ( "%u %u %u", b.name,
&b.numpages, &b.price ) ;
-
It is possible to build an array of
structures. struct book
{ char name[20]
; int numpages
; float price
; } ; struct book b[ ] =
{ { "Basic", 425, 135.00 },
{ "Pascal", 500, 155.00 }, { "VBasic", 625, 335.00
}
} ;
-
Nested structures are legal as
in:
struct address { char city[20]
; long int pin ; } ; struct
emp { char n[20] ; int
age ; struct address a ;
float s ; } ; struct emp e = { "Rahul", 23, "Nagpur", 440010,
4000.50 } ;
-
Contents of one structure variable can be
copied either into another structure variable either piece meal
or at one shot. This is shown below:
struct
book { char name[20] ;
int numpages ; float price ; } ;
struct
book b1 = { "Basic", 425, 135.00 } ; struct book b2, b3 ;
/*
piecemeal copying */ strcpy ( b2.n, b1.n ) ; b2.numpages =
b1.numpages ; b2.price = b1.price ;
/* copying at one shot
*/ b3 = b2 ;
-
Elements of a structure can be passed to a
function.
main( ) { struct
book {
char name[20] ;
int numpages ; float
price ; } ;
struct book
b1 = { "Basic", 425, 135.00 } ;
/* mixed call
- call be value + call by reference
*/ display ( b1.name,
b1.numpages, b1.price ) ;
/* pure call by
reference */ show ( b1.name,
&b1.numpages, &b1.price ) ; }
display ( char *n, int
nop, float pr ) { printf ( "%s %d %f", n, nop,
pr ) ; }
display ( char *n, int *nop, float *pr
) { printf ( "%s %d %f", n, *nop, *pr )
; }
-
Entire structure can also be passed to a
function.
// declaration must be global. // Otherwise
diaplay1() and show1() can't use it struct book {
char name[20] ; int
numpages ; float price ; } ;
main(
) { struct book b1 = { "Basic", 425, 135.00 }
; // call be value display1
( b1 ) ;
// call by reference show1
( &b1 ) ; }
display1 ( struct book b2
) { printf ( "%s %d %f", b2.name, b2.numpages,
b2.price ) ; }
show1 ( struct book *b2
) { printf ( "%s %d %f", ( *b2 ).name, ( *b2
).numpages, ( *b2 ).price ) ; printf ( "%s %d %f",
b2->name, b2->numpages, b2->price ) ; }
-
Self referential structures contain a
pointer to itself within its declaration. These are necessary for
building linked lists.
struct node { int
data ; node *link ; } ;
What will be the output of the following
program
main( )
{
struct
s1
{
char *z
;
int i
;
struct
s1 *p ;
}
;
static
struct s1 a[ ] = {
{
"Nagpur", 1, a + 1 },
{
"Raipur", 2, a + 2 },
{
"Kanpur", 3, a }
}
;
struct
s1 *ptr = a ;
printf (
"\n%s %s %s", a[0].z, ptr->z, a[2].p->z ) ;
}
Output Nagpur Nagpur Nagpur
Explanation: The zeroth and first
elements of struct s1 are a char pointer and an
int respectively. The second element is what's
new. It is a pointer to a structure. That is,
p stores the starting address of a structure variable of the type
struct s1. Next, a[ ], an array of such structures is
declared as well as initialised. During initialisation the base address of
"Nagpur" is stored in a[0].z, 1 is stored in the
element a[0].i, and a + 1 is assigned to
a[0].p. On similar lines, the remaining two elements of the array
are initialised. a[1].z, a[1].i and
a[1].p are assigned "Raipur", 2 and a + 2 in
that order, and "Kanpur", 3 and a are stored at
a[2].z, a[2].i and a[2].p respectively. What
exactly do a, a + 1 and a + 2 signify? a, of
course, is the base address of the array a[ ]. Let us assume it
to be 4000, as shown in Figure 1. Locations 4000 and 4001 are
occupied by the char pointer a[0].z, since a
pointer is always two bytes long.
The next two bytes are used to
store the integer a[0].i, and then 4004 and 4005 are used
by a[0].p. Similarly, the next 6 bytes store the
first structure a[1], and the 6 bytes after that contain
a[2], the second structure in the array.
 Figure
1.
Now, when we say a + 1, we do not
arrive at 4001, but at 4006. This is because on incrementing any pointer,
it points to the next location of its type. a points to the
zeroth structure in the array, i.e. a[0]. Hence, on incrementing
a, it will point to the next immediate element of its type,
i.e. the first structure a[1] of the array. Likewise, a + 2 signifies the
address of the second element a[2] of the array. Thus,
a[0].p contains address 4006 (refer figure), a[1].p
contains 4012, and a[2].p stores 4000. A struct pointer ptr
is now set up, which is assigned a, the base address of the array. In the
printf( ), a[0].z denotes the address from where "Nagpur"
is stored. Hence "Nagpur" gets printed out. Since ptr contains
the address of a[0], ptr->z refers to the contents of element
z of the array element a[0]. Thus ptr->z gives the
address A0 (refer figure) and this address happens to be the base
address of the string "Nagpur". Hence "Nagpur" gets printed out. Let us
now analyse the expression a[2].p->z. The left side of the
arrow operator always represents the base address of a structure. What
structure does a[2].p point to? Looking at the figure we
can confirm that a[2].p contains the address 4000, which is the
base address of the array a[ ]. Hence the expression
a[2].p->z can also be written as a->z. Since a is
the base address of the structure a[0], this expression refers to
the element z of the zeroth structure. Thus, "Nagpur" gets
printed for the third time.
What will be the output of the following
program
main( )
{
struct
s1
{
char
*str ;
int i
;
struct
s1 *ptr ;
}
;
static
struct s1 a[ ] = {
{
"Nagpur", 1, a + 1 },
{
"Raipur", 2, a + 2 },
{
"Kanpur", 3, a }
} ;
struct
s1 *p = a ;
int j
;
for ( j
= 0 ; j <<= 2 ; j++ )
{
printf (
"\n%d " , --a[j].i ) ;
printf (
"%s" , ++a[j].str ) ;
}
} Output
0 agpur
1 aipur
2 anpur
Explanation The example deals with a structure similar to the
one we just encountered. Picking up from the for loop, it is executed for
3 values of j: 0, 1 and 2. The first time through the for loop, j
is equal to zero, so the first printf( ) prints --a[0].i.
Since the dot operator has a higher priority, first a[0].i is
evaluated, which is 1. As -- precedes the value to be printed, 1 is first
decremented to 0, and then printed out.
The second printf( ) prints the string
at address ++a[0].str. a[0].str gives the starting address of
"Nagpur". On incrementing, it points to the next character, `a' of
"Nagpur", so starting from `a', the remaining string "agpur" is outputted.
A similar procedure is repeated for j = 1, and then once again for
j = 2, following which the execution is terminated.
|