functions struct&union

FunctionsThere are two types of functions

Library functions

They are built in functions present in C

They cannot be modified

They are not written by us Example: Printf, scanf

User defined functions

While handling large calculations we can write the program as modules. Modules are smallest unit of program. The program is split into number of subprograms and each part can be independently coded and later they can be combined into single unit. They are known as subprograms or functions A function is a module or block of program code which deals with a particular task..

.Defn: A function is a self-contained block of code that performs a particular task

It save time & space

We can use top down approach

We can easily locate the problem

they make a block of code reusable

General Form:

1

Library (or) Built in function

User defined functions

Function type function-name (argument-list)

Argument declaration;

{

Local Variable declaration; Statements; … … Return (expression);}

Function body

Function header

Function type - represents data type of value returned by the function

Function-name valid C variable name

Arguments list – formal arguments separated by commas

Local variable – declaration of variable in statement body

Return – keyword to return to the function

Calling a Function:

A function can be called by simply using the function name in a statement.

#include<stdio.h>

#include<conio.h>

sum(int,int);//function declaration

void main(){

int x;x=mul(10,2); function calling statementprintf(“%d\n”,x)

}mul(int a,int b){ int x;X=a*b;return (x);}

Category of the functions:

2

Category1: Functions with no arguments and no return values

Category2: Functions with arguments and no return values

Category3:Functions with arguments and return values

Category4:Functions with no arguments and return values

Category5:Functions that return multiple values

Main program

Function 1 Function 2 Function 3 Function 4

Category 1:No Arguments and No Return Values

When a function has no arguments, it does not receive any data from the calling function

When it does not return a value, the calling function does not receive any data from the called function

No Input

No Output

/* Sample Program */#include<stdio.h>

#include<conio.h>

value();

Void main( ){value();

}/* value function*/value( ){

int n,p; float r, sum;printf(“Enter the Amount\n”);scanf(“%d”,&p);printf(“Enter Number of Years\n”);scanf(“%d”,&n);printf(“Enter interest rate\n”);scanf(“%f”,&r);sum=(p*n*r)/100;printf(“Result is %f”,n,sum);

}

Category 2 : Functions with Arguments but No Return Value

When a function has arguments, it receives data from the calling function

When it does not return a value, the calling function does not receive any data from the called function

3

function1(){………function2()……}

function2(){………}

Output:

Enter the Amount 1000

Enter Number of Years 5

Enter interest rate 0.1

Result is 5

Values of

Argument

No Output


#include<conio.h>

value(int,int,float);main( ){

int n,p; float r;printf(“Enter the Amount\n”);scanf(“%d”,&p);printf(“Enter Number of Years\n”);scanf(“%d”,&n);printf(“Enter interest rate\n”);scanf(“%f”,&r); value(p,n,r);

}value(int p,int n,float r){

float sum;sum=(p*n*r)/100;printf(“Result is %f”,sum);

}

Category 3 : Function with Arguments and Return Value


When it has return a value, the calling function receive result from the called

function

Values of

Argument

Result

4

function1(){………function2(arg)……}

function2(arg){………}


function2(arg){………return(e)}

Output:




Result is 5


#include<conio.h>

value(int,int,float);main( ){

int n,p; float r, sum;printf(“Enter the Amount\n”);scanf(“%d”,&p);printf(“Enter Number of Years\n”);scanf(“%d”,&n);printf(“Enter interest rate\n”);scanf(“%f”,&r);sum=value(p,n,r);printf(“Result is %f”,sum);

}value(int p,int n,float r){

float sum1;sum1=(p*n*r)/100;return(sum1);

}Category4:Functions with no arguments and return values

When a function has no arguments.

When it has return a value, the calling function receive result from the called

function.

No input

result


#include<conio.h>

value();

5

Output:




Result is 5

function1(){………function2()……}

function2(){………return(e)}

main( ){

int m=value();printf(“m=%d”,m);}value(){

int number;printf(“Enter a number:);scanf(“%d”,&number)return(number);

}

Category5:Functions that return multiple values


When it has return multiple values, the calling function receive result from the

called function.

Value of

arguement

result

multiple values


#include<conio.h>

value(int x,int y,int *s,int *d);main( ){

int x=20,y=10,s,d;value(int x,int y,int *s,int *d);

6

Output:

Enter a number:10

m=10


function2(arg){………}

Output:

The result s=30

d=10

printf(“The result s =%d\n d=%d\n”,s,d));}value(int x,int y,int *sum,int *diff){

*sum=a+b;*diff= a-b;

}Ref:pg:286(nesting of functions)

Recursion

When a function calls itself it is called recursion.

“ Calling itself is called recursion ”

Ex 1:

main(){printf(“welcome”);main();)

Explanation: main() function is recursively called here.

Ex 2:

#include<stdio.>#include<conio.h>factorial(int);void main( ){

int f;f=factorial(5);printf(“factorial of 5 is %d\n”,f);

}factorial(int n){

int fact;if(n==1)

7

return(1);else

fact=n*factorial(n-1)return(fact);}

Explanation: Factorial value is calculated for 5 as follows

PASSING ARRAYS TO FUNCTIONS

In C programming, a single array element or an entire array can be passed to a function. Also, both one-dimensional and multi-dimensional array can be passed to function as argument.

Passing One-dimensional Array In FunctionC program to pass a single element of an array to function

#include <stdio.h>

void display(int a)

{

8

printf("%d",a);

}

int main(){

int c[]={2,3,4};

display(c[2]); //Passing array element c[2] only.

return 0;

}

Output

4

Single element of an array can be passed in similar manner as passing variable to a function.

Passing entire one-dimensional array to a functionWhile passing arrays to the argument, the name of the array is passed as an argument(,i.e, starting address of memory area is passed as argument).

Write a C program to pass an array containing age of person to a function. This function should find average age and display the average age in main function.

#include <stdio.h>

float average(float a[]);

int main(){

float avg, c[]={23.4, 55, 22.6, 3, 40.5, 18};

avg=average(c); /* Only name of array is passed as argument. */

printf("Average age=%.2f",avg);

return 0;

}

float average(float a[]){

int i;

float avg, sum=0.0;

for(i=0;i<6;++i){

9

sum+=a[i];

}

avg =(sum/6);

return avg;

}

Output

Average age=27.08

Passing Multi-dimensional Arrays to FunctionTo pass two-dimensional array to a function as an argument, starting address of memory area reserved is passed as in one dimensional array

Example to pass two-dimensional arrays to function

#include

void Function(int c[2][2]);

int main(){

int c[2][2],i,j;

printf("Enter 4 numbers:\n");

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

for(j=0;j<2;++j){

scanf("%d",&c[i][j]);

}

Function(c); /* passing multi-dimensional array to function */

return 0;

}

void Function(int c[2][2]){

/* Instead to above line, void Function(int c[][2]){ is also valid */

int i,j;

10

printf("Displaying:\n");

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

for(j=0;j<2;++j)

printf("%d\n",c[i][j]);

}

Output

Enter 4 numbers:

2

3

4

5

Displaying:

2

3

4

5

Passing strings to functions

The strings are treated as character arrays in c.Therefore the rules for Passing strings to functions are similar to Passing arrays to functions.#include <stdio.h>char* upper(char *word);int main(){ char word[100]; printf("Enter a string: "); gets(word);

11

printf("\nThe uppercase equivalent is: %s\n",upper(word)); return 0;}

char* upper(char *word){ int i; for (i=0;i<strlen(word);i++) word[i]=(word[i]>96&&word[i]<123)?word[i]-32:word[i]; return word;}

The Scope and lifetime of the variables in functions

A variable in C can have any one of the four storage classes

Automatic variables

External variables

Static variables

Register variables

Scope of the variable determines in which part of the program a variable is actually available for use (active).

Storage classes

Automatic Variables:

These variables are declared inside a function

These variables created when you enter into the function and destroyed when the function exited

Automatic variables are private to the function and also referred as local or internal variable

A variable declared inside a function without storage class , by default, an automatic variable.

Example: #include<stdio.h>

12

main( ){int number;…………}

main( ){auto int number;…………}

Both are equal

#include<conio.h>

fun1();

fun2();

void main( ){

int m=1000;fun2( );printf(“%d\n”m);

}fun1( ){

int m=10;printf(“%d\n”,m);

}fun2( ){

int m=100;fun1( );printf(“%d\n”,m);

}

External Variables:

Variables are both alive and active through out the program are known as external variables.

They are also known as global variables

External variables are declared outside a function.

Ex:

#include<stdio.h>

#include<conio.h>

fun1();

fun2();

fun3();

int x;void main( ){

x=10;printf(“x=%d\n”,x);printf(“x=%d\n”,fun1( ));printf(“x=%d\n”,fun2( ));printf(“x=%d\n”,fun3( ));

}

13

Output:

10

100

1000

Output

x=10

x=20

x=1

x=30

fun1( ){x=x+10;return(x);

}fun2( ){

int x;x=1;return(x);

}fun3( ){

x=x+10;return(x);

}

Static Variables:

The value of static variables persists until the end of the program

Using static keyword we declare static variables

Ex:

static int x;

static float y;

A static variables maybe either an internal or an external type, depending on the place of declaration

Internal static variables are similar to auto variables but the internal static variables can be used to retain values between function calls


#include<conio.h>

stat();

void main( ){int i;for(i=1;i<=3;i++)stat( );getch();}stat( ){static int x=0;x=x+1;printf(“x=%d\n”,x);

14

Output:

x=1

x=2

x=3

}

Register Variables:

Instead of keeping the value of the variables in memory, register variables

maintained in the registers. (Register access is faster than the memory).

Ex:

register int count;

StructureArrays 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 packing data of different types. A structure is a convenient method of handling a group of related data items of different data types.(A structure is a package of one or usually more variables which are grouped under a single name. Structures are not like arrays: a structure can hold any mixture of different types of data: it can even hold arrays of different types or Combine variables into a single package called a structure..)or it is collection of heterogeneous(different) types of data can be grouped to form structure. The entire collection can be referred to by structure name, the individual components which are called fields or members can be accessed and processed separately.

syntax

The word struct is a keyword .

The tag is the name that identifies structures of type and menber1,member2..

member n are individual member declaration.

An individual structure type variable can be declared as follows:

15

struct tag_name { data type member1; data type member2; … … data type member n;} ;

struct tag variable1, variable2,….,variable n;

The declaration of the structure composition with that of structure variables,

Example:

Structures are declared by using the struct keyword

struct samplename{ int a; char b;}

This structure is named sampleName.

It contains two variables: an integer named a and a character named b.

The above command only creates the structure. (it doesn't declare any variables.)

(structure)

(member)

(member)

The following line declares a structure variable named

s1.

struct sample s1;

Items within the structure are referred to by using dot notation.

printf("Character 1 is %s\n",g1.name);

EXAMPLE

Program1

16

samplename

a

b

struct tag_name { data type member1; data type member2; … … data type member n;}variable1, variable2,….,variable n;

#include <stdio.h>struct student{ char *name; float marks;} student1, student2; main ( ){ struct student student3; student1.name = "rose"; student2.marks = 99.9; printf (" Name is %s \n", student1.name); printf (" Marks are %f \n", student2.marks);}

Output Name is rose

Mark are 99.900002

Program2#include <stdio.h> main(){ struct{ int a; int b; } x, y; x.a = 10; y = x; /* assign one structure to another */ printf("%d", y.a);}Program3#include <stdio.h>struct stype{ int i; char ch; double d; char str[80];} s;main(){ printf("Enter an integer: "); scanf("%d:", &s.i); printf("Enter a character: "); scanf(" %c", &s.ch); printf("Enter a floating point number: "); scanf("%lf", &s.d); printf("Enter a string: "); scanf("%s", s.str); printf("%d %c %f %s", s.i, s.ch, s.d, s.str);}

Note: A structure is usually defines before main along with macro definitions. In such cases the structure assumes global status and all the functions can access the structure.

17

Initializing structure:

Like other data type we can initialize structure when we declare them. As for initialization goes structure obeys the same set of rules as arrays we initialize the fields of a structure by the following structure declaration with a list containing values for each fields as with arrays these values must be evaluate at compile time.

Example1(Consider the program 3):

struct stype st1{12345; ‘a’; 2.43; “KSR college”;};

this initializes the 12345 to i, ‘a’ to ch, 2.43 to d, and the string “KSR college” to str.

Example2:

#include<stdio.h>main(){

strut student{int rollno;float mark1,mark2,mark3;

};static struct student class={52,50.5,67.8,89.0};printf(“Rollno=%d\n”,class.rollno);printf(“Marks=%d\n%d\n%d”,class.mark1,class.mark2,class.mark3);

}

Declaring Structure Variables & Accessing Structure Members:

A field or member of structure is unique name if more than one structure is declared.

The same field or member name may be used with different data types.

Here each structure member will treated as a separate variable and reverse the memory space according to their data type member.

Example

#include<stdio.h>main(){

struct first{int a;float b;char c;

};struct second{

char a;int b;float c;

};

18

struct first f;struct second t;f.a=20;f.b=17.986;f.c=’z’;t.a=10;t.b=12.56;t.c=’g’;printf(“First Structure\n”);printf(“%d\n%f\n%c\n”, f.a,f.b,f.c);printf(“Second Structure\n”);printf(“%d\n%f\n%c\n”, t.a,t.b,t.c);

}Structures within Structures

Structures are said to nest. This means that structure templates can contain other structures as members. Consider two structure types: struct first_structure { int value; float number; };

and

struct second_structure {

int tag; struct first_structure fs;

} x;

These two structures are of different types, yet the first of the two is included in the second. An instance of the second structure would be initialized by the following assignments. The structure variable name is x:

x.tag = 10;

x.fs.value = 20;

x.fs.number = 30.0;

The way in which the member operator .(dot) can be used over and over again. No parentheses are necessary, because the reference which is calculated by this operator is worked out from left to right.(Ref:pg324:topic).

Array of structuresStructure is collection of different data type. An object of structure represents a single record in memory, if we want more than one record of structure type, we have to create an

19

array of structure or object. As we know, an array is a collection of similar type, therefore an array can be of structure type.

Syntax for declaring structure array

struct struct-name

{

datatype var1;

datatype var2;

- - - - - - - - - -

- - - - - - - - - -

datatype varN;

};

struct struct-name obj [ size ];

Example for declaring structure array

#include<stdio.h>

struct Employee

{

int Id;

char Name[25];

int Age;

long Salary;

};

void main()

{

int i;

struct Employee Emp[ 3 ]; //Statement 1

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

20

{

printf("\nEnter details of %d Employee",i+1);

printf("\n\tEnter Employee Id : ");

scanf("%d",&Emp[i].Id);

printf("\n\tEnter Employee Name : ");

scanf("%s",&Emp[i].Name);

printf("\n\tEnter Employee Age : ");

scanf("%d",&Emp[i].Age);

printf("\n\tEnter Employee Salary : ");

scanf("%ld",&Emp[i].Salary);

}

printf("\nDetails of Employees");

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

printf("\n%d\t%s\t%d\t%ld",Emp[i].Id,Emp[i].Name,Emp[i].Age,Emp[i].Salary);

}

Output :

Enter details of 1 Employee

Enter Employee Id : 101

Enter Employee Name : Suresh

Enter Employee Age : 29

Enter Employee Salary : 45000



21

Enter Employee Name : Mukesh





Enter Employee Name : Ramesh



Details of Employees

101 Suresh 29 45000

102 Mukesh 31 51000

103 Ramesh 28 47000

In the above example, we are getting and displaying the data of 3 employee using array of object. Statement 1 is creating an array of Employee Emp to store the records of 3 employees.

Arrays within structuresstructure is collection of different data type. Like normal data type, It can also store an array as well.

Syntax for array within structure

struct struct-name

{

datatype var1; // normal variable

datatype array [size]; // array variable

- - - - - - - - - -

- - - - - - - - - -

datatype varN;

};

22

struct struct-name obj;

Example for array within structure

struct Student

{

int Roll;

char Name[25];

int Marks[3]; //Statement 1 : array of marks

int Total;

float Avg;

};

void main()

{

int i;

struct Student S;

printf("\n\nEnter Student Roll : ");

scanf("%d",&S.Roll);

printf("\n\nEnter Student Name : ");

scanf("%s",&S.Name);

S.Total = 0;

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

{

printf("\n\nEnter Marks %d : ",i+1);

scanf("%d",&S.Marks[i]);

S.Total = S.Total + S.Marks[i];

}

23

S.Avg = S.Total / 3;

printf("\nRoll : %d",S.Roll);

printf("\nName : %s",S.Name);

printf("\nTotal : %d",S.Total);

printf("\nAverage : %f",S.Avg);

}

Output :

Enter Student Roll : 10

Enter Student Name : Kumar

Enter Marks 1 : 78

Enter Marks 2 : 89

Enter Marks 3 : 56

Roll : 10

Name : Kumar

Total : 223

Average : 74.00000

Structure and Function in CUsing function we can pass structure as function argument and we can also return structure from function.

Passing structure as function argumentStructure can be passed to function through its object therefore passing structure to function or passing structure object to function is same thing because structure object represents the structure. Like normal variable, structure variable(structure object) can be pass by value or by references / addresses.

Passing Structure by ValueIn this approach, the structure object is passed as function argument to the definition of function, here object is reperesenting the members of structure with their values.

Example for passing structure object by value

24

#include<stdio.h>

struct Employee

{

int Id;

char Name[25];

int Age;

long Salary;

};

void Display(struct Employee);

void main()

{

struct Employee Emp = {1,"Kumar",29,45000};

Display(Emp);

}

void Display(struct Employee E)

{

printf("\n\nEmployee Id : %d",E.Id);

printf("\nEmployee Name : %s",E.Name);

printf("\nEmployee Age : %d",E.Age);

printf("\nEmployee Salary : %ld",E.Salary);

}

Output :

Employee Id : 1

Employee Name : Kumar

Employee Age : 29

Employee Salary : 45000

25

Passing Structure by ReferenceIn this approach, the reference/address structure object is passed as function argument to the definition of function.

Example for passing structure object by reference

#include<stdio.h>

struct Employee

{

int Id;

char Name[25];

int Age;

long Salary;

};

void Display(struct Employee*);

void main()

{

struct Employee Emp = {1,"Kumar",29,45000};

Display(&Emp);

}

void Display(struct Employee *E)

{

printf("\n\nEmployee Id : %d",E->Id);

printf("\nEmployee Name : %s",E->Name);

printf("\nEmployee Age : %d",E->Age);

printf("\nEmployee Salary : %ld",E->Salary);

}

26

Output :

Employee Id : 1


Employee Age : 29


Function Returning StructureStructure is user-defined data type, like built-in data types structure can be return from function.

Example for passing structure object by reference

#include<stdio.h>

struct Employee

{

int Id;

char Name[25];

int Age;

long Salary;

};

Employee Input(); //Statement 1

void main()

{

struct Employee Emp;

Emp = Input();

printf("\n\nEmployee Id : %d",Emp.Id);

printf("\nEmployee Name : %s",Emp.Name);

27

printf("\nEmployee Age : %d",Emp.Age);

printf("\nEmployee Salary : %ld",Emp.Salary);

}

Employee Input()

{

struct Employee E;

printf("\nEnter Employee Id : ");

scanf("%d",&E.Id);

printf("\nEnter Employee Name : ");

scanf("%s",&E.Name);

printf("\nEnter Employee Age : ");

scanf("%d",&E.Age);

printf("\nEnter Employee Salary : ");

scanf("%ld",&E.Salary);

return E; //Statement 2

}

Output :


Enter Employee Name : Ajay



Employee Id : 10

Employee Name : Ajay

Employee Age : 25

28


In the above example, statement 1 is declaring Input() with return type Employee. As we know structure is user-defined data type and structure name acts as our new user-defined data type, therefore we use structure name as function return type.

Input() have local variable E of Employee type. After getting values from user statement 2 returns E to the calling function and display the values.

Union in CBoth structure and union are collection of different datatype. They are used to group number of variables of different type in a single unit.

Difference betweenw Structure and union.1. Declaration and Initialization of structure starts with struct keyword. Declaration and Initialization of union starts with union keyword.

2. Structure allocates different memory locations for all its members while union allocates common memory location for all its members. The memory occupied by a union will be large enough to hold the largest member of the union.

Union declarationDeclaration of union must start with the keyword union followed by the union name and union's member variables are declared within braces.

Syntax for declaring union

union union-name

{

datatype var1;

datatype var2;

- - - - - - - - - -

- - - - - - - - - -

datatype varN;

};

Accessing the union members

29

We have to create an object of union to access its members. Object is a variable of type union. Union members are accessed using the dot operator(.) between union's object and union's member name.

Syntax for creating object of union

union union-name obj;

Example for creating object & accessing union members

#include<stdio.h>

union Employee

{

int Id;

char Name[25];

int Age;

long Salary;

};

void main()

{

union Employee E;

printf("\nEnter Employee Id : ");

scanf("%d",&E.Id);

printf("Employee Id : %d",E.Id);

printf("\n\nEnter Employee Name : ");

scanf("%s",&E.Name);

printf("Employee Name : %s",E.Name);

printf("\n\nEnter Employee Age : ");

scanf("%d",&E.Age);

30

printf("Employee Age : %d",E.Age);

printf("\n\nEnter Employee Salary : ");

scanf("%ld",&E.Salary);

printf("Employee Salary : %ld",E.Salary);

}

Output :


Employee Id : 1

Enter Employee Name : Kumar



Employee Age : 29



Here, all the members are getting printed very well because one member is being used at a time.

Example of comparing size of union and structure

#include<stdio.h>

struct Employee1

{

int Id;

31

char Name[25];

long Salary;

};

union Employee2

{

int Id;

char Name[25];

long Salary;

};

void main()

{

printf("\nSize of Employee1 is : %d",sizeof(Employee1));

printf("\nSize of Employee2 is : %d",sizeof(Employee2));

}

Output :

Size of Employee1 is : 31

Size of Employee2 is : 25

32

Bit fields in CThere are times when the member variables of a structure represent some flags that store either 0 or 1. Here is an example :

struct info

{

int isMemoryFreed;

int isObjectAllocated;

}

If you observe, though a value of 0 or 1 would be stored in these variables but the memory used would be complete 8 bytes.

To reduce memory consumption when it is known that only some bits would be used for a variable, the concept of bit fields can be used.

Bit fields allow efficient packaging of data in the memory. Here is how bit fields are defined :

struct info

{

int isMemoryFreed : 1;

int isObjectAllocated : 1;

}

The above declaration tells the compiler that only 1 bit each from the two variables would be used. After seeing this, the compiler reduces the memory size of the structure.

33

functions struct&union

Education