Dynamic Arrays in C — Safe realloc Patterns for Production

#include <stdio.h>
#include <stdlib.h>

// Demonstrates why stack arrays fail when size is runtime-determined
// and how malloc solves the problem cleanly.

int main(void) {
    int item_count;

    printf("How many temperature readings do you want to store? ");
    scanf("%d", &item_count);

    // STACK approach — ILLEGAL in standard C89 and risky even in C99:
    // int temperatures[item_count];  // <-- Variable Length Array, avoid in production

    // HEAP approach — safe, portable, works at any size:
    // malloc(n * sizeof(double)) asks the OS for exactly n doubles worth of bytes
    double *temperatures = malloc(item_count * sizeof(double));

    // malloc returns NULL if allocation fails (e.g., out of memory)
    // ALWAYS check — ignoring this causes a segfault on the next line
    if (temperatures == NULL) {
        fprintf(stderr, "Memory allocation failed. Cannot store %d readings.\n", item_count);
        return 1;  // exit with error code, not just 0
    }

    // Populate with dummy sensor readings
    for (int index = 0; index < item_count; index++) {
        temperatures[index] = 20.0 + (index * 0.5);  // simulate rising temps
    }

    // Use the data
    printf("\nStored %d readings. First: %.1f°C  Last: %.1f°C\n",
           item_count, temperatures[0], temperatures[item_count - 1]);

    // ALWAYS free heap memory when done — the OS won't do this for you
    free(temperatures);
    temperatures = NULL;  // null the pointer so it can't be accidentally used again

    return 0;
}

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

// A reusable dynamic integer array with automatic growth.
// Models exactly how a C++ vector works internally.

typedef struct {
    int    *data;      // pointer to the heap block holding our integers
    int     count;     // how many items are currently stored
    int     capacity;  // how many items the current allocation can hold
} IntArray;

// Initialise the array with a small starting capacity
void array_init(IntArray *arr) {
    arr->capacity = 4;  // start small — we'll grow as needed
    arr->count    = 0;
    arr->data     = malloc(arr->capacity * sizeof(int));

    if (arr->data == NULL) {
        fprintf(stderr, "Failed to initialise dynamic array.\n");
        exit(1);
    }
}

// Append one integer, growing the backing array if necessary
void array_push(IntArray *arr, int value) {
    if (arr->count == arr->capacity) {
        // We're full — double the capacity
        int new_capacity = arr->capacity * 2;

        // Use a temporary pointer — if realloc fails we still have our old data
        int *resized = realloc(arr->data, new_capacity * sizeof(int));

        if (resized == NULL) {
            // realloc failed; arr->data is still valid, we just can't grow right now
            fprintf(stderr, "Could not grow array to capacity %d. Aborting push.\n", new_capacity);
            return;
        }

        // Safe to update now that we confirmed success
        arr->data     = resized;
        arr->capacity = new_capacity;

        printf("  [resize] Grew to capacity %d\n", new_capacity);
    }

    // Store the value and advance the count
    arr->data[arr->count] = value;
    arr->count++;
}

// Print every element with its index
void array_print(const IntArray *arr) {
    printf("Array (count=%d, capacity=%d): [", arr->count, arr->capacity);
    for (int i = 0; i < arr->count; i++) {
        printf("%d", arr->data[i]);
        if (i < arr->count - 1) printf(", ");
    }
    printf("]\n");
}

// Release heap memory — always call this when done
void array_free(IntArray *arr) {
    free(arr->data);
    arr->data     = NULL;  // prevent use-after-free
    arr->count    = 0;
    arr->capacity = 0;
}

int main(void) {
    IntArray scores;
    array_init(&scores);

    // Push 10 scores — watch the array resize automatically
    int game_scores[] = {42, 87, 15, 93, 56, 71, 34, 88, 62, 99};
    int total_games   = sizeof(game_scores) / sizeof(game_scores[0]);

    printf("Inserting %d scores into the dynamic array:\n", total_games);
    for (int i = 0; i < total_games; i++) {
        array_push(&scores, game_scores[i]);
    }

    printf("\nFinal state:\n");
    array_print(&scores);

    array_free(&scores);
    return 0;
}

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

typedef struct {
    int *data;
    int  count;
    int  capacity;
} IntArray;

void array_init(IntArray *arr) {
    arr->capacity = 8;
    arr->count    = 0;
    arr->data     = malloc(arr->capacity * sizeof(int));
    if (!arr->data) { fprintf(stderr, "Init failed\n"); exit(1); }
}

void array_push(IntArray *arr, int value) {
    if (arr->count == arr->capacity) {
        int  new_cap  = arr->capacity * 2;
        int *resized  = realloc(arr->data, new_cap * sizeof(int));
        if (!resized) { fprintf(stderr, "Grow failed\n"); return; }
        arr->data     = resized;
        arr->capacity = new_cap;
    }
    arr->data[arr->count++] = value;
}

// Remove the element at position `index`
// Shifts everything after it left by one slot
int array_remove(IntArray *arr, int index) {
    if (index < 0 || index >= arr->count) {
        fprintf(stderr, "Remove index %d out of bounds (count=%d)\n", index, arr->count);
        return -1;  // signal failure
    }

    int removed_value = arr->data[index];

    // Shift elements left — memmove handles overlapping regions safely
    memmove(
        &arr->data[index],          // destination: where the gap is
        &arr->data[index + 1],      // source: one past the gap
        (arr->count - index - 1) * sizeof(int)  // bytes to move
    );

    arr->count--;

    // Shrink if we're only using a quarter of our capacity
    // Floor at a minimum capacity of 4 to avoid tiny allocations
    if (arr->count > 0 && arr->count <= arr->capacity / 4 && arr->capacity > 4) {
        int  new_cap = arr->capacity / 2;
        int *shrunk  = realloc(arr->data, new_cap * sizeof(int));
        if (shrunk) {  // shrink is optional — if it fails, just keep the bigger block
            arr->data     = shrunk;
            arr->capacity = new_cap;
            printf("  [resize] Shrunk to capacity %d\n", new_cap);
        }
    }

    return removed_value;
}

void array_print(const IntArray *arr) {
    printf("[count=%d cap=%d]: ", arr->count, arr->capacity);
    for (int i = 0; i < arr->count; i++) printf("%d ", arr->data[i]);
    printf("\n");
}

void array_free(IntArray *arr) {
    free(arr->data);
    arr->data = NULL;
    arr->count = arr->capacity = 0;
}

int main(void) {
    IntArray task_ids;
    array_init(&task_ids);

    // Simulate a task queue with 8 tasks
    for (int id = 101; id <= 108; id++) {
        array_push(&task_ids, id);
    }

    printf("Initial queue:\n");
    array_print(&task_ids);

    // Remove task 103 (at index 2)
    int removed = array_remove(&task_ids, 2);
    printf("\nRemoved task ID %d\n", removed);
    array_print(&task_ids);

    // Remove several more to trigger shrink
    array_remove(&task_ids, 0);
    array_remove(&task_ids, 0);
    array_remove(&task_ids, 0);
    array_remove(&task_ids, 0);
    printf("\nAfter 4 more removals:\n");
    array_print(&task_ids);

    array_free(&task_ids);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

// Compare memory behaviour of doubling vs golden ratio growth
// Run with: gcc -o growth growth_factor_comparison.c && ./growth

int main(void) {
    int capacity_double = 4;
    int capacity_golden = 4;
    int count = 100;

    printf("Capacity progression for %d insertions:\n", count);
    printf("Insert  Doubling  Golden(1.618)\n");

    for (int i = 0; i < count; i++) {
        printf("%6d  %8d  %8d\n", i+1, capacity_double, capacity_golden);

        if (i == capacity_double) capacity_double *= 2;
        if (i == capacity_golden) capacity_golden = (int)(capacity_golden * 1.618) + 1;
    }

    printf("\nFinal capacity using doubling: %d\n", capacity_double);
    printf("Final capacity using golden:    %d\n", capacity_golden);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

// Intentionally create a buffer overflow to show how AddressSanitizer catches it
// Compile: gcc -g -fsanitize=address -o debug_demo debug_demo.c && ./debug_demo

int main(void) {
    int *arr = malloc(5 * sizeof(int));  // capacity for 5 ints
    if (!arr) return 1;

    for (int i = 0; i <= 5; i++) {  // Off-by-one: writes to arr[5] which is out of bounds
        arr[i] = i * 10;
    }

    printf("arr[5] = %d\n", arr[5]);  // This line will never be reached with ASan
    free(arr);
    return 0;
}