Union

Defining a Union

To define a union, we use union keyword.
The union statement defines a new data type with more than one member for your program. The format of the union statement is as follows -

                   
union union_tag
{
    datatype member1;
    datatype member2;
    .
    . 
    . 
} var;

Example ↓

                   
union Data
{
    int i;
    float f;
    char str[20];
} data;

The memory occupied by a union will be large enough to hold the largest member of the union.
For example, in the above example, data type will occupy 20 bytes of memory space because this is the maximum space which can be occupied by a character string.
The following code checks the size of union data type.

                   
#include <stdio.h>
#include <string.h>

union Data
{
    int i;
    float f;
    char str[20];
};

int main()
{
    union Data data;

    printf("Memory size occupied by data : %d", sizeof(data)); // 20
}

Accessing Union Members

To access any member of a union, we use the member access operator (.)

                   
#include <stdio.h>
#include <string.h>
    
union Data {
    int i;
    float f;
    char str[20];
};
    
int main( ) {

    union Data data;        

    data.i = 10;
    data.f = 220.5;
    strcpy( data.str, "C Programming");

    printf( "data.i : %d\n", data.i);
    printf( "data.f : %f\n", data.f);
    printf( "data.str : %s\n", data.str);

    return 0;
}

Output ↓

                        
data.i : 1917853763
data.f : 4122360580327794860452759994368.000000
data.str : C Programming

The values of i and f members of union got corrupted because the final value assigned to the variable has occupied the memory location and this is the reason that the value of str member is getting printed very well.

Now we will take an example where we will use one variable at a time. Which is the main purpose of having unions - ↓

                   
#include <stdio.h>
#include <string.h>
    
union Data {
    int i;
    float f;
    char str[20];
};
    
int main( ) {

    union Data data;        

    data.i = 10;
    printf( "data.i : %d\n", data.i);
    
    data.f = 220.5;
    printf( "data.f : %f\n", data.f);
    
    strcpy( data.str, "C Programming");
    printf( "data.str : %s\n", data.str);

    return 0;
}

when the above code is compiled and executed, it produces the following result. ↓

                   
data.i : 10
data.f : 220.500000
data.str : C Programming

Structure v/s Union

Memory allocation:
- A structure allocates separate memory space for each member variable declared inside the structure. Thus, the size of the structure is the sum of the sizes of all the member variables.
- A union, on the other hand, allocates the same memory space for all the member variables declared inside the union. Thus, the size of the union is equal to the size of its largest member variable.
Accessing member variables:
- In a structure, all the member variables can be accessed simultaneously and each variable has its own unique memory location.
- In a union, only one member variable can be accessed at a time and all the member variables share the same memory location.
Usage:
- Structures are commonly used to group related variables together into a single unit, whereas unions are mainly used for memory optimization and to save memory space.

Memory allocation of union members

In a union, memory is allocated in such a way that all the members share the same memory location.
The size of the memory allocated to the union is equal to the size of the largest member in the union.

For example consider the following union ↓

                         
union student
{
    char name[20];
    int rollNo;
    float fees;
}

In this union, the size of the largest member is 'char name[ ]' which takes up 20 bytes of memory. Therefore, the union student will take up 20 bytes of memory. However, only one of the members can be accessed at a time.
Thus, the union allows us to store different data types in the same memory location, saving memory space. However, we need to be careful while accessing the members as only one member can be accessed at a time.

Bit fields

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.
The type-specifier for the variable must be unsigned int, signed int or int.
Bit fields are used when the storage of our program is limited. Need of bit fields in C programming language:
- Reduces memory consumption
- To make our program more efficient and flexible.
Applications of Bit-fields:
- If storage is limited, we can go for bit-field.

Consider the following declaration without the use of bit fields.

                   
#include <stdio.h>

struct order
{
    unsigned int isAvailable;
    unsigned int isTshirt;
};

int main()
{
    printf("Size of order is %lu bytes\n", sizeof(struct order));
    struct order hoodie= {1, 0};
    printf("The order is %s and it is %s",(hoodie.isAvailable)?"available":"not available", (hoodie.isTshirt)?"T-shirt":"not T-shirt");
    return 0;
}

Output ↓

                   
Size of order is 8 bytes
The order is available and it is not T-shirt

The above representation of 'order' takes 8 bytes.
Since we know that the value of each member can be either 1 or 0 to represent true or false repectively.
So, we need only 2 bits out of 32 bits (8 bytes). We can optimize the space using bit fields.

Declaration of bit fields in C.

Bit-fields are variables that are defined using a predefined width or size. Format and the declaration of the bit-fileds in C are shown below ↓

                       
// syntax 
struct
{
    data_type member_name: width_of_bit_field;
};

data_type: It is an integer type that determines the bit-field value which is to be interpreted. data type may be int, signed int, or unsigned it.
member_name: The member name is the name of the bit field.
width: The number of bits in the bit-filed. The width be less than or equal to the bit width of the specified type.

Now we will see, 'order' representation with bit-fields ↓

                       
#include <stdio.h>
#pragma pack(1)
// space opmitized representation of 'order'
struct order
{
    // isAvailable can store either 0 or 1, so 1 bits are sufficient
    unsigned int isAvailable : 1;

    // isTshirt can store either 0 or 1, so 1 bits are sufficient
    unsigned int isTshirt : 1;
};

int main()
{
    printf("Size of order is %lu byte\n", sizeof(struct order)); // 1
    struct order hoodie= {1, 0};
    printf("The order is %s and it is %s",(hoodie.isAvailable)?"available":"not available", (hoodie.isTshirt)?"T-shirt":"not T-shirt");
    return 0;
}

Output ↓

                    
Size of order is 1 byte
The order is available and it is not T-shirt