1. Structures Department of Computer Engineering
Vishwakarma Institute of Technology, Pune

2. INDEX Structures: Introduction Declaration and Initialization
Structure variables
Accessing Values of the Structure Field
“Size of" operator.
Arrays of structures
Passing and Returning Structure from function.

3. Structures : Introduction
Structure is a Derived Data Type.
A structure is a collection of one or more variables of same or different types, grouped together under a single name.
Structures are for convenient handling of Data Variables.
Structures help to organize complicated data, particularly in large programs
Structures permit a group of related variables to be treated as a unit instead of as separate entities.

4. Declaring a Structure
struct sname { type var1; type var2; type var3; . type varN; };
struct is a keyword to define a structure.
sname is the name given to the structure data type.
type is a built-in data type.
var1,var2,var3,…..,varN are elements of structure being defined.
Structure template
sname is called tag makes it possible to declare other variable of the same structure type without having to rewrite the template itself. It’s a type name.tag is optional.

5. Structure : An Employee
struct employee_type {
char code;
char name[10];
int dept_code;
float salary; };
Here, No variable has been associated with this structure
No memory is set aside for this structure.

6. Declaring Variables of the Structure Type
Declares a variable employee of type employee_type
At this point, the memory is set aside for the structure variable employee.
We can also declare variable(s) of structure type along with the structure declaration.
struct employee_type employee1;
struct employee_type
{ char code;
char name[10];
int dept_code;
float salary;
}employee1;

7. How the elements of the structure variables are stored in memory
1197
1198
1199 .
1208
1209
1210
1211
1212
1213
1214
Code
Name
Dept_code
Salary

8. Initializing Structures
struct employee_type
{ char code;
char name[10];
int dept_code;
float salary; };
struct employee_type emp1={ ‘A’,”Krishna”,18, };

9. Accessing Structure Elements
Elements are accessed using dot operator.
It provides a powerful and clear way to refer to an individual element.
Syntax: sname.vname
sname is structure variable name.
vname is name of the element of the structure.
Eg: the element of the structure variable employee can be accessed as
emp1.code
emp1.name
emp1.dept_code
emp1.salary

10. Size of operator
The sizeof( ) operator gives the size of the variable in bytes.
void main(){
int a; char b; float d; int ab[10];
clrscr();
printf("%d %d %d %d ",sizeof(a), sizeof(b),
sizeof(d), sizeof(ab));
getch(); }
Output :

11. WAP to display size of structure elements.Use sizeof() of operator.
struct book1 { char book[30]; int pages; float price; }; main() struct book1 bk1; clrscr(); printf(“\nSize of Structure elements\n”); printf(“\nBook: %d”,sizeof(bk1.book)); printf(“\nPages: %d”,sizeof(bk1.pages)); printf(“\nBook:%d”,sizeof(bk1.price)); printf(“\nBook:%d”,sizeof(bk1)); }
Output
Book : 30
Pages:2
Price:4
Total Bytes:36

12. Entering Data into Structures
struct employee_type { int code; char name[25]; char dept[15]; float salary; }; main() struct employee_type emp; printf(“\nEnter employee code:\n”); scanf(“%d”,&emp.code); printf(“\nEnter name:\n”); gets(employee.name); printf(“\nEnter employee’s dept:\n”); gets(employee.dept); printf(“\nEnter employee’s salary:\n”); scanf(“%f”,&employee.salary);
printf(“\n\nParticulars of emp as entered by user\n”);
printf(“\nEmployees code:%d”,employee.code);
printf(“\nEmployee’s name:%s”, employee.name);
printf(“\nEmployee’s dept:%s”,employee.dept);
Printf(“\nEmployee’s sal:%f”,employee.salary);

13. Use of Assignment Statement for Structures
Value of one structure variable can be assigned to another variable of the same type using simple assignment statement.if student1 and student2 are structure variable of type student_type,then
student2=student1;
Assigns value of structure variable student1 to student2
Simple assignment cannot be used this way for arrays.

14. WAP to copy structure elements from one object to another object
void main() { struct disk char co[15]; float type; int price; }; struct disk d1={“SONY”,1.44,20}; struct disk d2,d3; strcpy(d2.co,d1.co); individual elements of d1 object are copied using d2.type=d1.type; assignment statement d2.price=d1.price; d3=d2; // all the contents are copied to d3 clrscr(); continue
continue
printf(“\n %s %g %d”,d1.co,d1.type,d1.price);
printf(“\n %s %g %d”,d2.co,d2.type,d2.price);
printf(“\n %s % %d”,d3.co,d3.type,d3.price); }

15. Pointers and Structures
struct student_type student,*ptr
It declares a structures variable student and a pointer variable ptr to structure of type student_type. ptr can be initialized with the following assignment statement
ptr=&student;
HOW WE CAN ACCESS THE ELEMENTS OF STRUCTURE
Instead of Dot operator we use arrow operator.
ptr->rollno,ptr->name,ptr->age,ptr->height

16. Structure within Structure
We can take object of one structure as member in another structure.
Structure within structure can be used to create complex data applications.
struct time {
int second;
int minute;
int hour; };
struct date
int day;
int year;
int month;
struct time st;
}today;

17. main() {
struct time
int second;
int minute;
int hour; }
struct t
int carno;
struct time st;
struct time rt; };
struct t r1;
clrscr();
scanf(“%d”,&r1.carno);
scanf(“%d %d %d”,&r1.st.hour,&r1.st.minute,&r1.st.second);
scanf(“%d %d %d”,&r1.rt.hour,&r1.rt.minute,&r1.rt.second);
printf(“\n \tCArno \n\tStarting time \n\t Reaching time\n”);
printf(“\t%d\t”,r1.carno);
printf(“\t%d:%d:%d\t\t”,r1.st.hour,ri.st.minute,r1.st.second);
printf(“\t%d:%d:%d\t\t”,r1.rt.hour,ri.rt.minute,r1.rt.second);

18. Declaring an Array of Structures
struct employee_type { int code; char name[25]; char dept[15]; float salary; }; struct employee_type emp1; struct employee_type emp[50];

19. Accessing elements an array of structures
Individual elements of a structure in an array of structure are accessed by referring to
structure variable name.
Followed by dot operator.
Ending with structure element desired.
Suppose we want to access salary of 7th employee,we can do so by writing
employee[6].salary

20. WAP to create an array of structure objects
main() { int k; struct time int second; int minute; int hour; }; struct date int day; int year; int month; struct time st; struct date r1[3]; clrscr();

21. printf(“\n Car no Starting time Reaching time”); for(k=0;k<3;k++) { scanf(“%d %d %d”, &r1[k].st.hour,&r1[k].st.minute,&r1[k].st.second); } printf(“%d %d %d”,r1[k].st.hour,r1[k].st.minute,r1[k].st.second);

22. Structure and Function
The relationship of structure with the function can be viewed from three angles:-
Passing Structures to a function.
Function Returning Structure.
Passing array of Structures to Function.
Note:
When a structure element is to be passed to any other function,it is essential to declare the structure outside the main() functioni.e global

23. Passing Structure to a Function
Similar to passing array of variable,structure can be passed to a function as argument
Syntax:
type-specifier func-name(struct-variable); /*actual argument*/

24. Read and display student grade by using structure with function
struct student { int rn; char name[20]; char grade; }s; main() printf(“\nEnter rollno,name and grade of student:\n”); scanf(“%d %s %c”,&s.rn,s.name,&s.grade); display(s); getch(); }
Display(struct student m) {
printf(“\nRollno is %d”,m.rn);
printf(“\n Name is %s”,m.name);
printf(“\n Grade is: %c”,m.grade); }

25. Passing of structure variables by value to a function
struct date { int day; int month; int year; }; void print_date(struct date); void main() struct date d={10,12,1997}; print_date(d); } void print_date(struct date a) printf(“\nDate in format %d %d %d”,a.day,a.month,a.year);

26. Passing to the function by address
struct book { char name[35]; char author[35]; int pages; }b1; void main() show(&b1); }
show(struct book *b2) { }

27. Prog to pass address of structure variable to user defined function and display the contents
struct book { char name[35]; char author[35]; int pages; } void main() struct book b1={“JAVA COMPETE REFERENCE”,”P.NAUGHTON”,886}; show(&b1); show(struct book *b2) pointer to structure clrscr(); printf(“%s %s %d”,b2->name,b2->author,b2->pages);

28. Passing of structure variables by reference to a function
struct date { int day; int month; int year; }; main() struct date d; void get_date(struct date *); printf(“Enter date in the format:\n”); get_date(&d); printf(“\nDate entered by you %d %d %d”,d.day,d.month,d.year); } void get_date(struct date *a) { scanf(“%d %d %d”,&a->day,&a->month,a->year);

29. Wap to pass structure elements to function print() and print the elements
void main() { struct boy char name[25]; int age; int wt; }; struct boy b1={“Amit”,20,25}; print(b1.name,b1.age,b1.wt); } print(char *s,int t, int n) printf(“\n%s %d %d”,s,t,n); return 0;
Note:
We have passed base address of name
But values of age and wt.
Here values are passed using call by reference and call by value

30. Function Returning Structure
struct date { int day; int month; int year; }; main() struct date d; struct date get_date(void); printf(“\nEnter date in format day/month/year”); d=get_date(); printf(“\nDAte entered by you is %d %d %d\n”,d.day,d.month,d.year); }
struct date get_date(void) {
struct date a;
scanf(“%d %d %d”,&a.day,&a.month,&a.year);
return a; }

31. Union
Union:
Union is similar as structure. The major distinction between them in terms of storage.
In structure each member has its own storage location whereas all the members of union uses the same location.
The union may contain many members of different data type it can handle only one member at a time union can be declared using the keyword union.
Hold only one object at a time
Union requires bytes that are equal to the number of bytes required for the largest members.
Eg: union contains char,int &long then the number of bytes reserved in the member for the union is 4 bytes.

32. 2. Each member have their own memory space
Structure
Union
 Structure allocates the memory equal to the total memory required by the members.
Union allocates the memory equal to the maximum memory required by the member of the union
2. Each member have their own memory space
2. One block is used by all the member of the union
3. All the members of the structure can be accessed at once
3. Where as in an union only one member can be used at a time.
Another important difference is in the size allocated to a structure and an union.
struct example
{ int integer;
float floating_numbers; }
the size allocated here is
sizeof(int)+sizeof(float);
The size in bytes is the sum total of size of all the elements in the structure, plus padding bytes.
union example
{ int integer;
float floating_numbers; }
size allocated is the size of the highest member.
so size is=sizeof(float);
Size of in bytes of the union is size of the
largest variable element in the union.

33. Union item {
int m;
float x;
char c;
} code;
This declare a variable code of type union item.

34. output
main() { union result int marks; char grade; }; struct res char name[15]; int age; union result perf; }data; printf(“Size of union:%d”,sizeof(data.perf)); printf(“Size of structure:%d”,sizeof(data)); }
Output:
Size of union: 2
Size of structure: 19

35. main() { int m,n,p,q,a[5][5],b[5][5],c[5][5],I,j,k; printf(“\nEnter the valur row and columns:\n”); scanf(“%d %d”,&m,&n); scanf(“%d %d”,&p,&q); if(n==p) printf(“\nEnter 1st matrix:\n”); for(i=0;i<=m-1;i++) for(j=0;j<=n-1;j+) scanf(“%d”,&a[i][j]); } for(i=0;i<=p-1;i++) for(j=0;j<=q-1;j+) for(j=0;j<=q-1;j++) {c[i][j]=0; for(k=0;k<=n-1;k++) c[i][j]=c[i][j]+a[i][k]*b[k][j];