Dynamic Structures

Why allocate structures dynamically?

Normally you declare a structure as a fixed variable. But sometimes you do not know how many you will need until the program runs — say, records for however many students the user enters. Dynamic allocation lets you create structures at run time with malloc, using exactly as much memory as you need.

The tools are the same as any dynamic memory: malloc to reserve, free to release — plus one new piece of syntax, the arrow operator.

Allocating a single struct

#include <stdio.h>
#include <stdlib.h>
struct Student { char name[20]; int marks; };

int main() {
    struct Student *p = malloc(sizeof(struct Student));
    if (p == NULL) return 1;         // always check

    p->marks = 95;                    // arrow operator
    printf("Marks = %d\n", p->marks);

    free(p);
    return 0;
}

The arrow operator

When you have a struct variable you use a dot. When you have a struct pointer you use the arrow ->.

p->marks is simply a cleaner way to write (*p).marks — first follow the pointer, then reach the member.

A dynamic array of structures

Ask for space for n structures in one malloc, then use normal indexing.

#include <stdio.h>
#include <stdlib.h>
struct Student { char name[20]; int marks; };

int main() {
    int n = 3;
    struct Student *arr = malloc(n * sizeof(struct Student));
    if (arr == NULL) return 1;

    for (int i = 0; i < n; i++)
        arr[i].marks = (i + 1) * 10;   // dot, because arr[i] is a value

    for (int i = 0; i < n; i++)
        printf("Student %d: %d\n", i + 1, arr[i].marks);

    free(arr);
    return 0;
}

Freeing the memory

Whether you allocated one struct or an array, one free on the pointer releases the whole block.

free(arr);      // releases all n structures
arr = NULL;     // good habit: avoid a dangling pointer

Common mistakes

• Using dot . on a pointer (or arrow on a plain variable).
• Forgetting to check malloc for NULL before use.
• Forgetting free, causing a memory leak.
• Using the memory after freeing it (a dangling pointer).

Summary

• Use malloc(sizeof(struct ...)) to create a structure at run time.
• Access members through a pointer with the arrow operator ->.
• For n structs, malloc(n * sizeof(struct ...)) and index with arr[i].
• Use . on a struct value, -> on a struct pointer.
• Always check malloc and free what you allocate.