malloc, sizeof and the allocation idiom that scales

Understanding malloc, sizeof and the allocation idiom that scales

malloc has exactly one input: a count of bytes. It does not know what you intend to store there, which is why its result type is void * — the address of a block of raw storage with no type attached to it. Since C gives you no way to say "room for four struct point objects", you convert objects to bytes yourself, and sizeof is the only portable way to do that conversion, because the byte count of a struct point is not a number you can hard-code across compilers and platforms.

sizeof is an operator, not a function, and apart from variable-length array types it is resolved entirely at compile time. Its operand is not evaluated, so sizeof *pts asks how large the type pts points to is, without ever reading through pts. That is why the expression is legal and harmless while pts is still uninitialized or NULL, which is precisely its state on the line where you call malloc. The result has type size_t, so print it with %zu rather than %d.

The reason to write n * sizeof *pts instead of n * sizeof(struct point) is maintenance, not keystrokes. The first form derives the size from the destination, so if the declaration later becomes struct point3d *pts, the request grows with it. The second form names the type a second time, and because malloc takes a plain number and returns void *, no compiler can notice when that second name goes stale: long *v = malloc(n * sizeof(int)); compiles without one diagnostic and hands you a block half the size you needed. For the same reason, leave malloc's result uncast — a cast is a third place to repeat the type.

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

struct point { double x, y; };

int main(void)
{
    size_t n = 4;
    struct point *pts = malloc(n * sizeof *pts);   /* bytes, not objects */

    if (pts == NULL) {
        fprintf(stderr, "out of memory\n");
        return 1;
    }

    for (size_t i = 0; i < n; i++) {
        pts[i].x = (double)i;
        pts[i].y = (double)i * 2.0;
    }

    printf("sizeof *pts = %zu\n", sizeof *pts);
    printf("request bytes = %zu\n", n * sizeof *pts);
    printf("pts[3] = (%.1f, %.1f)\n", pts[3].x, pts[3].y);

    /* sizeof does not evaluate its operand, so this never dereferences */
    struct point *never = NULL;
    printf("never == NULL: %d, sizeof *never = %zu\n",
           never == NULL, sizeof *never);

    free(pts);
    return 0;
}

Worked examples

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

int main(void)
{
    int arr[10];
    int *heap = malloc(10 * sizeof *heap);

    if (heap == NULL)
        return 1;

    printf("sizeof arr = %zu\n", sizeof arr);
    printf("elements in arr = %zu\n", sizeof arr / sizeof arr[0]);
    printf("sizeof heap = %zu\n", sizeof heap);
    printf("sizeof *heap = %zu\n", sizeof *heap);

    free(heap);
    return 0;
}

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

static char *copy_str(const char *src)
{
    size_t len = strlen(src);
    char *copy = malloc(len + 1);   /* sizeof *copy is 1 */

    if (copy == NULL)
        return NULL;

    memcpy(copy, src, len + 1);
    return copy;
}

int main(void)
{
    char *c = copy_str("malloc");

    if (c == NULL)
        return 1;

    printf("copy = %s, bytes requested = %zu\n", c, strlen(c) + 1);
    printf("sizeof *c = %zu\n", sizeof *c);

    free(c);
    return 0;
}

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

struct vec {
    size_t len;
    int *data;
};

int main(void)
{
    struct vec *v = malloc(sizeof *v);   /* one object: no multiply */

    if (v == NULL)
        return 1;

    v->len = 5;
    v->data = malloc(v->len * sizeof *v->data);
    if (v->data == NULL) {
        free(v);
        return 1;
    }

    for (size_t i = 0; i < v->len; i++)
        v->data[i] = (int)(i * i);

    printf("len=%zu data[4]=%d\n", v->len, v->data[4]);
    printf("header bytes=%zu element bytes=%zu\n",
           sizeof *v, v->len * sizeof *v->data);

    free(v->data);
    free(v);
    return 0;
}

Important notes

Common mistakes

Try it yourself