Union

• Union is the collection of different data types
• If we want to use Union ,use of ‘union’ keyword is mandatory.
• Every declaration done inside a union is called member.
• A single memory location is shared among the members of the Union.
• The biggest in size among the members decides the size of the Union.

Defining a union

To define a Union, ‘union’ keyword is used. It is same as defining a structure.

The basic syntax of union is as follows :

union union_name
{
	data_type var_1;
	data_type var_2;
	..;
	..;
	data_type var_n;
};

First we define union keyword with a unique union name. After this we define variables of different data types in curly brackets.

union Employee
{
    int emp_id;
    char emp_name[30];
    float salary;
};

Now in the above example we can see that the name of the union is taken as ‘Employee’ and there are three members of the Union- emp_id, emp_name and salary. Now variables can be declared for the union and every variable will have three members which will have a shared memory location.

There are two types to declare variables for Union:-.

1. When the definition of Union is written then Union variables can be declared along with it.
2. The variable of union can also be declared inside the main() function.

Syntax for Union Variable outside of Union Definition

union Union_name
{  
    member 1;  
    member 2;  
    ------------------
    ------------------
    member n;  
}Union_variable(s);

Example for Union Variable outside of Union Definition

union Teacher
{
    int teach_id;
    char teach_name[30];
}t1,t2;

Syntax for Union Variable in main() Function

union Union_name
{
    member 1;
    member 2;
    ...
    member n;
};
int main()
{
     union Union_name variable_name;
}

Example for Union Variable in main() Function

union Teacher
{
    int teach_id;
    char teach_name[30];
};

int main()
{
union Teacher info;
}

As we have already discussed, The members of the union are stored in the same memory location and the size of the whole union equals to the largest member of the Union.

So, when we find the size of the union it will return the size of the largest member of the union.

Let’s take an example for reference:

				    
#include"iostream"
using namespace std; 
union Teacher 
{
	int teach_id;
	char teach_name[20];
	float salary;
};
int main()
{
    union Teacher info;
    printf( "Size of Teacher id is : %d bytes\n", sizeof(info.teach_id));  // size of teach_id
    printf( "Size of Teacher name : %d bytes\n", sizeof(info.teach_name)); // size of teach_name
    printf( "Size of Teacher salary is : %d bytes\n", sizeof(info.salary)); // size of salary
     printf( "Size of Teacher union : %d bytes", sizeof(info)); // size of Teacher
    return 0;

}

Output:

Size of Teacher id is : 4 bytes
Size of Teacher name : 20 bytes
Size of Teacher salary is : 4 bytes
Size of Teacher union : 20 bytes

Union using Pointer

Members of the Union are accessed in two ways

. (dot Operator)
-> (pointer Operator)

Accessing Members using pointer Operator

#include <iostream>
union Teacher 
{
    int teach_id;
    char teach_name[30];
    float salary;
};
int main()
{
    union Teacher info;
    union Teacher *ptr;
    ptr = &info;
    ptr->teach_id = 34;
    strcpy( ptr->teach_name, "Sanya");
    ptr->salary = 20000.00;
    printf( "Teacher id is : %d\n", ptr->teach_id);
    printf( "Teacher name is %s\n", ptr->teach_name);
    printf( "Teacher salary is : %f", ptr->salary);
    return 0;
}

Output :

Teacher id is : 1184645120
Teacher name is
Teacher salary is : 20000.000000