In C programming, structures allow multiple variables of different data types to be grouped together. However, every member of a structure gets its own memory location. In situations where memory conservation is important, using structures may not be the most efficient solution.
To address this issue, C provides unions. A union is a user-defined data type similar to a structure, but all of its members share the same memory location. As a result, only one member can hold a valid value at a time. Unions are commonly used in embedded systems, hardware programming, and memory-sensitive applications.
 

Table of Contents

---

 

What is a Union in C?

A union is a user-defined data type that allows different data types to share the same memory location. Unlike structures, where each member has separate memory, all members of a union use the same memory space.
This means that the size of a union is determined by the size of its largest member. When a value is assigned to one member, it may overwrite the value stored in another member.
Syntax:

union union_name
{
    data_type member1;
    data_type member2;
    data_type member3;
};

Example:

union Data
{
    int num;
    float marks;
    char grade;
};

Explanation:
In this example, Data is a union containing three members. Although the union has multiple members, they all share the same memory location.

Declaring Union Variables

After defining a union, variables can be declared in the same way as structure variables.
Syntax:

union union_name variable_name;

Example:

union Data data1;

Explanation:
Here, data1 is a union variable of type Data. It can store values for any member of the union, but only one member should be used at a time.

Accessing Union Members

Union members are accessed using the dot operator (.), similar to structures.
Example:

// C program to access union members
#include stdio.h

union Data
{
    int num;
    float marks;
};

int main()
{
    union Data data1;

    data1.num = 100;

    printf("Number: %d\n", data1.num);

    return 0;
}

Output:

Number: 100

Explanation:
The value 100 is assigned to the member num. The dot operator is used to access and display the stored value.

Understanding Shared Memory in Unions

The most important feature of a union is that all members share the same memory location.
Example:

// C program to understand shared memory in unions
#include stdio.h

union Data
{
    int num;
    float marks;
};

int main()
{
    union Data data1;

    data1.num = 100;
    printf("Number: %d\n", data1.num);

    data1.marks = 95.5;
    printf("Marks: %.2f\n", data1.marks);

    printf("Number After Overwrite: %d\n", data1.num);

    return 0;
}

Output:

Number: 100
Marks: 95.50
Number After Overwrite: 1119813632

Explanation:
Initially, the value 100 is stored in num. When a value is assigned to marks, it overwrites the same memory location. As a result, the original value of num is lost and displays an unexpected value.

Finding the Size of a Union

The size of a union is equal to the size of its largest member because all members share the same memory location.
Example:

// C program to find the size of the union
#include stdio.h

union Data
{
    int num;
    float marks;
    char grade;
};

int main()
{
    printf("Size of Union: %zu bytes", sizeof(union Data));

    return 0;
}

Output:

Size of Union: 4 bytes

Explanation:
The largest member in the union is either int or float, both typically occupying 4 bytes. Therefore, the size of the union is 4 bytes.

Difference Between Structure and Union

Basis of Comparison	Structure	Union
Memory Allocation	Each member gets its own separate memory location.	All members share the same memory location.
Memory Usage	Memory usage is the sum of all member sizes.	Memory usage is equal to the size of the largest member.
Value Storage	All members can store values simultaneously.	Only one member can hold a valid value at a time.
Data Access	Changing one member does not affect other members.	Changing one member may overwrite other member values.
Efficiency	Suitable when all members need to be used together.	Suitable when memory optimization is required.

Advantages of Unions in C

1. Efficient Memory Usage: Since all members share the same memory location, unions consume less memory compared to structures. This makes them useful in memory-constrained environments.
2. Useful for Embedded Systems: Embedded systems often have limited memory resources. Unions help reduce memory consumption while handling different data types.
3. Supports Multiple Data Representations: The same memory location can be interpreted in different ways by using different union members. This flexibility is useful in low-level programming.
4. Improves Performance in Certain Applications: Using less memory can improve performance in applications where memory efficiency is critical.
5. Helpful in Hardware Programming: Unions are widely used when interacting with hardware registers and device drivers because they allow different views of the same memory location.

Limitations of Unions in C

1. Only One Valid Value at a Time: Since all members share memory, assigning a value to one member can overwrite the value stored in another member.
2. Risk of Data Loss: Accidentally accessing a member that was not most recently assigned may produce incorrect results.
3. More Difficult to Debug: Tracking which member currently contains valid data can be challenging in large programs.
4. Not Suitable for Simultaneous Data Storage: If multiple values need to be stored at the same time, structures are a better choice than unions.
5. Reduced Readability: Programs that heavily use unions can become harder to understand because different members share the same memory.

Common Mistakes While Using Unions

1. Assuming All Members Store Values Simultaneously: Many beginners think unions behave like structures.
Example:

union Data
{
    int num;
    float marks;
};

union Data d;

d.num = 100;
d.marks = 90.5;

printf("%d", d.num);

Explanation:
Assigning a value to marks overwrites the value stored in num.

2. Accessing an Uninitialized Union: Using union members before assigning values may produce garbage values.
Example:

union Data d;
printf("%d", d.num);

3. Misunderstanding Union Size: Some programmers expect the size of a union to be the sum of all member sizes.
Example:

union Data
{
    int num;
    char grade;
};

The size of the union is determined by the largest member, not the sum of member sizes.

4. Using the Wrong Member: Reading data from a member that was not most recently assigned can produce unexpected results.
Example:

d.marks = 95.5;
printf("%d", d.num);

5. Confusing Structures and Unions: Structures allocate separate memory for each member, while unions share memory among all members. Treating them as identical can lead to logical errors.

Applications of Unions in C

1. Embedded Systems: Embedded applications use unions to save memory when different data types need to share the same storage location.
2. Hardware Programming: Device drivers and hardware interfaces use unions to represent hardware registers in multiple formats.
3. Network Programming: Unions are used to interpret network packets in different ways without allocating extra memory.
4. Compiler Design: Compilers use unions in syntax trees and symbol tables to store different types of information efficiently.
5. Memory-Constrained Applications: Applications running on systems with limited memory use unions to optimize memory usage and improve efficiency.

Conclusion

Unions in C provide an efficient way to store different types of data in the same memory location. Unlike structures, where each member has separate memory, all union members share a common memory space, making unions highly memory-efficient.
Although unions offer significant memory savings, they should be used carefully because only one member can hold a valid value at a time. Understanding unions is important for embedded systems, hardware programming, compiler design, and other low-level applications where memory optimization is essential.

Frequently Asked Questions

1. What is a union in C?

A union is a user-defined data type in which all members share the same memory location.

2. How is a union different from a structure?

In a structure, each member has separate memory, whereas in a union, all members share the same memory location.

3. Why are unions used?

Unions are used to save memory when multiple data types do not need to store values simultaneously.

4. Which operator is used to access union members?

The dot (.) operator is used to access union members.

5. What determines the size of a union?

The size of a union is determined by the size of its largest member.