Union in C: Syntax, Examples, Memory Optimization

Published: 27 Nov 2025 | Reading Time: 5 min read

Table of Contents

Key Takeaways From the Blog

Introduction

In C programming, union in C used to minimize the usage of memory when several variables occupy the same space in memory. Unlike structures, which use separate memory space for each member, union uses space to all members so that they occupy the same memory. This is especially useful when a programmer knows that a variable will contain one value from a set of choices at a specific time.

The union in C saves memory, mainly while working with large memory objects in memory-limited systems. The article discusses all the aspects of unions in C, such as their definition, initialization, accessing the union members, and how unions differ from structures. It also discusses real-life applications, their pros and cons, and compares them with structures.

What is a Union in C?

A union in C is a user-defined data type that allows many members to use a shared memory location. Only one member can store a value at a time, and unions are used most effectively in conserving memory in programs where storing several values simultaneously is unnecessary.

Types of Defining a Union

Unions can be defined using the union keyword followed by the union name and its members:

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

Declaration and Syntax of Unions

A union in C is a data structure created by the user that can hold different data types but the data types share the same memory location. It is important to proper union declaration and definition to be able to use memory efficiently and have flexible data handling.

Union Declaration Using the union Keyword

A union declaration consists of the union keyword, the name of the union, followed by a set of curly braces containing member declarations. Each element is a variable that will use the same memory space.

General Syntax:

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

Example: Declaring a union named union_data

union union_data {
    int int_member;
    float float_member;
    char char_member;
};
/* union_data is a user-defined data type
and its members share the same memory */

Here, union_data is a user-defined data type, and its members (int_member, float_member, char_member) share the same memory.

Creating Union Variables

After declaring a union type, you can create union variables in two ways:

1. During Declaration

union myunion {
    int x;
    float y;
} var1, var2;

/* var1 and var2 are union variables of type union myunion */

Here, var1 and var2 are union variables of type union myunion.

2. After Declaration

union myunion var3, var4;

/* Using an already defined union type to declare variables */

This approach declares union variables using an already defined union type.

Example: Union Declaration and Member Access

union student {
    int roll_no;
    float percentage;
};

union student stu1;
stu1.roll_no = 25;  // Accessing a member in union using the dot operator

Key Points:

Initialization of Union

A union can be initialized at the time of declaration. Only one member (the first one, unless using a designated initializer in C99 or later) can be initialized directly.

Example:

union myunion data1 = {100}; // Initializes the first member (x)

Or, using a designated initializer (C99+):

union myunion data2 = {.y = 3.14}; // Initializes the member y

Key Terms Used

Initialization of Union Members

In C programming Union initialization involves assigning an initial value to one of the union's members. Since all members share the same memory, only one member can be initialized at a time.

Syntax

Initializer List:

union UnionName obj = {value};

Designated Initializer (C99 and later):

union UnionName obj = {.member_name = value};

Example

#include <stdio.h>
union Data {
    int i;
    float f;
};

int main() {
    union Data obj = {42};  // Initialize first member (i)
    printf("Value: %d\n", obj.i);
    return 0;
}

Examples of Union

Here are the C programming union examples:

How to use unions in a program

#include <stdio.h>
union Data {
    int x;
    float y;
};

int main() {
    union Data data;
    data.x = 42;  // Step 1: Assign integer value
    printf("Integer: %d\n", data.x);  // Step 2: Access integer member

    data.y = 3.14;  // Step 3: Assign float value (overwrites integer)
    printf("Float: %.2f\n", data.y);  // Step 4: Access float member

    return 0;
}

Explanation:

Output:

Integer: 42
Float: 3.14

Quick Recap: Unions store multiple data types in shared memory, saving space but allowing only one valid member at a time.

Size of a Union

#include <stdio.h>
union SizeUnion {
    int a;
    double b;
};

int main() {
    printf("Size of union: %lu bytes\n", sizeof(union SizeUnion));
    return 0;
}

Explanation:

Output:

Size of union: 8 bytes

Memory Occupied by a Union

#include <stdio.h>
union MemoryUnion {
    int x;
    char y[10];
};

int main() {
    printf("Memory occupied by union: %lu bytes\n", sizeof(union MemoryUnion));
    return 0;
}

Explanation:

Output:

Memory occupied by union: 10 bytes

Memory Occupied by a Structure

#include <stdio.h>
struct MemoryStruct {
    int x;
    char y[10];
};

int main() {
    printf("Memory occupied by structure: %lu bytes\n", sizeof(struct MemoryStruct));
    return 0;
}

Explanation:

Output:

Memory occupied by structure: 14 bytes

Key Takeaways So Far:

Accessing and Initializing Union Members

Understanding how to access and initialize union members is essential for effective use of unions in C programming. Since all members of a union share the same memory location, only one member can hold a valid value at a time. Below are the key methods and concepts related to accessing and initializing union members.

Accessing Union Members

Union members are accessed using the dot operator (.) for direct access or the arrow operator (->) when using pointers to union variables. This is similar to accessing members of a struct.

Example using the dot operator:

#include <stdio.h>

union Data {
    int i;
    float f;
};

int main() {
    union Data data;
    data.i = 10;  // Access individual member using dot operator
    printf("Integer value: %d\n", data.i);

    return 0;
}

Example using the arrow operator:

#include <stdio.h>

union Data {
    int i;
    float f;
};

int main() {
    union Data data;
    union Data *ptr = &data;  // Pointer to union
    ptr->f = 3.14;  // Access individual member using arrow operator
    printf("Float value: %.2f\n", ptr->f);

    return 0;
}

Initializing Union Members

A union member can be initialized when the union variable is declared. Initialization is done using an initializer list or a designated initializer (for C99 and later).

Example of member initialization:

#include <stdio.h>

union Data {
    int i;
    float f;
};

int main() {
    union Data data1 = {42};  // Initializes the first member (i)
    printf("Value of i: %d\n", data1.i);

    return 0;
}

Note: Only one member can be initialized at a time. Assigning a new value to a different member will overwrite the existing data because of shared memory.

Anonymous Unions and Structs with Unions

An anonymous union is a union declared without a name, allowing its members to be accessed directly within a struct or the containing scope.

Example of anonymous union in a struct:

#include <stdio.h>

struct Example {
    int type;
    union {       // Anonymous union
        int i;
        float f;
    };
};

int main() {
    struct Example ex;
    ex.i = 100;  // Accessed directly due to anonymous union
    printf("Value of i: %d\n", ex.i);

    return 0;
}

This approach is useful when working with structs that include a union for memory-efficient storage of different data types.

Key Terms in Practice

Similarities Between Union and Structure

Here are the similarities of Union and Structure:

Difference Between Union and Structure

Here are the key differences for the union and structure:

Aspect Union Structure
Memory Allocation Shared same memory for all members Different memory for every member
Size Size of the largest member The sum of size of all members
Member Access A single member can be accessed at a time All members can be accessed at the same time
Memory Usage Conserves memory space More use of memory
Initialization Only the initial member can be initialized All members can be initialized
Use Case Ideal when a single value is required at a time Ideal when more values are required at a time
Performance Slower, since just one member is accessed Faster, since all the members are accessed
Flexibility Less flexible, since a single member only is utilized More flexible for data of different types

Quick Note: Union vs structure: unions save memory with shared storage, structures offer flexibility with independent memory for every member.

Applications and Use Cases of Unions

Unions in C are quite helpful, particularly in situations where it is necessary to save memory and the data representation has to be flexible. The following are some examples and practical implementation of the use of unions that are dominant especially in the domain of systems-level and low-level programming.

1. Efficient Memory Usage in Memory-Constrained Environments

Unions are a kind of data structure that can have different types of data sharing the same memory space. This feature makes them perfect for applications where memory is limited, such as in embedded systems or microcontrollers. The use of unions offers the advantage of limiting the memory consumption since only one value can be stored at a time.

2. Hardware Mapping and Register Access

In low-level programming, unions are often used to map hardware registers. Hardware registers may have different interpretations—such as status, command, or data fields—depending on the operation being performed. Using a union enables direct, efficient access to these registers under different formats without casting or complex pointer manipulations.

Example:

union Register {
    unsigned int value;
    struct {
        unsigned int status : 8;
        unsigned int command : 8;
        unsigned int data : 16;
    } fields;
};

Here, the same register can be accessed as a whole (value) or as individual fields (status, command, data).

3. Tagged Unions for Flexible Data Structures

A tagged union represents the combination of a union and a variable that indicates the member which is valid (the "tag"). The idea is extensively implemented as the specification of the data structures designed to store the types of data changing in different times. Examples of such are unit converters, protocol parsers, and message systems.

Example:

enum DataType { INT, FLOAT, STATUS };

struct TaggedData {
    enum DataType type;
    union {
        int i;
        float f;
        char status[8];
    } value;
};

The type field tracks which member of the union is currently holding valid data, reducing the risk of data corruption.

4. Reducing Data Corruption Risks

Properly tagged unions combined with cautious access enable programmers to lessen the danger of data corruption due to wrong member access to almost zero. This pattern plays a vital role in systems-level programming.

5. Interpreting Data with Different Meanings

Unions come in handy when the same memory has to be looked at in different ways. Say, a communication protocol might have to look at a register as a command when one context and as a status when another. Such a flexibility is a typical feature of unions in C.

Key Takeaways So Far:

Advantages of Union in C

Here are the key advantages of Union in C:

Disadvantages of Union in C

Here are the some disadvantages of Union in C:

Bottom Line: Unions save memory but require careful handling to avoid overwriting and unpredictable behavior.

Conclusion

In conclusion, unions are an important concept in C programming, offering programmers a memory-conserving way of dealing with memory for various types of data that do not need to be available simultaneously. They save memory and simplify operations for some but do have limitations such as overwriting values, which must be dealt with stringently. It is essential to understand how and when unions are to be used to enhance program performance, especially in resource-constrained environments such as embedded systems.

Why It Matters?

Unions in C language are significant as they help in cutting down memory consumption to a large extent by permitting different data types to use the same memory area. As a result, they are indispensable in the development of embedded systems, programming at the hardware level, and any kind of applications where the speed of the code, low memory usage, and the ability to interpret the data in various ways are factors that are needed for the program to behave correctly.

Practical Advice for Learners

Frequently Asked Questions

1. Can multiple members of a union in C hold values at the same time?

No. In a union, all members share the same memory location, so only one member can store a valid value at any given time. Writing to one member will overwrite the value of the others.

2. Why does accessing a union member sometimes give unexpected results?

If you assign a value to one member and then read from another without reassigning, the result is usually unpredictable. This is because all members occupy the same memory space, and their binary representations may not be compatible.

3. What occurs if I attempt to simultaneously initialize multiple members of a union?

When an initializer list is used, only the first member can be directly initialized. With a designated initializer (C99 and later), you can indicate the member to be initialized. If you initialize more than one member, you do not have multiple valid values; only the last one will be stored.

4. By what means can I determine which member of a union is presently valid?

C unions do not maintain information about the last member that was written. It is the programmer's obligation to figure out this, usually by having an extra variable (like an enum or a flag) together with the union.

5. Are unions a safe choice in C?

Unions can be considered safe if they are used with care; however, they have the potential to cause very subtle bugs in the situation where you accidentally access a member which was not the last one to be written. So, as a rule, make sure that you only access the member that is presently valid.

6. What is the reason that sizeof(union) gives the size of the biggest member?

The union is required to be as large as its largest member since all the members share the same memory. Therefore, the size of the union is equal to the size of the biggest member, with an additional padding, if any.

7. Can I use unions with arrays or structures as members?

Yes, unions can have arrays or structures as members. The size of the union will be at least as large as the largest member, whether it is a primitive type, array, or structure.

8. What are some typical use cases or situations in which unions would be beneficial?

Unions find their great utility in scenarios where memory is limited such as embedded systems or when different types of data need to be placed in the same location at different times (e.g., hardware registers or protocol packets).

9. Are there any constraints or disadvantages of union usage?

Indeed. The main restrictions are that only one member can store a valid value at a time, and incorrect accessing may result in undefined behavior. It is difficult to debug errors associated with unions.

10. What is a common misconception about unions in C?

A frequent misconception is that unions can store multiple values at once like structures. In reality, only one member can hold a valid value at a time due to shared memory.

Related Articles

Source: NxtWave CCBP Blog

Original URL: https://www.ccbp.in/blog/articles/union-in-c

Contact Information: