Program 48) Write a program to illustrate the comparison of structure variables.
This program shows that how a structure variable can be copied into another of the same type. It also performs member-wise comparison to decide whether two structure variables are identical.
PROGRAM
struct class
{
int number ;
char name [20] ;
float marks:
} ;
main ( )
{
int x ;
struct class student1 = {111, "Rao", 72.50} ;
struct class student2 = {222, "Reddy", 67.00} ;
struct class student3 ;
student3 = student2 ;
x = ( (student3.number == student2.number) &&
(student3.marks == student2.marks) ) ? 1 : 0 ;
if (x ==1)
{
printf ("\nstudent2 and student3 are same\n\n") ;
printf ("%d %s %f\n", student3.number,
student3.name, student3.marks) ;
}
else
printf ("\nstudent2 and student3 are different\n\n") ;
}
Output: student2 and student3 are same
222 Reddy 67.000000
Defining and accessing structures members
Program 47) Define a structure type, struct personal that would contain person name, data of joining and salary. Using this structure, write a program to read this information for one person from the keyboard and print the same on the screen.
Structure definition along with the program is shown below. The scanf and printf functions illustrate how the member operator '.' is used to link the structure member to the structure variables. The variable name with a period and the member name is used like an ordinary variable.
PROGRAM
struct personal
{
char name [20] ;
int day ;
char month [10] ;
int year ;
float salary ;
} ;
main ( )
{
struct personal person ;
printf ("Input values\n") ;
scanf ("%s %d %s %f",person.name, &person.day,
person.month, &person. year, person salary) ;
}
Output: Input values
M .L.Geol 10 January 1945 4500
M.L.Goel 10 January 1945 4500.00
Structure definition along with the program is shown below. The scanf and printf functions illustrate how the member operator '.' is used to link the structure member to the structure variables. The variable name with a period and the member name is used like an ordinary variable.
PROGRAM
struct personal
{
char name [20] ;
int day ;
char month [10] ;
int year ;
float salary ;
} ;
main ( )
{
struct personal person ;
printf ("Input values\n") ;
scanf ("%s %d %s %f",person.name, &person.day,
person.month, &person. year, person salary) ;
}
Output: Input values
M .L.Geol 10 January 1945 4500
M.L.Goel 10 January 1945 4500.00
Illustration of static variable
Program 46) Write a program to illustrate the properties of static variable.
This program explains the behaviour of a static variable
PROGRAM
void stat (void) ;
main ( )
{
int i ;
for (i = 1; i <=3; i++)
stat ( ) ;
}
void stat (void)
{
static int x = 0 ;
x = x + 1 ;
printf ("x = %d\n", x) ;
}
Output: x = 1
x = 2
x = 3
A static variable is initialized only once, when the program is compiled. It is never initialized again. During the first call to stat, x is incremented to 1. Because x is static, this value persists and therefore, the next call adds another 1 to x giving it a value of 2. The value of x becomes three when the third call is made.
Had we declared x as an auto variable, the output would have been:
x = 1
x = 1
x = 1
This is because each time stat is called, the auto variable x is initialized to zero. When the function terminates, ita value of 1 is lost.
An external static variable is declared outside of all functions and is available to all the functions in that program. The difference between a static external variable and a simple external variable is that the static external variable is available only within the file where it is defined while the simple external variable can be accessed by other files.
It is also possible to control the scope of the function. For example, we would like a particular function accessible only to the functions in the file in which it is defined, and not to any function in other files. This can be accomplished by defining 'that' function with the storage class static.
This program explains the behaviour of a static variable
PROGRAM
void stat (void) ;
main ( )
{
int i ;
for (i = 1; i <=3; i++)
stat ( ) ;
}
void stat (void)
{
static int x = 0 ;
x = x + 1 ;
printf ("x = %d\n", x) ;
}
Output: x = 1
x = 2
x = 3
A static variable is initialized only once, when the program is compiled. It is never initialized again. During the first call to stat, x is incremented to 1. Because x is static, this value persists and therefore, the next call adds another 1 to x giving it a value of 2. The value of x becomes three when the third call is made.
Had we declared x as an auto variable, the output would have been:
x = 1
x = 1
x = 1
This is because each time stat is called, the auto variable x is initialized to zero. When the function terminates, ita value of 1 is lost.
An external static variable is declared outside of all functions and is available to all the functions in that program. The difference between a static external variable and a simple external variable is that the static external variable is available only within the file where it is defined while the simple external variable can be accessed by other files.
It is also possible to control the scope of the function. For example, we would like a particular function accessible only to the functions in the file in which it is defined, and not to any function in other files. This can be accomplished by defining 'that' function with the storage class static.
Illustration of properties of global variables
Program 45) Write a multifunction program to illustrate the properties of global variables.
This program illustrate the properties of global variables. Note that variable x is used in all functions but none except fun2, has a definition for x. Because x has been declared 'above' all the functions, it is available to each function without having to pass x as a function argument. Further, since the value of x is directly available, we need not use return(x) statements in fun1 and fun3. However, since fun2 has a definition of x, it returns its local value of x and therefore uses a return statement. In fun2, the global x is not visible. The local x hides its visibility here.
PROGRAM
int fun1 (void) ;
int fun2 (void) ;
int fun3 (void) ;
int x ; /* Global */
main ( )
{
x = 10 ; /* Global */
printf ("x = %d\n", x) ;
printf ("x = %d\n", fun1() ) ;
printf ("x = %d\n", fun2() ) ;
printf ("x = %d\n", fun3() ) ;
}
fun1 (void)
{
x = x + 10 ;
}
int fun2 (void)
{
int x ; /* Loacl */
x = 1 ;
return (x) ;
}
fun3 (void)
{
x = x + 10 ; /* Global */
}
Output: X = 10
X = 20
X = 1
X = 30
Once a variable has been declared as global, any function can use it and change its value. Then, subsequent functions can reference only that new value.
This program illustrate the properties of global variables. Note that variable x is used in all functions but none except fun2, has a definition for x. Because x has been declared 'above' all the functions, it is available to each function without having to pass x as a function argument. Further, since the value of x is directly available, we need not use return(x) statements in fun1 and fun3. However, since fun2 has a definition of x, it returns its local value of x and therefore uses a return statement. In fun2, the global x is not visible. The local x hides its visibility here.
PROGRAM
int fun1 (void) ;
int fun2 (void) ;
int fun3 (void) ;
int x ; /* Global */
main ( )
{
x = 10 ; /* Global */
printf ("x = %d\n", x) ;
printf ("x = %d\n", fun1() ) ;
printf ("x = %d\n", fun2() ) ;
printf ("x = %d\n", fun3() ) ;
}
fun1 (void)
{
x = x + 10 ;
}
int fun2 (void)
{
int x ; /* Loacl */
x = 1 ;
return (x) ;
}
fun3 (void)
{
x = x + 10 ; /* Global */
}
Output: X = 10
X = 20
X = 1
X = 30
Once a variable has been declared as global, any function can use it and change its value. Then, subsequent functions can reference only that new value.
Working of automatic variables
Program 44) Write a multifunction to illustrate how automatic variables work.
A program with two subprograms function1 and function2 is shown below. m is an automatic variable and it is declared at the beginning of each function. m is initialized to 10, 100, and 1000 in function1, function2, and main respectively.
When executed, main calls function2 which in turn calls function1. When main is active, m = 1000; but when function2 is called, the main's m is temporarily put on t he shelf and the new local m = 100 becomes active. Similarly, when function1 is called, both the previous values of m are put on the shelf and t he latest value of m (=10) becomes active. As soon as function1 (m=10) is finished, function2 (m=100) takes over again. As soon it is done, main (m=1000) takes over. The output clearly shows that the value assigned to m in one function does not affect its value in the other functions; and the local value of m is destroyed when it leaves a function.
PROGRAM
void function1 (void) ;
void function2 (void) ;
main ( )
{
int m = 1000 ;
function2 ( ) ;
printf ("%d\n",m) ; /* Third output */
}
void function1 (void)
{
int m = 10 ;
printf ("%d\n",m) ; /* First output */
}
void function2 (void)
{
int m = 100 ;
function1 ( ) ;
printf ("%d\n",m) ; /* Second output */
}
Output: 10
100
1000
There are two consequences of the scope and longevity of auto variables worth remembering. First, any variable local to main will be normally alive throughout the whole program, although it is active only in main. Secondly, during recursion, the nested variables are unique auto variables, a situation similar to function-nested auto variables with identical names.
A program with two subprograms function1 and function2 is shown below. m is an automatic variable and it is declared at the beginning of each function. m is initialized to 10, 100, and 1000 in function1, function2, and main respectively.
When executed, main calls function2 which in turn calls function1. When main is active, m = 1000; but when function2 is called, the main's m is temporarily put on t he shelf and the new local m = 100 becomes active. Similarly, when function1 is called, both the previous values of m are put on the shelf and t he latest value of m (=10) becomes active. As soon as function1 (m=10) is finished, function2 (m=100) takes over again. As soon it is done, main (m=1000) takes over. The output clearly shows that the value assigned to m in one function does not affect its value in the other functions; and the local value of m is destroyed when it leaves a function.
PROGRAM
void function1 (void) ;
void function2 (void) ;
main ( )
{
int m = 1000 ;
function2 ( ) ;
printf ("%d\n",m) ; /* Third output */
}
void function1 (void)
{
int m = 10 ;
printf ("%d\n",m) ; /* First output */
}
void function2 (void)
{
int m = 100 ;
function1 ( ) ;
printf ("%d\n",m) ; /* Second output */
}
Output: 10
100
1000
There are two consequences of the scope and longevity of auto variables worth remembering. First, any variable local to main will be normally alive throughout the whole program, although it is active only in main. Secondly, during recursion, the nested variables are unique auto variables, a situation similar to function-nested auto variables with identical names.
Sorting of array element using a function
Program 43) Write a program that uses a function to sort an array of integers.
A program to sort an array of integers using the function sort( ). Its output clearly shows that a function can change the values in an array passed as an argument.
PROGRAM
void sort (int m, int x[ ]) ;
main ( )
{
int i ;
int marks [5] = {40, 90, 73, 81, 35} ;
printf ("Marks before sorting\n") ;
for (i = 0; i < 5; i++)
printf ("%d", marks [i]) ;
printf ("\n\n") ;
sort (5, marks) ;
printf ("Marks after sorting \n") ;
for (i = 0; i < 5; i++)
printf ("%4d", marks [i]) ;
printf ("\n") ;
}
void sort (intm, int x[ ])
{
int i, j, t ;
for (i = 1; i<= m - 1; i++)
for (j = 1; j<= m - i; j++)
if (x [j - 1] >= x [j])
{
t = x [j - 1] ;
x [j - 1] = x [j] ;
x [j] = t ;
}
}
Output: Marks before sorting
40 90 73 81 35
Marks after sorting
35 40 73 81 90
A program to sort an array of integers using the function sort( ). Its output clearly shows that a function can change the values in an array passed as an argument.
PROGRAM
void sort (int m, int x[ ]) ;
main ( )
{
int i ;
int marks [5] = {40, 90, 73, 81, 35} ;
printf ("Marks before sorting\n") ;
for (i = 0; i < 5; i++)
printf ("%d", marks [i]) ;
printf ("\n\n") ;
sort (5, marks) ;
printf ("Marks after sorting \n") ;
for (i = 0; i < 5; i++)
printf ("%4d", marks [i]) ;
printf ("\n") ;
}
void sort (intm, int x[ ])
{
int i, j, t ;
for (i = 1; i<= m - 1; i++)
for (j = 1; j<= m - i; j++)
if (x [j - 1] >= x [j])
{
t = x [j - 1] ;
x [j - 1] = x [j] ;
x [j] = t ;
}
}
Output: Marks before sorting
40 90 73 81 35
Marks after sorting
35 40 73 81 90
Subscribe to:
Comments (Atom)