Difference Between struct and union in C

By the end of this page, you will understand how struct and union differ in C, especially in memory layout, data access, and practical use. You will also learn that this is mainly a language and memory-model concept, not an operating system feature.

A struct and a union are both user-defined types in C, but they represent data in very different ways.

struct

A struct gives each member its own storage. All fields can hold valid values at the same time.

struct Point {
    int x;
    int y;
};

If you set x and y, both values are stored independently.

union

A union makes all members share the same memory location. Only one member's value is meaningfully stored at a time.

union Number {
    int i;
    float f;
};

If you write to i and then write to f, the f write reuses the same bytes and overwrites the previous contents.

Think of a struct as a desk with separate labeled drawers:

• one drawer for id
• one drawer for price
• one drawer for code

Each member has its own space, so all values can exist together.

Think of a union as a single drawer with several labels stuck on it:

• id
• price
• code

There is still only one drawer. The labels are different ways to interpret the same space. If you put something in as id and later put something in as price, the new value replaces the old bytes.

So:

• struct = many storage locations grouped together
• union = one storage location viewed in different ways

Basic syntax

struct Person {
    int age;
    char initial;
};

union Value {
    int i;
    float f;
    char c;
};

Example: struct

#include <stdio.h>

struct Person {
    int age;
    char initial;
};

int main(void) {
    struct Person p;
    p.age = 25;
    p.initial = 'A';

    printf("age = %d\n", p.age);
    printf("initial = %c\n", p.initial);
    return 0;
}

Here both fields keep their values because each member has separate storage.

Example: union

Consider this union example:

#include <stdio.h>

union Data {
    int i;
    char c;
};

int main(void) {
    union Data d;

    d.i = 65;
    printf("d.i = %d\n", d.i);

    d.c = 'B';
    printf("d.c = %c\n", d.c);

    return 0;
}

Step by step

1. union Data d;

   • Memory is reserved for one union Data variable.
   • Its size is enough for the largest member.

2. d.i = 65;

   • The shared memory is filled with the integer representation of 65.
   • At this point, i is the active member.

When struct is used

struct is used far more often than union in everyday C programming.

Common uses:

• storing records such as users, points, products, or configuration data
• grouping related fields into one object
• representing packets, headers, or state objects
• passing multiple related values to functions

Example:

struct User {
    int id;
    char role;
    float rating;
};

A user has all of these properties at the same time, so struct is the correct choice.

When union is used

union is useful when a value can be one of several types, but never all at once.

Common uses:

• memory-constrained systems
• parsers handling different token value types
• message payloads where only one payload format is active
• tagged data types combined with an enum

Example:

  {
    TYPE_INT,
    TYPE_FLOAT,
    TYPE_CHAR
};


    
    
         i;
         f;
         c;
    } data;
};

In real projects, developers usually use union together with a tag that tells the program which member is currently valid.

Tagged union pattern

enum EventType {
    EVENT_KEY,
    EVENT_MOUSE
};

struct Event {
    enum EventType type;
    union {
        int key_code;
        struct {
            int x;
            int y;
        } mouse;
    } data;
};

This is common in:

• event systems
• compilers and interpreters
• protocol handling
• embedded firmware

Why the tag matters

Without a tag, code can easily read the wrong union member.

struct usage patterns in real code

Developers use struct for:

• configuration objects
• return values with multiple fields
• state containers
• linked list and tree nodes
• API request and response models

Guarding access to unions

A common pattern is:

1. Thinking a union stores all members at once

Broken assumption:

union Data {
    int i;
    float f;
};

union Data d;
d.i = 10;
d.f = 2.5f;
printf("%d\n", d.i);  // Not a safe way to expect the old int value

Why it is wrong:

• assigning d.f overwrites the shared memory
• d.i is no longer the active value

2. Using a union when a struct is needed

Broken design:

union Person {
    int age;
    char initial;
};

If a person needs both age and initial, use a struct, not a union.

3. Ignoring padding and alignment

Beginners often assume sizes are just the sum of member sizes.

struct vs union in one sentence

struct S {
    int a;
    float b;
};

union U {
    int a;
    float b;
};

• struct: each member has its own storage
• union: all members share the same storage
• struct size: enough for all members + padding
• union size: enough for largest member + alignment
• struct: all fields can be used together
• union: only one member should be treated as active
• No special OS-level difference in normal C usage
• Layout details depend on compiler, target, and alignment rules

Good rule of thumb

• Need multiple fields at once? Use struct.
• Need one value that may take different forms? Use union.

Safer union pattern

enum Kind { INT_KIND, FLOAT_KIND };

  {
    
    
         i;
         f;
    } data;
};

Is a union just a smaller struct?

No. A union is not just a space-optimized struct. Its members share the same memory, which changes how values are stored and read.

When should I use a struct instead of a union?

Use a struct when all fields are part of the object at the same time, such as a user with an id, name, and age.

When is a union useful in C?

A union is useful when a value can be one of several types, such as a token in a parser or an event payload in a system.

Does the operating system treat structs and unions differently?

Usually no. This is mainly a C language and compiler memory layout issue, not an OS-level distinction.

Why is a union often combined with an enum?

The enum acts as a tag so the program knows which union member currently contains valid data.

Can a union and struct have unexpected sizes?

Yes. Alignment and padding can change sizes, especially for structs. Always use sizeof instead of guessing.

Is reading one union member after writing another allowed?

It may compile, but it can be tricky and is often not the right design for beginners. Use a tagged union pattern when possible.

• sizeof — useful for checking the actual memory size of struct and union types.
• memory alignment — explains why type sizes and field layout may include padding.
• padding — closely related to how compilers lay out struct members.
• enum — commonly used with unions to track the active member.
• arrays — another way of storing multiple values, but unlike structs they usually store values of the same type.
• pointers — often used with structs and unions in real C programs.
• type casting — related when interpreting memory in different ways, though it must be used carefully.
• typedef — often used to make struct and union types easier to name and use.