Structures and Unions

What is a structure? What is a union?

A structure is a user-defined data type that bundles related variables (called members) into a single unit. Each member gets its own memory.

struct Student {
    char  name[50];
    int   roll;
    float marks;
};                        /* semicolon is required */

struct Student s1;      /* declare a variable */
s1.roll = 101;          /* dot operator accesses members */

A union uses the same syntax but all members share one memory location. Only one member holds a valid value at any moment.

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

union Value v;
v.i = 65;      /* now i is valid */
v.f = 3.14;    /* now f is valid, i is garbage */

Why structures?

• Group related data — one Student instead of three loose variables
• Mixed types — arrays cannot hold a string, an int, and a float together
• Pass one argument — send an entire record to a function at once
• Arrays of records — Student list[100]; models a whole class
• Model the real world — the code starts describing the problem domain
• Build data structures — linked lists, stacks, trees all need self-referential structs
• File records — write and read a fixed-size record in one operation

/* Without a structure — three parallel arrays, easy to desynchronize */
char  names[100][50];
int   rolls[100];
float marks[100];

/* With a structure — one array of complete records */
struct Student list[100];

Applications of structures

Where unions are used instead:

• Memory-constrained systems — embedded devices where every byte counts
• Variant / tagged types — a value that is an int or a float, never both
• Type reinterpretation — inspecting the bytes of a value (implementation-specific)
• Protocol messages — one of several message bodies in a fixed buffer

Structure vs union

struct S { int i; float f; char c; };   /* sizeof ~ 12 bytes */
union  U { int i; float f; char c; };   /* sizeof ~ 4 bytes  */

union U u;
u.i = 10;
u.f = 2.5;                /* u.i is now meaningless */
printf("%d\n", u.i);      /* garbage — the bytes of 2.5 read as int */

Structure and union initialization

1. Positional initializer list:

struct Student s1 = { "Asha", 101, 88.5 };

2. Designated initializers (C99) — by member name:

struct Student s2 = { .roll = 102, .name = "Ravi" };
/* order does not matter; marks becomes 0 */

3. Partial initialization — the rest become zero:

struct Student s3 = { "Neha" };   /* roll = 0, marks = 0.0 */
struct Student s4 = { 0 };        /* everything zeroed */

4. Member-by-member assignment after declaration:

struct Student s5;
strcpy(s5.name, "Kiran");   /* strings need strcpy, not = */
s5.roll  = 103;
s5.marks = 91.0;

5. Copying one structure into another:

struct Student s6 = s1;   /* member-wise copy — allowed */

Union initialization — only one member:

union Value v1 = { 65 };           /* initializes the FIRST member */
union Value v2 = { .f = 3.14 };   /* designator picks another */

Pointers with structures

A pointer to a structure uses the arrow operator -> to reach members.

struct Student s = { "Asha", 101, 88.5 };
struct Student *p = &s;

printf("%d\n", p->roll);       /* arrow — preferred */
printf("%d\n", (*p).roll);    /* same thing, parentheses required */

p->marks = 95.0;               /* changes s.marks */

Self-referential structure — the basis of a linked list:

struct Node {
    int data;
    struct Node *next;   /* pointer to the same type — allowed */
};

Dynamic memory for structures

Allocating a single structure:

#include <stdlib.h>

struct Student *p = malloc(sizeof(*p));
if (p == NULL) return 1;

strcpy(p->name, "Asha");
p->roll  = 101;
p->marks = 88.5;

free(p);
p = NULL;

Allocating an array of structures:

int n, i;
scanf("%d", &n);

struct Student *list = calloc(n, sizeof(*list));
if (list == NULL) return 1;

for (i = 0; i < n; i++)
    scanf("%d", &list[i].roll);   /* list[i] is a struct → use dot */

free(list);

When the structure itself owns a pointer — free inside-out:

struct Person { char *name; int age; };

struct Person *q = malloc(sizeof(*q));
q->name = malloc(50);      /* second allocation */

free(q->name);              /* inner first */
free(q);                     /* then the struct */

Passing structures as function arguments

(a) By value — the function gets a copy:

void show(struct Student s) {
    printf("%s %d\n", s.name, s.roll);
    s.roll = 999;      /* changes the copy only */
}

(b) By pointer — the function can modify the original:

void promote(struct Student *s) {
    s->marks += 5;     /* changes the caller's struct */
}

promote(&s1);

(c) By const pointer — efficient and read-only:

void print(const struct Student *s) {
    printf("%s %.2f\n", s->name, s->marks);
    /* s->marks = 0;  would be a compile error */
}

(d) Returning a structure by value:

struct Point makePoint(int x, int y) {
    struct Point p;
    p.x = x;
    p.y = y;
    return p;       /* safe — the whole struct is copied out */
}

Bit fields

A bit field lets a structure member occupy an exact number of bits instead of a whole integer — useful when memory is tight or when modelling flags.

struct Flags {
    unsigned int isActive : 1;   /* 1 bit  → 0 or 1   */
    unsigned int isAdmin  : 1;   /* 1 bit             */
    unsigned int level    : 4;   /* 4 bits → 0 to 15  */
};

struct Flags f = { 0 };
f.isActive = 1;
f.level    = 12;

printf("size = %zu\n", sizeof(f));  /* often 4, not 12 */

typedef — cleaner declarations

/* Without typedef */
struct Point { int x, y; };
struct Point p1;          /* must repeat 'struct' */

/* With typedef */
typedef struct {
    int x, y;
} Point;

Point p2;                  /* clean */

/* Both tag and typedef — needed for self-reference */
typedef struct Node {
    int data;
    struct Node *next;    /* typedef name not ready yet here */
} Node;

Nested structures and arrays of structures

struct Date {
    int day, month, year;
};

struct Employee {
    char name[50];
    struct Date doj;      /* nested structure */
    float salary;
};

struct Employee e = { "Ravi", { 15, 8, 2020 }, 55000 };

printf("%d\n", e.doj.year);   /* chain the dots */

/* Array of structures */
struct Student list[3] = {
    { "Asha", 101, 88.5 },
    { "Ravi", 102, 76.0 },
    { "Neha", 103, 91.5 }
};

for (i = 0; i < 3; i++)
    printf("%s %d\n", list[i].name, list[i].roll);

Padding, alignment, and sizeof

The compiler inserts padding bytes so each member starts at an address suitable for its type. That is why sizeof often exceeds the sum of the members.

Shallow copy vs deep copy

struct Person { char *name; int age; };

struct Person a, b;
a.name = malloc(50);
strcpy(a.name, "Asha");

b = a;               /* SHALLOW: both point at the SAME buffer */
strcpy(b.name, "Ravi");  /* a.name also becomes "Ravi" */

/* DEEP copy — allocate separate storage */
b.name = malloc(50);
strcpy(b.name, a.name);

• = on structures copies members, including pointer values
• Two shallow copies sharing a buffer means a double free risk
• Deep copy means allocating new memory for every pointer member

Tagged unions — the safe way to use a union

A union alone cannot tell you which member is valid. Wrap it in a structure with a tag that records the current type.

enum Kind { KIND_INT, KIND_FLOAT, KIND_CHAR };

struct Variant {
    enum Kind kind;        /* which member is valid */
    union {
        int   i;
        float f;
        char  c;
    } value;
};

void show(const struct Variant *v) {
    switch (v->kind) {
        case KIND_INT:   printf("%d\n", v->value.i); break;
        case KIND_FLOAT: printf("%f\n", v->value.f); break;
        case KIND_CHAR:  printf("%c\n", v->value.c); break;
    }
}

Self-referential structures — a linked list node

struct Node {
    int data;
    struct Node *next;
};

/* Build two linked nodes on the heap */
struct Node *head = malloc(sizeof(*head));
head->data = 10;
head->next = malloc(sizeof(*head));
head->next->data = 20;
head->next->next = NULL;   /* end of list */

/* Free every node before exiting */
free(head->next);
free(head);

Common mistakes