Dynamic Memory Allocation

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

int main(void)
{
    // 1. malloc: uninitialized. Note "sizeof *numbers", not "sizeof(int)".
    int *numbers = malloc(4 * sizeof *numbers);
    if (numbers == nullptr) {               // ALWAYS check
        return EXIT_FAILURE;
    }
    for (size_t i = 0; i < 4; ++i) {
        numbers[i] = (int)i * 10;           // write before reading
    }

    // 2. calloc: zeroed, and overflow-checked in the multiplication.
    int *zeros = calloc(4, sizeof *zeros);
    if (zeros == nullptr) {
        free(numbers);
        return EXIT_FAILURE;
    }

    // 3. A string copy on the heap.
    const char *source = "hello";
    char *copy = malloc(strlen(source) + 1);        // +1 for the NUL
    if (copy == nullptr) {
        free(numbers);
        free(zeros);
        return EXIT_FAILURE;
    }
    strcpy(copy, source);                           // the size was computed from source

    printf("%d %d %s\n", numbers[3], zeros[0], copy);

    free(copy);
    free(zeros);
    free(numbers);
    return 0;
}

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

struct IntVec {
    int *data;
    size_t count;
    size_t capacity;
};

static bool vec_push(struct IntVec *v, int value)
{
    if (v->count == v->capacity) {
        size_t new_capacity = (v->capacity == 0) ? 4 : v->capacity * 2;

        // Guard the multiplication before it reaches realloc.
        if (new_capacity > SIZE_MAX / sizeof *v->data) {
            return false;
        }

        // Assign to a TEMPORARY: if realloc fails it returns nullptr and the
        // original block is still valid -- overwriting v->data would leak it.
        int *grown = realloc(v->data, new_capacity * sizeof *v->data);
        if (grown == nullptr) {
            return false;
        }

        v->data = grown;
        v->capacity = new_capacity;
    }

    v->data[v->count++] = value;
    return true;
}

static void vec_free(struct IntVec *v)
{
    free(v->data);
    v->data = nullptr;              // leave the struct in a safe, reusable state
    v->count = 0;
    v->capacity = 0;
}

int main(void)
{
    struct IntVec v = { };          // C23 empty initializer: all members zero

    for (int i = 0; i < 10; ++i) {
        if (!vec_push(&v, i * i)) {
            vec_free(&v);
            return EXIT_FAILURE;
        }
    }

    printf("count=%zu capacity=%zu last=%d\n", v.count, v.capacity, v.data[v.count - 1]);
    vec_free(&v);
    return 0;
}

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

struct Widget {
    char *name;              // owned by this Widget
    int *values;             // owned by this Widget
    size_t value_count;
};

// Constructor: either fully succeeds, or allocates nothing and returns nullptr.
static struct Widget *widget_create(const char *name, size_t value_count)
{
    struct Widget *w = calloc(1, sizeof *w);            // zeroed: every pointer is null
    if (w == nullptr) {
        return nullptr;
    }

    w->name = malloc(strlen(name) + 1);
    if (w->name == nullptr) {
        goto fail;
    }
    strcpy(w->name, name);

    w->values = calloc(value_count, sizeof *w->values);
    if (w->values == nullptr) {
        goto fail;
    }
    w->value_count = value_count;

    return w;

fail:
    free(w->name);           // free(nullptr) is a no-op, so this is safe either way
    free(w);
    return nullptr;
}

// Destructor: accepts nullptr, frees members before the struct itself.
static void widget_destroy(struct Widget *w)
{
    if (w == nullptr) {
        return;
    }
    free(w->values);
    free(w->name);
    free(w);
}

int main(void)
{
    struct Widget *w = widget_create("gauge", 16);
    if (w == nullptr) {
        return EXIT_FAILURE;
    }

    w->values[0] = 42;
    widget_destroy(w);
    widget_destroy(nullptr);        // harmless
    return 0;
}

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

struct Matrix {
    size_t rows;
    size_t cols;
    double cells[];             // flexible array member: not counted by sizeof
};

static struct Matrix *matrix_create(size_t rows, size_t cols)
{
    if (rows != 0 && cols > SIZE_MAX / rows) {
        return nullptr;                                     // overflow guard
    }
    size_t cell_count = rows * cols;

    if (cell_count > (SIZE_MAX - sizeof(struct Matrix)) / sizeof(double)) {
        return nullptr;
    }

    struct Matrix *m = malloc(sizeof *m + cell_count * sizeof *m->cells);
    if (m == nullptr) {
        return nullptr;
    }

    m->rows = rows;
    m->cols = cols;
    for (size_t i = 0; i < cell_count; ++i) {
        m->cells[i] = 0.0;
    }
    return m;
}

static double *matrix_at(struct Matrix *m, size_t r, size_t c)
{
    return &m->cells[r * m->cols + c];      // row-major, computed by hand
}

int main(void)
{
    struct Matrix *m = matrix_create(3, 4);
    if (m == nullptr) {
        return EXIT_FAILURE;
    }

    *matrix_at(m, 2, 3) = 1.5;
    printf("%zux%zu, cell(2,3) = %g\n", m->rows, m->cols, *matrix_at(m, 2, 3));

    free(m);                    // one free for header and payload together
    return 0;
}

#include <stdlib.h>

int main(void)
{
    size_t n = 64;

    void *p = malloc(n);
    if (p == nullptr) {
        return EXIT_FAILURE;
    }

    free_sized(p, n);           // C23: the size must match the request exactly

    void *q = aligned_alloc(64, 128);
    if (q == nullptr) {
        return EXIT_FAILURE;
    }
    free_aligned_sized(q, 64, 128);

    return 0;
}

$ clang -std=c23 -Wall -Wextra -g -fsanitize=address,undefined -o app app.c
$ ./app
==12345==ERROR: AddressSanitizer: heap-use-after-free on address 0x502000000010
    #0 0x... in main app.c:14

$ valgrind --leak-check=full --show-leak-kinds=all ./app
==12346== HEAP SUMMARY:
==12346==     definitely lost: 40 bytes in 1 blocks
==12346==     indirectly lost: 16 bytes in 1 blocks
==12346==       possibly lost: 0 bytes in 0 blocks
==12346==     still reachable: 72 bytes in 3 blocks