Introduction

Structures and unions are user-defined C types that group multiple members under one type name. Their declaration syntax is similar, but their memory models are fundamentally different.

struct Data
{
    int integer;
    double real;
    char character;
};

union DataValue
{
    int integer;
    double real;
    char character;
};

In a structure, each member has its own storage within the structure object. All members can retain their values simultaneously.

In a union, all members overlap in the same storage region. The program normally stores and interprets one selected alternative at a time.

Prerequisites

What Is a Structure?

A structure groups related members into one object while giving each member a distinct position in that object.

struct Student
{
    unsigned int identifier;
    double average_score;
    char grade;
};

A struct Student object can retain its identifier, average score and grade simultaneously.

struct Student student = {
    .identifier = 101,
    .average_score = 87.5,
    .grade = 'A'
};

Conceptual Structure Layout

struct Student
+-------------------+
| identifier        |
+-------------------+
| possible padding  |
+-------------------+
| average_score     |
+-------------------+
| grade             |
+-------------------+
| possible padding  |
+-------------------+

The named members do not overlap. The implementation may insert padding between members or after the final member to satisfy alignment requirements.

What Is a Union?

A union defines several alternative members that occupy overlapping storage.

union Number
{
    int integer;
    double real;
};

The same union object can be used to store an integer value or a double value at different times.

union Number number;

number.integer = 25;

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

number.real = 19.95;

printf(
    "%.2f\n",
    number.real
);

Conceptual Union Layout

union Number
+-------------------------+
| integer storage         |
| overlaps real storage   |
| overlaps every member   |
+-------------------------+

Writing to number.real reuses storage that was previously used through number.integer. The application must track which interpretation is intended.

Structure vs Union Summary

sizeof a Structure

struct Example
{
    char character;
    int integer;
    double real;
};

The size of the structure includes:

• Storage for character
• Storage for integer
• Storage for real
• Any internal padding
• Any trailing padding

printf(
    "Structure size: %zu\n",
    sizeof(struct Example)
);

Do not predict the result by adding assumed sizes. Measure the target implementation.

sizeof a Union

union Example
{
    char character;
    int integer;
    double real;
};

The union must provide enough storage and suitable alignment for any of its members.

printf(
    "Union size: %zu\n",
    sizeof(union Example)
);

The union size is therefore at least large enough for its largest member. The implementation may include padding to meet alignment and array-layout requirements.

Measuring Both Types

#include <stdalign.h>
#include <stdio.h>

struct StructureData
{
    char character;
    int integer;
    double real;
};

union UnionData
{
    char character;
    int integer;
    double real;
};

int main(void)
{
    printf(
        "Structure size     : %zu\n",
        sizeof(struct StructureData)
    );

    printf(
        "Structure alignment: %zu\n",
        alignof(struct StructureData)
    );

    printf(
        "Union size         : %zu\n",
        sizeof(union UnionData)
    );

    printf(
        "Union alignment    : %zu\n",
        alignof(union UnionData)
    );

    return 0;
}

The output can differ between compilers, architectures, ABIs and compiler options.

Member Addresses

Union members begin at the same union storage location.

#include <stdio.h>

union Data
{
    int integer;
    double real;
    char character;
};

int main(void)
{
    union Data data;

    printf(
        "union address : %p\n",
        (void *)&data
    );

    printf(
        "integer       : %p\n",
        (void *)&data.integer
    );

    printf(
        "real          : %p\n",
        (void *)&data.real
    );

    printf(
        "character     : %p\n",
        (void *)&data.character
    );

    return 0;
}

In comparison, structure members have distinct ordered positions, although padding can exist between them.

Writing Structure Members

struct Data
{
    int integer;
    double real;
};

struct Data data;

data.integer = 25;
data.real = 19.95;

Both values remain available:

printf(
    "%d %.2f\n",
    data.integer,
    data.real
);

Writing Union Members

union Data
{
    int integer;
    double real;
};

union Data data;

data.integer = 25;

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

data.real = 19.95;

printf(
    "%.2f\n",
    data.real
);

After assigning data.real, the program should treat real as the selected alternative unless a narrowly defined language rule or verified implementation contract explicitly supports another interpretation.

data.integer = 25;
data.real = 19.95;

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

The Active-member Problem

A union object contains no automatic metadata identifying which member the application intends to use.

union Value
{
    int integer;
    double real;
    const char *text;
};

Looking only at a union Value object does not tell application code whether it should use integer, real or text.

A separate discriminator, commonly called a tag, solves this problem.

Tagged Union

enum ValueType
{
    VALUE_INTEGER,
    VALUE_REAL,
    VALUE_TEXT
};

struct Value
{
    enum ValueType type;

    union
    {
        int integer;
        double real;
        const char *text;
    } data;
};

The enumeration records which union member is selected.

Creating Tagged Values

struct Value first = {
    .type = VALUE_INTEGER,
    .data.integer = 25
};

struct Value second = {
    .type = VALUE_REAL,
    .data.real = 19.95
};

struct Value third = {
    .type = VALUE_TEXT,
    .data.text = "C Programming"
};

Reading the Selected Member

void value_print(
    const struct Value *value)
{
    if (value == NULL)
    {
        return;
    }

    switch (value->type)
    {
        case VALUE_INTEGER:
            printf(
                "Integer: %d\n",
                value->data.integer
            );
            break;

        case VALUE_REAL:
            printf(
                "Real: %.2f\n",
                value->data.real
            );
            break;

        case VALUE_TEXT:
            printf(
                "Text: %s\n",
                value->data.text != NULL
                    ? value->data.text
                    : "(null)"
            );
            break;

        default:
            puts("Invalid value type.");
            break;
    }
}

Why the Tag Is Outside the Union

union InvalidValue
{
    enum ValueType type;
    int integer;
    double real;
};

If the tag is another member of the same union, writing the value reuses the storage occupied by the tag.

struct Value
{
    enum ValueType type;

    union
    {
        int integer;
        double real;
    } data;
};

Anonymous Union Members

C11 supports anonymous unions under the applicable language rules.

struct Value
{
    enum ValueType type;

    union
    {
        int integer;
        double real;
        const char *text;
    };
};

Members can then be accessed directly:

struct Value value = {
    .type = VALUE_INTEGER,
    .integer = 25
};

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

A named union member such as data can make the storage relationship more explicit, while an anonymous union can make access shorter. Follow the project's readability standard consistently.

Initializing Structures and Unions

Structure Initialization

struct Student
{
    unsigned int identifier;
    double score;
    char grade;
};

struct Student student = {
    .identifier = 101,
    .score = 87.5,
    .grade = 'A'
};

Multiple structure members can be initialized because each has independent storage.

Union Initialization

union Number
{
    int integer;
    double real;
};

union Number number = {
    .real = 12.5
};

A designated initializer clearly identifies the initially selected union member.

Assignment

Structure and union objects can be assigned to compatible objects of the same type.

struct Student first = {
    .identifier = 101,
    .score = 87.5,
    .grade = 'A'
};

struct Student second =
    first;

union Number first_number = {
    .integer = 50
};

union Number second_number =
    first_number;

For a union, application-level correctness still requires the receiver to know which alternative the copied representation denotes. A tagged union copies both the tag and union when the containing structure is assigned.

Comparing Structures and Unions

C does not provide a built-in equality operator for complete structure or union objects.

if (left == right)
{
    /* Not valid for structure objects. */
}

Avoid using memcmp() as a general logical comparison because structure or union representations can contain padding bytes.

Compare a Tagged Union by Meaning

int values_equal(
    const struct Value *left,
    const struct Value *right)
{
    if (left == NULL ||
        right == NULL)
    {
        return left == right;
    }

    if (left->type != right->type)
    {
        return 0;
    }

    switch (left->type)
    {
        case VALUE_INTEGER:
            return
                left->data.integer ==
                right->data.integer;

        case VALUE_REAL:
            return
                left->data.real ==
                right->data.real;

        case VALUE_TEXT:
            if (left->data.text == NULL ||
                right->data.text == NULL)
            {
                return
                    left->data.text ==
                    right->data.text;
            }

            return strcmp(
                left->data.text,
                right->data.text
            ) == 0;

        default:
            return 0;
    }
}

Unions with Dynamically Allocated Members

enum ResourceType
{
    RESOURCE_NONE,
    RESOURCE_INTEGER_ARRAY,
    RESOURCE_TEXT
};

struct Resource
{
    enum ResourceType type;

    union
    {
        struct
        {
            int *values;
            size_t count;
        } integer_array;

        char *text;
    } data;
};

Cleanup must inspect the tag before releasing owned resources.

void resource_destroy(
    struct Resource *resource)
{
    if (resource == NULL)
    {
        return;
    }

    switch (resource->type)
    {
        case RESOURCE_INTEGER_ARRAY:
            free(
                resource->data
                    .integer_array
                    .values
            );

            resource->data
                .integer_array
                .values = NULL;

            resource->data
                .integer_array
                .count = 0;
            break;

        case RESOURCE_TEXT:
            free(
                resource->data.text
            );

            resource->data.text =
                NULL;
            break;

        case RESOURCE_NONE:
            break;

        default:
            break;
    }

    resource->type =
        RESOURCE_NONE;
}

Safely Changing a Tagged-union Alternative

When an existing alternative owns resources, release it before selecting a different alternative.

int resource_set_text(
    struct Resource *resource,
    const char source[])
{
    if (resource == NULL ||
        source == NULL)
    {
        return 0;
    }

    size_t length =
        strlen(source);

    if (length == SIZE_MAX)
    {
        return 0;
    }

    char *copy =
        malloc(length + 1);

    if (copy == NULL)
    {
        return 0;
    }

    memcpy(
        copy,
        source,
        length + 1
    );

    resource_destroy(resource);

    resource->data.text = copy;
    resource->type = RESOURCE_TEXT;

    return 1;
}

The new allocation is completed before the existing resource is destroyed. Therefore, allocation failure leaves the original value unchanged.

Structures, Unions and External Data

Neither a structure nor a union automatically defines a portable file or network representation.

fwrite(
    &value,
    sizeof value,
    1,
    file
);

Raw object representations can depend on:

• Member sizes
• Structure padding
• Union alignment and padding
• Integer representation
• Floating-point representation
• Byte order
• Pointer representation
• Compiler and ABI rules

Unions and Hardware Interfaces

Low-level code sometimes uses unions to provide multiple views of a register or data word.

union RegisterView
{
    uint32_t complete_value;
    unsigned char bytes[4];
};

The observed relationship between complete_value and bytes depends on representation details such as byte order.

Do not assume that a union declaration alone establishes compatibility with a device register or communication format. Such code requires verified compiler, ABI and hardware documentation.

Type Punning and Representation Inspection

Union-based reinterpretation is sensitive to language rules and implementation behavior. It can also produce target-dependent results because object representations differ.

When the goal is to inspect or copy representation bytes portably, use character storage and memcpy().

#include <string.h>

void copy_float_bytes(
    float value,
    unsigned char output[
        sizeof(float)
    ])
{
    memcpy(
        output,
        &value,
        sizeof value
    );
}

This safely copies the representation bytes. It does not make those bytes a platform-independent encoding.

Common Structure Use Cases

• Student, employee and product records
• Coordinates containing multiple dimensions
• Dates containing day, month and year
• Configuration objects
• Linked-list and tree nodes
• Function results containing several related values
• Objects containing metadata and owned resources

Coordinate Example

struct Point3D
{
    double x;
    double y;
    double z;
};

A point requires all three coordinates simultaneously, making a structure appropriate.

Common Union Use Cases

• Tagged variant values
• Parser tokens with alternative payload types
• Abstract syntax tree nodes with alternative node data
• Events carrying different payloads
• Memory-sensitive internal representations
• Implementation-specific hardware or binary views under a verified contract

Token Example

enum TokenType
{
    TOKEN_IDENTIFIER,
    TOKEN_INTEGER,
    TOKEN_REAL
};

struct Token
{
    enum TokenType type;

    union
    {
        const char *identifier;
        long integer;
        double real;
    } value;
};

Every token has one type and one corresponding payload.

Complete Tagged-union Program

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

enum ValueType
{
    VALUE_EMPTY,
    VALUE_INTEGER,
    VALUE_REAL,
    VALUE_TEXT
};

struct Value
{
    enum ValueType type;

    union
    {
        long integer;
        double real;
        char *text;
    } data;
};

void value_initialize(
    struct Value *value)
{
    if (value == NULL)
    {
        return;
    }

    value->type = VALUE_EMPTY;
    value->data.integer = 0;
}

void value_destroy(
    struct Value *value)
{
    if (value == NULL)
    {
        return;
    }

    if (value->type == VALUE_TEXT)
    {
        free(value->data.text);
    }

    value->type = VALUE_EMPTY;
    value->data.integer = 0;
}

int value_set_integer(
    struct Value *value,
    long integer)
{
    if (value == NULL)
    {
        return 0;
    }

    value_destroy(value);

    value->data.integer =
        integer;

    value->type =
        VALUE_INTEGER;

    return 1;
}

int value_set_real(
    struct Value *value,
    double real)
{
    if (value == NULL)
    {
        return 0;
    }

    value_destroy(value);

    value->data.real = real;
    value->type = VALUE_REAL;

    return 1;
}

int value_set_text(
    struct Value *value,
    const char text[])
{
    if (value == NULL ||
        text == NULL)
    {
        return 0;
    }

    size_t length =
        strlen(text);

    if (length == SIZE_MAX)
    {
        return 0;
    }

    char *copy =
        malloc(length + 1);

    if (copy == NULL)
    {
        return 0;
    }

    memcpy(
        copy,
        text,
        length + 1
    );

    value_destroy(value);

    value->data.text = copy;
    value->type = VALUE_TEXT;

    return 1;
}

void value_print(
    const struct Value *value)
{
    if (value == NULL)
    {
        return;
    }

    switch (value->type)
    {
        case VALUE_EMPTY:
            puts("Value: empty");
            break;

        case VALUE_INTEGER:
            printf(
                "Integer: %ld\n",
                value->data.integer
            );
            break;

        case VALUE_REAL:
            printf(
                "Real: %.2f\n",
                value->data.real
            );
            break;

        case VALUE_TEXT:
            printf(
                "Text: %s\n",
                value->data.text
            );
            break;

        default:
            puts("Value: invalid type");
            break;
    }
}

int main(void)
{
    struct Value value;

    value_initialize(&value);

    if (!value_set_integer(
            &value,
            250))
    {
        return EXIT_FAILURE;
    }

    value_print(&value);

    if (!value_set_real(
            &value,
            49.95))
    {
        value_destroy(&value);
        return EXIT_FAILURE;
    }

    value_print(&value);

    if (!value_set_text(
            &value,
            "C Programming"))
    {
        value_destroy(&value);
        return EXIT_FAILURE;
    }

    value_print(&value);

    printf(
        "Tagged value size: %zu\n",
        sizeof value
    );

    value_destroy(&value);

    return EXIT_SUCCESS;
}

Program Analysis

1. The outer structure provides separate storage for the tag and union.
2. The enumeration records the selected union alternative.
3. The union stores an integer, real number or text pointer in shared storage.
4. value_initialize() establishes a valid empty state.
5. Every setter changes both the selected union member and the tag.
6. The text alternative owns dynamically allocated character storage.
7. The text setter allocates the replacement before destroying the previous value.
8. value_destroy() releases storage only when the text alternative is selected.
9. value_print() checks the tag before reading a union member.
10. The printed sizeof value is measured rather than assumed.

Common Mistakes

data.integer = 25;
data.real = 19.95;

value.type = VALUE_REAL;
value.data.integer = 25;

Choosing Structure or Union

Best Practices

Recommended Test Cases

Recommended Compiler Commands

Warning-enabled C17 Build

gcc -std=c17 -Wall -Wextra -Wpedantic -Wconversion -Wsign-conversion -Wswitch-enum program.c -o program

Clang C17 Build

clang -std=c17 -Wall -Wextra -Wpedantic -Wconversion -Wsign-conversion -Wswitch-enum program.c -o program

Development Build with Sanitizers

gcc -std=c17 -Wall -Wextra -Wpedantic -fsanitize=undefined,address -fno-omit-frame-pointer -g program.c -o program

Complete switch diagnostics are especially useful for tagged unions because adding a new enumeration alternative should prompt a review of printing, copying, comparison and destruction logic.

Practice Exercises

1. Create a structure and union containing char, int and double members.
2. Print their measured sizes and alignments.
3. Print the addresses of every union member.
4. Demonstrate that structure members retain values simultaneously.
5. Create a tagged union representing integer, real and text values.
6. Write constructor functions for every tagged-union alternative.
7. Write a printing function that checks the tag.
8. Write a member-aware equality function.
9. Add dynamically allocated text ownership.
10. Write correct cleanup logic for every alternative.
11. Implement safe copying of the tagged union with deep copying for text.
12. Encode the tagged value into an explicit byte-oriented format.
13. Decode the external format with bounds validation.
14. Compare structure and union layouts under two supported compilers.

Frequently Asked Questions