Union in C

Definition
• union can be defined as a user-defined data type which is a collection of different
variables of different data types in the same memory location. The union can also
be defined as many members, but only one member can contain a value at a
particular point in time.
• union is a user-defined data type, but unlike structures, they share the same
memory location.
• Syntax:
keyword union unionName {
data_type Variablename;
data_type Variablename; members of union.
};
Declaring and Accessing variables

• We can declare a variable for the union so that we can access the member of
the union easily. There are two ways to declare union variable:

1.By union keyword within main() function.

2.By declaring a variable at the time of defining the union.

By union keyword within function.
• We can declare variables in main function. Let us discuss with an example.

union stud { union unionname{

int rollno; data_type member1;
char name[20]; data_type member2;
float marks; .
}; data_type member n;
int main() { };
union stud s1; mani function() {
union unionname
variable1,2..;
} }
By declaring a variable at the time of defining structure
• Declaring a variable at the time of defining a structure. It is easy and
simple.
• Syntax:
union union_name { ex: union student{
data_type element; int rno;
data_type element; float marks;
. }s1,s2;
.
} union variable1,union variable2,..union variable n;
• Accessing union variable
There are two ways to access union members:
1.By . (member or dot operator).
2.By -> (union pointer operator).

By . Dot operator.
The dot operator is used only when you are working with a union variable directly
(not a pointer to a structure).
Syntax:
unionVariable.membername;
• Arrow operator.
The arrow operator (->) in C is used to access members of a structure
through a union to that union. It's a shorthand for dereferencing a
pointer and then accessing the union member.

syntax: unionvariable->membername;
Ex: ptr->id = value;
• Without arrow(->) operator
(*ptr).id = value;
Typedef in Union

union student{
int rno;
float marks;
char name[20];
};
If we want to declare a union variable to student we have to follow this
union student s1,s2;
But we can avoid this with the use of typedef.
Syntax: typedef union union_name alias_name;
i.e typedef union student stud;
Here student remained as stud. So we can declare variables as
stud s1,s2;
Array of Unions

An array of structures in C can be defined as the collection of multiple

union variables where each variable contains information about different
entities. The array of union in C are used to store information about
multiple entities of different data types. The array of unions is also
known as the collection of unions.
• Syntax:
union union_name svariable[size];
Ex:
#include<stdio.h>
#include <string.h>
union student{
int rollno;
char name[10];
};
int main(){
int i;
union 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);
}
return 0;
}
Nested union
• C provides us the feature of nesting one structure within another structure by using which, complex data types
are created.
• To store the address of the employee, we need to store the address of the employee into a separate structure
and nest the structure address into the structure employee.
Ex:
#include<stdio.h>
struct address
{
char city[20];
int pin;
char phone[14];
};
struct employee
{
char name[20];
struct address add;
};
Pointers of structures

• In C, pointers to unions are used to refer to the memory address of a

unions. This is especially useful when you want to pass unions to functions
efficiently, work with dynamic memory allocation, or manipulate large
unions without copying them.
Syntax for declaration:
• union unionName *pointerName;
Accessing variable:
When accessing union members via a pointer, you use the arrow operator (-
>).
The arrow operator is shorthand for dereferencing the pointer and then using
the dot operator.
Ex:
#include <stdio.h>
#include <stdlib.h>

// Defining a structure
union Student {
int id;
float marks;
};
int main() {
// Dynamically allocate memory for a structure
union Student *ptr = (union Student *)malloc(sizeof(union Student));
 // Assigning values using the pointer
ptr->id = 102;
ptr->marks = 92.5;
// Printing union members
printf("ID: %d\n", ptr->id);
printf("Marks: %.2f\n", ptr->marks);
// Freeing the allocated memory
free(ptr);
return 0;
}
Enumerations in C

• The enum in C is also known as the enumerated type. It is a user-defined data type
that consists of integer values, and it provides meaningful names to these values.
The use of enum in C makes the program easy to understand and maintain. The
enum is defined by using the enum keyword.
• enum variable consists a set of possible values.
• Syntax:
enum flag{integer_const1, integer_const2,.....integter_constN};
• Ex:
Enum fruits {mango,apple,guva,papaya};
In above example, compiler will assign values from 0 automatically. Or we can
assign values as for our needs.
Enumerated type declaration

• As we know that in C language, we need to declare the variable of a pre-defined

type such as int, float, char, etc. Similarly, we can declare the variable of a user-
defined data type, such as enum. Let's see how we can declare the variable of an
enum type.

• enum status{false,true};
• Why do we use enum
• The enum is used when we want our variable to have only a set of values. For
example, we create a direction variable. As we know that four directions exist
(North, South, East, West), so this direction variable will have four possible
values. But the variable can hold only one value at a time. If we try to provide
some different value to this variable, then it will throw the compilation error.
• The enum is also used in a switch case statement in which we pass the enum
variable in a switch parenthesis. It ensures that the value of the case block should
be defined in an enum.
#include <stdio.h>
enum days{sunday=1, monday, tuesday, wednesday, thursday, friday, saturday};
int main()
{
enum days d;
d=monday;
switch(d)
{
case sunday:
printf("Today is sunday");
break;
case monday:
printf("Today is monday");
break;
case tuesday:
printf("Today is tuesday");
break;
 case wednesday:
printf("Today is wednesday");
break;
case thursday:
printf("Today is thursday");
break;
case friday:
printf("Today is friday");
break;
case saturday:
printf("Today is saturday");
break;
}

return 0;
}
Some Important points

• If we do not provide any value to the enum names, then the compiler will
automatically assign the default values to the enum names starting from 0.
• We can also provide the values to the enum name in any order, and the unassigned
names will get the default value as the previous one plus one.
• The values assigned to the enum names must be integral constant, i.e., it should
not be of other types such string, float, etc.
• All the enum names must be unique in their scope, i.e., if we define two enum
having same scope, then these two enums should have different enum names
otherwise compiler will throw an error.
Macro vs enum.

• Macro can also be used to define the name constants, but in case of an enum, all the name
constants can be grouped together in a single statement.
• For example.
# define pass 0;
# define success 1;
•
The above two statements can be written in a single statement by using the enum type.
enum status{pass, success};
• The enum type follows the scope rules while macro does not follow the scope rules.
• In Enum, if we do not assign the values to the enum names, then the compiler will
automatically assign the default value to the enum names. But, in the case of macro, the
values need to be explicitly assigned.
• The type of enum in C is an integer, but the type of macro can be of any type.
Bit-fields in C

• In C, we can specify the size (in bits) of the structure and union members. The
idea of bit-field is to use memory efficiently when we know that the value of a
field or group of fields will never exceed a limit or is within a small range. C Bit
fields are used when the storage of our program is limited.
• Need of Bit Fields in C

• Reduces memory consumption.

• To make our program more efficient and flexible.

• Easy to Implement.
Declaration

Bit-fields are variables that are defined using a predefined width or size.

Syntax:
struct
{
data_type member_name : width_of_bit-field;
};
• Where,

• data_type: It is an integer type that determines the bit-field value

which is to be interpreted. The type may be int, signed int, or
unsigned int.

• member_name: The member’s name is the name of the bit field.

• width_of_bit-field: The number of bits in the bit-field. The width

must be less than or equal to the bit width of the specified type.
• Applications of C Bit Fields
• If storage is limited, we can go for bit-field.

• When devices transmit status or information encoded into multiple bits

for this type of situation bit-field is most efficient.

• Encryption routines need to access the bits within a byte in that

situation bit-field is quite useful.
• Structure with Bit Field
• The below code defines a structure named date with a single member
month. The month member is declared as a bit field with 4 bits.

• struct date
• {
• // month has value between 0 and 15,
• // so 4 bits are sufficient for month variable.
• int month : 4;
• };
Ex;
// C program to demonstrate use of Bit-fields
#include <stdio.h>
// Space optimized representation of the date
struct date {
// d has value between 0 and 31, so 5 bits
// are sufficient
int d : 5;
// m has value between 0 and 15, so 4 bits
// are sufficient
int m : 4;
int y;
};
int main()
{
printf("Size of date is %lu bytes\n",
sizeof(struct date));
struct date dt = { 31, 12, 2014 };
printf("Date is %d/%d/%d", dt.d, dt.m, dt.y);
return 0;
}
Output
Size of date is 8 bytes here actual size is 12 bytes because we taken 3 int
values but it given 8 because of bit-field.
Date is -1/-4/2014 the values are in negative because of signed int.
Thank you