Easy Understanding of Structure Union Typedef Enum in C Language.pdf

STRUCTURES, UNIONS, ENUMERATIONS AND TYPEDEF
Structure Definition
A structure is a collection of one or more data items of different data types, grouped together
sharing a common name.
Structure is a user-defined data type which holds or store heterogeneous/different types of data
items or elements in a single variable. It is a Combination of primitive (int, char,float) and
derived data type(array,pointer).
Variables inside the structure are called members of structure.
Each element of a structure is called a member.
struct keyword is used to define/create a structure.
struct define a new data type which is a collection of different type of data.
Syntax
struct structure_name /tag name
{
data_type member1;
data_type member2;
.
.
data_type member n;
};
Note: Don't forget the semicolon }; in the ending line.
Example

struct employee
{ int id;
char name[50];
float salary;
};
Here, struct is the keyword, employee is the tag name of structure; id, name and salary
are the members or fields of the structure. Let's understand it by the diagram given
below:
Syntax to create structure variable
struct tagname variable;
Declaring structure variable
We can declare variable for the structure, so that we can access the members of the structure
easily. There are two ways to declare structure variable:
1. By struct keyword within main() function/ Declaring Structure variables separately
2. By declaring variable at the time of defining structure/ Declaring Structure Variables
within Structure definition

1st way:
Let's see the example to declare structure variable by struct keyword. It should be declared
within the main function.
struct employee
{
int id;
char name[50];
float salary;
};
Now write given code inside the main() function.
struct employee e1, e2;
2nd way:
Let's see another way to declare variable at the time of defining structure.
struct employee
{ int id;
char name[50];
float salary;
}e1,e2;
Which approach is good
If number of variables sre not fixed, use 1st approach. It provides you flexibility to declare the
structure variable many times.
If number of variables are fixed, use 2nd approach. It saves your code to declare variable in
main() function.

Structure Initialization
structure variable can also be initialized at compile time.
struct Patient
{
float height;
int weight;
int age;
};
struct Patient p1 = { 180.75 , 73, 23 }; //initialization
or
//initialization of each member separately
struct patient p1;
p1.height = 180.75;
p1.weight = 73;
p1.age = 23;
Accessing Structures/ Accessing members of structure
There are two ways to access structure members:
1. By . (member or dot operator)
2. By -> (structure pointer operator)
When the variable is normal type then go for struct to member operator.
When the variable is pointer type then go for pointer to member operator.

Any member of a structure can be accessed as:
structure_variable_name.member_name
Example
struct book
{
char name[20];
char author[20];
int pages;
};
struct book b1;
for accessing the structure members from the above
example
b1.name, b1.author, b1.pages:
Example :
struct emp
{
int id;
char name[36];
int sal;
};
sizeof(struct emp) // --> 40 byte (2byte+36byte+2byte)
Example of Structure in C :
#include<stdio.h>
struct emp
{

int id;
char name[36];
float sal;
};
void main()
{
struct emp e;
printf("Enter employee Id, Name, Salary: ");
scanf("%d",&e.id);
scanf("%s",&e.name);
scanf("%f",&e.sal);
printf("Id: %d",e.id);
printf("nName: %s",e.name);
printf("nSalary: %f",e.sal);
}
Output
Output: Enter employee Id, Name, Salary: 5 Spidy 45000
Id : 05
Name: Spidy
Salary: 45000.00
Example
#include <stdio.h>
#include <string.h>
struct employee

{
int id;
char name[50];
}e1; //declaring e1 variable for structure
int main( )
{
//store first employee information
e1.id=101;
strcpy(e1.name, "Sonoo Jaiswal");//copying string into char array
//printing first employee information
printf( "employee 1 id : %dn", e1.id);
printf( "employee 1 name : %sn", e1.name);
}
Output:
employee 1 id : 101 employee 1
name : Sonoo Jaiswal
Difference Between Array and Structure
1 Array is collection of homogeneous data.
Structure is the collection of
heterogeneous data.
2 Array data are accessed using index.
Structure elements are accessed using .
Operator(dot operator).
3 Array allocates static memory. Structures allocates dynamic memory.
4
Array element access takes less time than
structures.
Structure elements takes more time than
Array.

Nested Structures
structure can have another structure as a member. There are two ways to define nested structure
in C language:
1. By separate structure
2. By Embedded structure
1) Separate structure
We can create 2 structures, but dependent structure should be used inside the main structure as a
member. Let's see the code of nested structure.
struct Date
{
int dd;
int mm;
int yyyy;
};
struct Employee
{
int id;
char name[20];
struct Date doj;
}emp1;
2) Embedded structure
struct Employee
{
int id;

char name[20];
struct Date
{
int dd;
int mm;
int yyyy;
}doj;
}emp1;
Accessing Nested Structure
We can access the member of nested structure by Outer_Structure.Nested_Structure.member as
given below:
e1.doj.dd
e1.doj.mm
e1.doj.yyyy
Arrays of Structures
Array of structures is used to store collection of information of different data types. Each element
of the array represents a structure variable. The array of structures is also known as collection of
structures.
Ex : if you want to handle more records within one structure, we need not specify the number of
structure variable. Simply we can use array of structure variable to store them in one structure
variable.
Example : struct employee emp[5];
Example of structure with array that stores information of 5 students and prints it.
#include<stdio.h>
#include<string.h>
struct student

{
int rollno;
char name[10];
};
void main()
{
int i;
struct student st[5];
printf("Enter Records of 5 students");
for(i=0;i<5;i++)
{
printf("nEnter Rollno:");
scanf("%d",&st[i].rollno);
printf("nEnter Name:");
scanf("%s",&st[i].name);
}
printf("nStudent Information List:");
for(i=0;i<5;i++)
{
printf("nRollno:%d,Name:%s",st[i].rollno,st[i].name);
}
}
Output:
Enter Records of 5 students
Enter Rollno:1

Enter Name:Sonoo
Enter Rollno:2
Enter Name:Ratan
Enter Rollno:3
Enter Name:Vimal
Enter Rollno:4
Enter Name:James
Enter Rollno:5
Enter Name:Sarfraz
Student Information List:
Rollno:1, Name:Sonoo
Rollno:2, Name:Ratan
Rollno:3, Name:Vimal
Rollno:4, Name:James
Rollno:5, Name:Sarfraz
Structures and Functions
A structure can be passed as a function argument just like any other variable. This raises a few
practical issues.
PASSING STRUCTURE TO FUNCTION IN C:
It can be done in below 3 ways.
1. Passing structure to a function by value
2. Passing structure to a function by address(reference)
3. No need to pass a structure – Declare structure variable as global
.

The general format of sending a copy of a structure to the called function is:
Function_name(structure_variable_name);
The called function takes the following form:
data_type function_name(struct tag_name var)
{
----------
----------
return(exp);
}
PASSING STRUCTURE TO FUNCTION IN C BY VALUE:
#include <stdio.h>
#include <string.h>
struct student
{
int id;
char name[20];
float percentage;
};
void fun(struct student record);
int main()
{

struct student record;
record.id=1;
strcpy(record.name, "Raju");
record.percentage = 86.5;
func(record);
}
void fun(struct student record)
{
printf(" Id is: %d n", record.id);
printf(" Name is: %s n", record.name);
printf(" Percentage is: %f n", record.percentage);
}
Output
Id is: 1
Name is: Raju
Percentage is: 86.500000
PASSING STRUCTURE TO FUNCTION IN C BY ADDRESS:
#include <stdio.h>
#include <string.h>
struct student
{
int id;

char name[20];
float percentage;
};
void func(struct student *record);
int main()
{
record.id=1;
strcpy(record.name, "Raju");
record.percentage = 86.5;
func(&record);
}
void func(struct student *record)
{
printf(" Id is: %d n", record->id);
printf(" Name is: %s n", record->name);
printf(" Percentage is: %f n", record->percentage);
}
EXAMPLE PROGRAM TO DECLARE A STRUCTURE VARIABLE AS GLOBAL IN C:
#include <stdio.h>
#include <string.h>
struct student
{

int id;
char name[20];
float percentage;
};
// Global declaration of structure
void structure_demo();
int main()
{
record.id=1;
strcpy(record.name,"Raju");
record.percentage= 86.5;
structure_demo();
}
void structure_demo()
{
printf(" Id is: %d n", record.id);
printf(" Name is: %s n", record.name);
printf(" Percentage is: %f n", record.percentage);
}
Passing a copy of entire structure to a function
struct std
{

int no;
float avg;
};
struct std a;
void fun(struct std p);
void main()
{
a.no=12;
a.avg=13.76;
fun(a);
}
void fun(struct std p)
{
printf("number is%dn",p.no);
printf("averageis%fn",p.avg);
}
Passing Structures through Pointers
Example
#include <stdio.h>
#include <string.h>

struct student
{
int id;
char name[30];
float percentage;
};
int main()
{
int i;
struct student record1 = {1, "Raju", 90.5};
struct student *ptr;
ptr = &record1;
printf("Records of STUDENT1: n");
printf(" Id is: %d n", ptr->id);
printf(" Name is: %s n", ptr->name);
printf(" Percentage is: %f nn", ptr->percentage);
}
OUTPUT:
Records of STUDENT1:
Id is: 1
Name is: Raju
Percentage is: 90.500000
Self‐referential Structures
A structure consisting of at least one pointer member pointing to the same structure is known as
a self-referential structure. A self referential structure is used to create data structures like linked
lists, stacks, etc. Following is an example of this kind of structure:

A self-referential structure is one of the data structures which refer to the pointer to (points to)
another structure of the same type. For example, a linked list is supposed to be a self-referential
data structure. The next node of a node is being pointed, which is of the same struct type. For
example,
Syntax : struct tag_name
{
type member1;
type membere2;
: :
: :
typeN memberN;
struct tag_name *name;
}
Where *name refers to the name of a pointer variable.
Ex:
struct emp
{
int code;
struct emp *name;
}
Unions
A union is a special data type available in C that allows to store different data types in the same
memory location.

Unions are conceptually similar to structures. The syntax of union is also similar to that of
structure. The only difference is in terms of storage. In structure each member has its own storage
location, whereas all members of union use a single shared memory location which is equal to
the size of its largest data member.
We can access only one member of union at a time. We can‟t access all member values at the
same time in union. But, structure can access all member values at the same time. This is because,
Union allocates one common storage space for all its members. Where as Structure allocates
storage space for all its members separately.

syntax of union
union_name
{
data_type member1;
data_type member2;
.
.
data_type memeberN;
};
Example
union employee
{ int id;
char name[50];
float salary;
};

Example
#include<stdio.h>
#include<string.h>
union employee
{
int id;
char name[50];
}e1; //declaring e1 variable for union
int main( )
{
//store first employee information
e1.id=101;
strcpy(e1.name, "Sonoo Jaiswal");//copying string into char array
//printing first employee information
printf( "employee 1 id : %dn", e1.id);
printf( "employee 1 name : %sn", e1.name);
}
Output:
employee 1 id:1869508435
employee 1 name : Sonoo Jaiswal
As you can see, id gets garbage value because name has large memory size. So only name will
have actual value.

Example
#include <stdio.h>
union item
{
int a;
float b;
char ch;
};
int main( )
{
union item it;
it.a = 12;
it.b = 20.2;
it.ch='z';
printf("%dn",it.a);
printf("%fn",it.b);
printf("%cn",it.ch);
}
Output
-26426
67.1999
z
As you can see here, the values of a and b get corrupted and only variable c prints the expected
result. Because in union, the only member whose value is latest currently stored only that value
will have the memory access.

We can print all the values successfully by updating the above program in the following
manner:
#include <stdio.h>
union item
{
int a;
float b;
char ch;
};
int main( )
{
union item it;
it.a = 12;
printf("%dn",it.a);
it.b = 20.2;
printf("%fn",it.b);
it.ch='z';
printf("%cn",it.ch);
}
Output
12
20.2
z
Now all the values are printed correctly because once memory is allocated for it.a variable,
perform entire work with that value(like printing its value in the above program) so that the

same memory location can be utilized by the other members of the union more meaningfully
like it.b and it.ch.
Difference between Structure and Union
Structure Union
1 For defining structure use
struct keyword.
For defining union we use union keyword
2 Structure occupies more
memory space than union.
Union occupies less memory space than Structure.
3 In Structure we can access
all members of structure at a
time.
In union we can access only one member of union at a time.
4 Structure allocates separate
storage space for its every
members.
Union allocates one common storage space for its all
members. Union find which member need more memory than
other member, then it allocate that much space
Bit‐Fields
Syntax
struct {
type [member_name] : width ;
};
The following table describes the variable elements of a bit field −

Elements Description
type An integer type that determines how a bit-field's value is interpreted. The
type may be int, signed int, or unsigned int.
member_name The name of the bit-field.
width The number of bits in the bit-field. The width must be less than or equal
to the bit width of the specified type.
The variables defined with a predefined width are called bit fields. A bit field can hold more than
a single bit; for example, if you need a variable to store a value from 0 to 7, then you can define
a bit field with a width of 3 bits as follows –
struct
{
unsigned int age : 3;
} Age;
The above structure definition instructs the C compiler that the age variable is going to use only
3 bits to store the value. If you try to use more than 3 bits, then it will not allow you to do so. Let
us try the following example –
#include <stdio.h>
#include <string.h>
struct {
unsigned int age : 3;
} Age;
int main( )
{

Age.age = 4;
printf( "Sizeof( Age ) : %dn", sizeof(Age) );
printf( "Age.age : %dn", Age.age );
Age.age = 7;
Age.age = 8;
}
Output
Sizeof( Age ) : 4
Age.age : 4
Age.age : 7
Age.age : 0
Typedef :
The typedef is a keyword that allows the programmer to create a new data type name for an
existing data type. So, the purpose of typedef is to redefine the name of an existing variable type.
Syntax
typedef datatype alias_name;
Example of typedef
#include<stdio.h>
typedef int Intdata; // Intdata is alias name of int
void main()
{
int a=10;
Integerdata b=20;

typedef Intdata Integerdata; // Integerdata is again alias name of
Intdata Integerdata s;
s=a+b;
printf("n Sum:=%d",s);
}
Output
Sum: 30
Advantages of Typedef :
1 : Provides a meaningful way of declaring the variable.
2 : Increase the readability of the program.
#include<stdio.>
void main() {
typedef int digits;
digits a,b,sum;
printf("Enter a and b values:");
scanf("%d%d",&a,&b);
sum=a+b;
printf("The sum is:%d",sum);
}

Note: By using typedef only we can create the alias name and it is under control of compiler.
Application of Typedef
Typedef can be used to give a name to user defined data type as well. Let’s see its use with
structures.
typedef struct
{
type member1;
type member2;
type member3;
} type_name ;

Here type_name represents the stucture definition associated with it. Now this type_name can
be used to declare a variable of this stucture type. type_name t1, t2 ;
Example of structure definition using typedef
#include<stdio.h>
#include<string.h>
typedef struct employee
{
char
name[50];
int salary;
} emp ;
void main( )
{
emp e1;
printf("nEnter Employee recordn");
printf("nEmployee namet");
scanf("%s",e1.name);
printf("nEnter Employee salary t");
scanf("%d",&e1.salary);
printf("nstudent name is %s",e1.name);
printf("nroll is %d",e1.salary);
}
typedef and Pointers
typedef can be used to give an alias name to pointers also. Here we have a case in which use of
typedef is beneficial during pointer declaration.

In Pointers * binds to the right and not the left.
int* x, y ;
By this declaration statement, we are actually declaring x as a pointer of type int, whereas y will
be declared as a plain integer.
typedef int* IntPtr ;
IntPtr x, y, z;
But if we use typedef like in above example, we can declare any number of pointers in a single
statement.
NOTE : If you do not have any prior knowledge of pointers, do study Pointers first.
Enumerations
An enum is a keyword, it is an user defined data type. All properties of integer are applied on
Enumeration data type so size of the enumerator data type is 2 byte. It works like Integer.
It is used for creating an user defined data type of integer. Using enum we can create sequence
of integer constant value.
Syntax :
enum tagname {value1, value2, value3,....};
• In above syntax enum is a keyword. It is a user defiend data type.
• In above syntax tagname is our own variable. tagname is any variable name.
• value1, value2, value3,.... are create set of enum values.

It’s value starts with 0 (zero) by default and value is incremented by 1 for the sequential identifiers
in the list. If constant one value is not initialized then by default sequence will be start from zero
and next to generated value should be previous constant value one.
Example of Enumeration in C
#include<stdio.h>
enum ABC {x,y,z};
void main()
{
int a;
a=x+y+z; //0+1+2
printf("Sum: %d",a);
}
Output
Sum: 3
#include<stdio.h>
enum week {sun, mon, tue, wed, thu, fri, sat};
void main()
{

enum week today;
today=tue;
printf("%d day",today+1);
}
Output
3 day
#include<stdio.h>
enum week {sun, mon, tue, wed, thu, fri, sat};
void main()
{
for(i=sun; i<=sat; i++)
{
printf("%d ",i);
}
}
Output
In above code replace sun, mon, tue,.... with Equivalent numeric value 0, 1, 2,...respectively.

Easy Understanding of Structure Union Typedef Enum in C Language.pdf

More Related Content

What's hot (20)

Similar to Easy Understanding of Structure Union Typedef Enum in C Language.pdf (20)

More from sudhakargeruganti (20)

Recently uploaded (20)

Easy Understanding of Structure Union Typedef Enum in C Language.pdf