Unions in C

Unions are a fundamental data structure in the C programming language, which allow you to store different types of data in the same memory location. They offer a way to manage memory more efficiently and enable advanced techniques like type-punning. In this tutorial, we’ll explore how unions work, how they are allocated in memory, and the key differences between unions and structures.

What are Unions?

Unions in C are a user-defined data type that allows multiple members to share the same memory location. They are defined using the ‘union’ keyword, followed by a set of member variables enclosed in braces. Unions can hold values of different data types, but only one member can contain a value at a time.


union UnionName {
    dataType1 member1;
    dataType2 member2;


  • union-name is the name of the union.
  • member-1member-2, …, member-n are the members of the union.

Accessing Union Members in C

To access a member of a union in C, you use the dot (.) operator. The syntax for accessing a union member is as follows:



  • union-variable is the name of the union variable.
  • member-name is the name of the member you want to access.

Memory Allocation for Unions:

The memory allocated for a union is equal to the size of its largest member. This is because a union can only store one value at a time, and it needs to have enough space for any of its members. When you assign a value to one of the union’s members, the memory location is overwritten with the new value.


union Data {
    int i;
    float f;
    char str[10];
int main() {
    union Data data;
    printf("Memory size occupied by data: %zu\n", sizeof(data));
    return 0;

In this example, the size of the Data union will be 10 bytes (assuming that int is 4 bytes, float is 4 bytes, and char is 1 byte), which is the size of the largest member, str.unions memory allocation

Unions vs. Structures:

Unions and structures are both user-defined data types, but they have some key differences:

Memory Allocation:

  • Unions: Memory allocated is equal to the size of the largest member.
  • Structures: Memory allocated is the sum of the size of all members.


Member Access:

  • Unions: Only one member can store a value at a time.
  • Structures: Each member can store a value independently.

Use Cases:

  • Unions: Useful when you want to store different types of data in the same memory location and interpret it differently, depending on the context.
  • Structures: Ideal for grouping related variables together, without the need for overlapping memory.

Read about Structures in C – Structures in C – NerdyElectronics

Example: Union Usage

#include <stdio.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: %.1f\n", data.f);
    strcpy(data.str, "C Programming");
    printf("data.str: %s\n", data.str);
    return 0;

In this example, only the value of data.str will be printed correctly, because it was the last value assigned to the union. The other two values (data.i and data.f) will be overwritten.

When to Use Unions in C

Unions can be useful in a variety of situations, such as:

  • When you need to store multiple values of different types in a single variable.
  • When you need to save space by storing multiple values in the same memory location.
  • When you need to be able to quickly switch between different values.


Understanding how unions work and how they differ from structures is crucial for mastering C programming. Unions provide a memory-efficient way to store different types of data in the same location, allowing you to manage memory and perform advanced techniques, such as type-punning. Keep practicing and experimenting with unions and structures to deepen your understanding of these powerful C language features.

Leave a Reply

Your email address will not be published. Required fields are marked *