C Standard Library stddef.h

What You’ll Learn

<stddef.h> is one of the smallest but most important C headers. It defines types and macros for sizes, pointer differences, null pointers, and structure layout—building blocks used by malloc, strlen, arrays, and almost every library function that deals with memory.

Definition and Usage

stddef.h provides portable names for concepts the compiler already understands: how big something is (size_t), how far apart two pointers are (ptrdiff_t), what “no object” means for a pointer (NULL), and where a field sits inside a struct (offsetof).

You rarely call functions from this header. Instead, you use its types and macros everywhere—especially with sizeof, dynamic memory, string lengths, and pointer arithmetic.

📝 Syntax

Include the header:

#include <stddef.h>

Types and macros defined in stddef.h

• size_t — unsigned integer type; result of sizeof and sizes for malloc, strlen, etc.
• ptrdiff_t — signed integer type; result of subtracting two pointers to the same array.
• wchar_t — integer type for wide characters (see also <wchar.h>).
• NULL — null pointer constant macro.
• offsetof(type, member) — byte offset of member within type.
• max_align_t — (C11) type with maximum alignment requirement.

Typical forms (implementation-defined details)

typedef /* implementation-defined */ size_t;
typedef /* implementation-defined */ ptrdiff_t;
typedef /* implementation-defined */ wchar_t;

#define NULL /* null pointer constant, often ((void *)0) or 0 */

#define offsetof(type, member) /* byte offset */

Common usage

size_t n = sizeof(int);
char *p = NULL;

if (p == NULL) {
    /* no valid object */
}

ptrdiff_t gap = &arr[5] - &arr[0];   /* same array only */

size_t off = offsetof(struct S, field);

Headers and linking

• #include <stddef.h> — types and macros only; no extra link flag.
• Print size_t with %zu in printf (C99+).
• Print ptrdiff_t with %td (C99+).

Examples Gallery

Compile with gcc file.c -std=c11 -o out. Structure sizes and offsets in Example 1 depend on platform alignment; output shown is typical on 64-bit GCC.

#include <stdio.h>
#include <stddef.h>

typedef struct {
    int id;
    char name[50];
    double salary;
} Employee;

int main(void) {
    Employee emp = { 1, "John Doe", 75000.0 };
    size_t total = sizeof(Employee);
    size_t off = offsetof(Employee, salary);

    (void)emp;
    printf("Size of Employee: %zu bytes\n", total);
    printf("Offset of salary: %zu bytes\n", off);
    printf("sizeof(int)=%zu, sizeof(double)=%zu\n",
           sizeof(int), sizeof(double));

    return 0;
}

Size of Employee: 64 bytes
Offset of salary: 56 bytes
sizeof(int)=4, sizeof(double)=8

#include <stdio.h>
#include <stddef.h>

void greet(const char *name) {
    if (name == NULL) {
        printf("No name provided.\n");
        return;
    }
    printf("Hello, %s!\n", name);
}

int main(void) {
    greet("Ada");
    greet(NULL);
    return 0;
}

Hello, Ada!
No name provided.

#include <stdio.h>
#include <stddef.h>

int main(void) {
    int data[] = { 10, 20, 30, 40, 50 };
    int *start = &data[0];
    int *end = &data[4];

    ptrdiff_t count = end - start;
    ptrdiff_t bytes = (char *)end - (char *)start;

    printf("Elements between start and end: %td\n", count);
    printf("Byte distance (char*): %td\n", bytes);

    return 0;
}

Elements between start and end: 4
Byte distance (char*): 16

#include <stdio.h>
#include <stddef.h>

int main(void) {
    int scores[] = { 88, 92, 75, 100 };
    size_t i;
    size_t n = sizeof(scores) / sizeof(scores[0]);
    size_t sum = 0;

    for (i = 0; i < n; i++) {
        sum += (size_t)scores[i];
    }

    printf("Count: %zu, Sum: %zu, Average: %.1f\n",
           n, sum, (double)sum / (double)n);

    return 0;
}

Count: 4, Sum: 355, Average: 88.8

#include <stdio.h>
#include <stddef.h>

int main(void) {
    wchar_t letter = L'A';
    char narrow = 'A';

    printf("sizeof(char)   = %zu\n", sizeof(char));
    printf("sizeof(wchar_t)= %zu\n", sizeof(wchar_t));
    printf("narrow value: %d\n", (int)narrow);
    printf("wide value:   %d\n", (int)letter);

    return 0;
}

sizeof(char)   = 1
sizeof(wchar_t)= 2 or 4 (platform-dependent)
narrow value: 65
wide value:   65

🚀 Common Use Cases

• Dynamic memory — malloc(n * sizeof(T)) returns void *; size argument is size_t.
• String lengths — strlen returns size_t.
• Array bounds — loop with size_t up to element count.
• Optional pointers — use NULL for “not set” or end-of-list sentinels.
• Binary protocols — offsetof documents field layout in structs.
• Iterator distance — ptrdiff_t for pointer subtraction in buffers.

📝 Notes

• size_t is unsigned—avoid comparing it to negative signed values without casting.
• Subtract pointers only within the same array object (C rule).
• offsetof on bit-fields is undefined; use only on normal members.
• Structure padding makes offsets platform-specific; do not hard-code magic numbers.
• NULL expands to an implementation-defined null pointer constant—commonly 0 or ((void *)0).
• C11 adds max_align_t to stddef.h for alignment queries.

⚡ Optimization

size_t and ptrdiff_t are typedefs—no runtime cost. offsetof is resolved at compile time. Choosing size_t for indices matching strlen or malloc sizes avoids extra casts and warnings. For micro-optimization of struct layout, reorder members to reduce padding, but prefer clarity unless profiling shows memory pressure.

💡 Best Practices