Structure vs Union in C: Key Differences (with Memory Table)

The Difference in 30 Seconds

The short answer: a structure gives every member its own separate memory. A union makes all its members share the same memory. That single fact decides everything else between them.

If you take a structure with three members, each one lives in its own box. If you take a union with those same three members, they all sit in one box and take turns using it. Whichever member was written last is the one you get back when you read.

The rest of this page walks through what that looks like in code, how the memory is laid out, and when you would choose one over the other. If you just need the table, it is two sections below.

What is a Structure?

A structure is a way to bundle related pieces of data under one name. Think of it as a small container that holds several labelled slots, each with its own type.

For example, if you are tracking employees, you might want each employee to have a number, a name, and a salary. A structure lets you keep those three pieces together. Each employee record then has all three values stored at the same time.

struct structure_name {
    data_type member1;
    data_type member2;
    ...
};

Example — an employee structure:

struct employee {
    int empno;
    char ename[20];
    long salary;
};

Every member of a structure has its own memory address. Changing the employee number does not touch the employee name. They live in different parts of memory. That is the whole point — a structure lets you read and write every member whenever you like.

What is a Union?

A union looks almost identical to a structure when you write it. Same syntax, same member list. The difference is what happens in memory.

In a union, all members share the same memory. The union is exactly as big as its largest member, and only one member can hold a value at a time. If you write to the name and then write to the salary, the salary overwrites the name. They occupy the same bytes.

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

Example — the same fields as a union:

union employee {
    int empno;
    char ename[20];
    long salary;
};

Both pieces of code look the same. But with a structure, all three values live side by side in memory, so you can read all three back whenever you want. With a union, only the most recently written member is valid. Reading the others gives you garbage.

Key Differences Between Structure and Union

If you remember nothing else from this page, remember the table below. The rest of the differences all flow from the first row.

How Memory Works in Each

Let's say you have a structure with three members: an int (4 bytes), a char array of 20 (20 bytes), and a long (8 bytes).

With a structure, the compiler reserves separate memory for each member. The total size is the sum of the parts — 4 + 20 + 8 = 32 bytes. All three members are usable at the same time, because each lives in its own address.

With a union, the compiler reserves one block of memory that is big enough for the largest member. In this case, the largest is the 20-byte array, so the union is 20 bytes. All members are mapped to that same starting address. If you write to the int and then write to the long, the long overwrites the int. You cannot hold both at once.

One small detail: the size of a structure is sometimes larger than the sum of its members. This is because of padding — the compiler adds a few unused bytes between members to keep each one aligned to a natural boundary. The union does not have this issue, because only one member is valid at a time.

When to Use Structure vs Union

This is the question most beginners ask first, and it is the right question. The answer comes down to one thing: do you need to keep all the values at the same time, or just one at a time?

Reach for a structure when:

• You have several related fields that must all be accessible at once. Think of an employee record, a student mark sheet, or a point with x and y coordinates.
• You are modelling a real object. Most objects in the real world have several attributes that coexist.
• You do not care about saving every last byte. Structures are the normal, predictable choice.

Reach for a union when:

• You are short on memory, and you know only one value will be used at a time. Embedded systems and microcontrollers are the classic cases.
• You are parsing a network packet where the meaning of the same bytes depends on a preceding tag. This is the "tagged union" pattern you see in C libraries.
• You want to peek at the raw bytes of one type as another type. Not something you do often, but it has its uses when debugging binary formats.

In everyday C code, structures are the default. You will use them dozens of times per project. Unions are more of a special-purpose tool — you will use them when you need them and forget about them otherwise.

Common Mistakes Beginners Make

These are the errors I see most often when students run this code for the first time. Check your own code against each one before you move on.

• Reading a union member you did not write last. If you assign to the int and then read the char array, you get nonsense. That is not a bug. That is how unions work. Only the last written member is valid.
• Expecting the size of a structure to be exactly the sum of its members. Padding can add a few bytes. Use sizeof if you need the exact size. Do not add up the members in your head.
• Using a union when a structure was needed. If you find yourself confused about why a value keeps changing, check whether you accidentally used a union. Most of the time you wanted a structure.
• Initializing more than one union member at once. This will not compile. A union holds exactly one member at a time, so it can be initialized with exactly one value.
• Assuming sizeof(struct) equals sizeof(union) when both have the same members. They never do. The struct is larger. That is the whole point.

Full Program Example

Here is a complete program that shows both a structure and a union with the same members. Run it and watch the sizes come out different.

#include <stdio.h>

struct EmpStruct {
    int id;
    char name[20];
    float salary;
};

union EmpUnion {
    int id;
    char name[20];
    float salary;
};

int main() {
    printf("Size of Structure: %lu bytes\n", sizeof(struct EmpStruct));
    printf("Size of Union: %lu bytes\n", sizeof(union EmpUnion));
    return 0;
}

/* Sample Output:
Size of Structure: 28 bytes
Size of Union: 20 bytes
*/

Frequently Asked Questions

Previous Topic: -->> Create and Use Union in C   ||   Next topic: -->> Union Examples