Structure vs Union

Programming Language & Its Applications — Pointers, Structure and Data Files in C, NEC licence examination syllabus (Nepal Engineering Council).

Structure vs Union

A struct gives every member its own space; a union makes them all share one. The size difference tells the whole story.

A struct groups related values of different types into one named object — a student record, a point, a date. A union looks identical in syntax but lays all members at the same address, so only one is valid at a time. Structs are what you use ninety-nine percent of the time; unions matter for memory-constrained code, type-punning and tagged variants.

🌍 Where this lives: structs are how you read a file format or a network packet. An IP header, a BMP image header, a WAV audio header — each is a documented byte layout you can declare as a struct and read in one fread. This is also where padding becomes urgent: get it wrong and your struct no longer matches the file, so you read garbage. Search "__attribute__((packed)) network header" to see how systems programmers force the layout to match the wire format exactly.

Structure declaration and access

struct Student { int roll; char name[30]; float marks; }; /* semicolon is mandatory */ Creating variables: struct Student s1; struct Student s2 = {101, "Ram Bahadur", 87.5f}; struct Student s3 = {.marks = 90.0f, .roll = 102}; /* designated initialisers, C99 */ Access: s1.roll = 101; /* dot for an object */ struct Student *p = &s1; p->roll = 101; /* arrow for a pointer */ (*p).roll = 101; /* identical to p->roll */ typedef removes the repeated "struct": typedef struct { int x, y; } Point; Point a = {3, 4};

structbasics.c

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

typedef struct {
    int   roll;
    char  name[30];
    float marks[3];
    float total;
} Student;

int main(void) {
    Student s = {101, "Ram Bahadur", {78.0f, 85.5f, 91.0f}, 0};

    s.total = 0;
    for (int i = 0; i < 3; i++) s.total += s.marks[i];

    printf("Roll : %d\n", s.roll);
    printf("Name : %s\n", s.name);
    printf("Marks: %.1f %.1f %.1f\n",
           s.marks[0], s.marks[1], s.marks[2]);
    printf("Total: %.1f  Avg: %.2f\n", s.total, s.total/3);

    /* via a pointer */
    Student *p = &s;
    printf("through pointer: %s scored %.1f\n",
           p->name, p->total);

    /* struct assignment copies EVERYTHING, member by
       member - including the whole name array */
    Student t = s;
    strcpy(t.name, "Sita Devi");
    printf("s.name=%s   t.name=%s\n", s.name, t.name);
    return 0;
}
Output:
Roll : 101
Name : Ram Bahadur
Marks: 78.0 85.5 91.0
Total: 254.5  Avg: 84.83
through pointer: Ram Bahadur scored 254.5
s.name=Ram Bahadur   t.name=Sita Devi

Notice that Student t = s; performs a full member-wise copy — unlike arrays, structs are assignable. But it is a shallow copy: if a member were a pointer, both structs would point to the same memory.

Union: shared storage

union Value { int i; /* 4 bytes */ float f; /* 4 bytes */ char s[8]; /* 8 bytes */ }; sizeof(union Value) = 8 ← the LARGEST member (plus padding for alignment) All members start at the SAME address: &u.i == &u.f == &u.s Writing one member OVERWRITES the others. Reading a member you did not last write gives an implementation-defined reinterpretation of those bytes. Contrast: struct S { int i; float f; char s[8]; }; sizeof(struct S) = 16 ← 4 + 4 + 8, each its own space

unions.c

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

struct S { int i; float f; char s[8]; };
union  U { int i; float f; char s[8]; };

int main(void) {
    printf("sizeof(struct S) = %zu\n", sizeof(struct S));
    printf("sizeof(union  U) = %zu\n", sizeof(union U));

    union U u;
    u.i = 65;
    printf("wrote i=65  -> i=%d s[0]='%c'\n", u.i, u.s[0]);

    u.f = 3.14f;     /* CLOBBERS i */
    printf("wrote f     -> f=%.2f i=%d (garbage)\n",
           u.f, u.i);

    strcpy(u.s, "HELLO");
    printf("wrote s     -> s=%s f=%g (garbage)\n",
           u.s, u.f);

    /* all members share the address */
    printf("&u.i=%p &u.f=%p &u.s=%p\n",
           (void*)&u.i, (void*)&u.f, (void*)u.s);
    return 0;
}
Output:
sizeof(struct S) = 16
sizeof(union  U) = 8
wrote i=65  -> i=65 s[0]='A'          <-- 65 is ASCII 'A'
wrote f     -> f=3.14 i=1078523331 (garbage)
wrote s     -> s=HELLO f=1.14314e+27 (garbage)
&u.i=0x7ffd4a1b2c30 &u.f=0x7ffd4a1b2c30 &u.s=0x7ffd4a1b2c30

Why u.i became 1078523331 after writing 3.14f: 3.14f in IEEE-754 single precision: sign = 0 exponent = 128 → biased, 2^(128-127) = 2 mantissa gives 1.57 × 2 = 3.14 bit pattern: 0100 0000 0100 1000 1111 0101 1100 0011 as hex : 0x4048F5C3 as int : 1078523331 ✔ The BYTES did not change — only the interpretation. This is "type punning", and it is exactly what a union lets you do.

Memory layout and padding

padding.c

#include <stdio.h>
#include <stddef.h>

struct Bad  { char c; int i; char d; };   /* 12 */
struct Good { int i; char c; char d; };   /* 8  */

int main(void) {
    printf("Bad  = %zu bytes\n", sizeof(struct Bad));
    printf("Good = %zu bytes\n", sizeof(struct Good));

    printf("Bad  offsets: c=%zu i=%zu d=%zu\n",
        offsetof(struct Bad,c), offsetof(struct Bad,i),
        offsetof(struct Bad,d));
    printf("Good offsets: i=%zu c=%zu d=%zu\n",
        offsetof(struct Good,i), offsetof(struct Good,c),
        offsetof(struct Good,d));
    return 0;
}
Output:
Bad  = 12 bytes
Good = 8 bytes
Bad  offsets: c=0 i=4 d=8
Good offsets: i=0 c=4 d=5

The alignment rule: each member sits at an offset that is a multiple of its own size (its alignment requirement), and the total size is rounded up to a multiple of the LARGEST alignment. struct Bad { char c; int i; char d; } offset 0: c (1 byte) offset 1-3: PADDING — int needs a multiple of 4 offset 4: i (4 bytes) offset 8: d (1 byte) offset 9-11: PADDING — round total to a multiple of 4 total = 12 bytes for 6 bytes of data → 50% wasted struct Good { int i; char c; char d; } offset 0: i, offset 4: c, offset 5: d offset 6-7: padding → total 8, only 25% wasted For an array of 1,000,000 records that is 4 MB saved by reordering three declarations.

The alignment exists because CPUs fetch memory in aligned words. An unaligned 4-byte read may need two memory cycles, or on some architectures fault outright. The compiler inserts padding to guarantee speed — you control it only by ordering members largest to smallest.

Worked example — the tagged union

tagged.c

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

/* The safe, standard way to use a union: pair it with a
   tag saying which member is currently valid. */
typedef enum { T_INT, T_FLOAT, T_STR } Type;

typedef struct {
    Type tag;                 /* which member is live */
    union { int i; float f; char s[16]; } val;
} Variant;

void print_variant(const Variant *v) {
    switch (v->tag) {
        case T_INT:   printf("int    %d\n",   v->val.i); break;
        case T_FLOAT: printf("float  %.2f\n", v->val.f); break;
        case T_STR:   printf("string %s\n",   v->val.s); break;
    }
}

int main(void) {
    Variant a = { T_INT,   .val.i = 42 };
    Variant b = { T_FLOAT, .val.f = 3.14f };
    Variant c; c.tag = T_STR; strcpy(c.val.s, "Nepal");

    print_variant(&a); print_variant(&b); print_variant(&c);

    printf("sizeof(Variant) = %zu\n", sizeof(Variant));
    return 0;
}
Output:
int    42
float  3.14
string Nepal
sizeof(Variant) = 20

💡 Exam angle: the struct-vs-union comparison table is asked directly — separate storage vs shared storage, size = sum-plus-padding vs size = largest member, all members valid vs one member valid. Be ready to compute sizeof with padding for a given struct: that is a favourite numerical. Know the dot-vs-arrow rule and that struct assignment is a shallow member-wise copy.

Syllabus points

Difference; memory usage

Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.