Anonymous Union in C

Introduction

An anonymous union is a union that does not have a name (tag) and whose members can be accessed directly without specifying a union variable. Anonymous unions provide a convenient way to group multiple data representations while simplifying member access.

Anonymous unions are supported in modern C standards (starting with C11 as an optional feature) and are widely used in embedded systems, operating systems, hardware interfaces, and low-level libraries.

Before learning anonymous unions, you should understand how ordinary unions work.

What Is an Anonymous Union?

An anonymous union is a union declaration without a tag name or variable name. Instead of accessing members through a union object, the members become direct members of the enclosing scope.

        
union
{
    type member1;

    type member2;
};
        
    

Unlike an ordinary union, there is no union variable used to access its members.

Anonymous Union Inside a Structure

The most common use of anonymous unions is inside structures.

        
struct Data
{
    int type;

    union
    {
        int number;

        float decimal;
    };
};
        
    

Because the union is anonymous, its members become direct members of struct Data.

Accessing Members

Anonymous union members are accessed directly through the enclosing structure.

        
struct Data value;

value.number = 100;

value.decimal = 3.14f;
        
    

Notice that there is no union variable name between value and the member.

Comparison with an Ordinary Union

Ordinary Union

        
struct Data
{
    union
    {
        int number;

        float decimal;
    } value;
};

struct Data data;

data.value.number = 100;
        
    

Anonymous Union

        
struct Data
{
    union
    {
        int number;

        float decimal;
    };
};

struct Data data;

data.number = 100;
        
    

The anonymous union eliminates one level of member access.

Complete Example

        
#include <stdio.h>

struct Value
{
    int type;

    union
    {
        int integer;

        float decimal;
    };
};

int main(void)
{
    struct Value value;

    value.integer = 100;

    printf("%d\n", value.integer);

    return 0;
}
        
    

        
100
        
    

Memory Layout

An anonymous union has the same memory layout as an ordinary union.

• All members share the same memory.
• The size equals the largest member (plus alignment).
• Writing to one member overwrites the others.

The only difference is the way members are accessed.

Tagged Union Pattern

Anonymous unions are commonly combined with an enumeration to indicate which member is currently active.

        
enum ValueType
{
    INTEGER,

    FLOAT
};

struct Value
{
    enum ValueType type;

    union
    {
        int integer;

        float decimal;
    };
};
        
    

The type field identifies whether integer or decimal currently contains valid data.

Advantages of Anonymous Unions

• Simpler member access.
• Cleaner syntax.
• No unnecessary union variable.
• Useful for hardware register definitions.
• Widely used in low-level programming.

Limitations

• Members still share the same memory.
• Only one member should normally contain a valid value at a time.
• Not supported by every older C compiler.
• Can make member names conflict with surrounding declarations.

Anonymous Union vs Ordinary Union

Common Use Cases

Anonymous unions are commonly found in:

• Embedded systems.
• Hardware register mappings.
• Operating systems.
• Device drivers.
• Network protocol implementations.
• Tagged unions.

Common Beginner Mistakes

• Assuming anonymous unions have a different memory layout from ordinary unions.
• Believing multiple members can safely hold values simultaneously.
• Using anonymous unions without checking compiler support.
• Confusing anonymous unions with anonymous structures.
• Ignoring name collisions with enclosing structure members.

Best Practices

• Use anonymous unions when direct member access improves readability.
• Pair anonymous unions with an enum to identify the active member.
• Use descriptive member names to avoid naming conflicts.
• Verify compiler support when targeting older C standards.
• Document which member is expected to be active at any given time.

Summary

An anonymous union is a union without a name whose members become direct members of the enclosing scope. It provides cleaner syntax while preserving the same memory-sharing behavior as an ordinary union.

Anonymous unions are a convenient feature for modern C programs that need the memory efficiency of unions without the extra level of member access. When combined with an enumeration, they provide a clean and powerful way to represent variant data.