Learn C Language: A Comprehensive Guide to Different Types of Pointers

Different Types of Pointers in C

Understanding Pointer Variants

C provides several pointer categories that are useful in different contexts. Below are the common ones with succinct definitions and examples.

• Null pointer: A pointer that explicitly points to nothing. Use NULL (or 0 in C) to indicate absent addresses.
• Void pointer: void * can hold the address of any object type but must be cast before dereference.
• Function pointer: Holds the address of a function so you can call it indirectly.
• Const pointer variants: Either the pointer is constant (int * const p), the pointee is constant (const int *p), or both (const int * const p).
• Dangling pointer: A pointer that still refers to memory that has been freed or is out of scope; this must be avoided.

Example: function pointer declaration:

/* pointer to a function that takes int and returns void */
void (*funcPtr)(int);

Pointer Arithmetic: Navigating Memory Efficiently

How pointer arithmetic works

Pointer arithmetic moves in increments of the pointed-to type. Incrementing an int * advances by sizeof(int). This is predictable and useful for array traversal and manual memory layouts.

int arr[] = {1, 2, 3, 4};
int *ptr = arr;  /* same as &arr[0] */
ptr++;           /* now points to arr[1] */

For multi-dimensional arrays stored contiguously (C row-major), compute offsets using row length and column index. Be careful: pointer arithmetic cannot replace bounds checks — you must ensure indices are valid.

Pointers vs. Arrays: Clarifying Common Confusions

An array name (in most expressions) decays to a pointer to its first element, but arrays and pointers are distinct types at compile time. Arrays allocate contiguous storage automatically, while pointers can be used to reference dynamically allocated memory with greater flexibility.

Remember these rules:

• Array size is fixed when declared as a local array; dynamic allocation uses malloc/calloc.
• Passing an array to a function receives a pointer to its first element; the callee has no size information unless you pass it explicitly.

Function Pointers: Unlocking Dynamic Functionality

Use cases and example

Function pointers are useful for callbacks, tables of handlers (dispatch tables), and plugin-like architectures. Example: a small menu where handlers are stored in a table.

#include 

void handler_one(void) { puts("Handler one"); }
void handler_two(void) { puts("Handler two"); }

int main(void) {
    void (*handlers[])(void) = { handler_one, handler_two };
    for (size_t i = 0; i < sizeof(handlers)/sizeof(handlers[0]); ++i)
        handlers[i]();
    return 0;
}

Void, Const, and Dangling Pointers (Detailed)

Void pointers

void * is used to write generic APIs (e.g., qsort callback receives void *). Cast back to the correct type before dereferencing.

void print_int(void *p) {
    int *ip = (int *)p;
    printf("%d\n", *ip);
}

Const pointer variants

Different semantics:

• const int *p — the integer is const; you cannot modify *p.
• int * const p — the pointer itself is const; you cannot change p to point elsewhere, but *p can be modified.
• const int * const p — both the pointee and pointer are const.

const int val = 10;
const int *p1 = &val;     /* OK: pointee const */
int x = 5;
int * const p2 = &x;      /* OK: pointer const */

Dangling pointers

After free() or when a local variable goes out of scope, pointers that still reference that memory become dangling. Always set pointers to NULL immediately after freeing when appropriate and avoid returning addresses of stack-allocated objects.

int *make_bad_ptr(void) {
    int local = 42;
    return &local;  /* BAD: returning address of stack memory */
}

void example(void) {
    int *p = malloc(sizeof *p);
    if (!p) return;
    *p = 7;
    free(p);
    p = NULL; /* clear to avoid dangling use */
}

Dynamic Memory: malloc, calloc, realloc, free

Practical usage patterns

Always check the return value of allocation functions and use size_t for sizes. Avoid integer overflow when computing allocations.

#include 
#include 
#include 

void *xmalloc(size_t n) {
    if (n == 0) n = 1; /* keep semantics clear */
    void *p = malloc(n);
    if (!p) {
        /* deterministic behavior for failures */
        perror("malloc");
        exit(EXIT_FAILURE);
    }
    return p;
}

/* example: safe array allocation */
int *arr = xmalloc(n * sizeof(int));
/* use arr ... */
free(arr);

calloc zero-initializes: int *a = calloc(n, sizeof *a);. Prefer calloc when you need zeroed memory and want clear semantics.

realloc adjusts block size; on failure, the original pointer remains valid. Typical pattern:

void *tmp = realloc(ptr, new_size);
if (!tmp) {
    /* handle failure; ptr still valid */
} else {
    ptr = tmp;
}

Simple Linked List: Complete Example

A practical linked list demonstrates pointer allocation, traversal, and safe freeing. Compile with gcc -std=c11 -O2 -Wall.

#include 
#include 

typedef struct Node {
    int data;
    struct Node *next;
} Node;

Node *create_node(int value) {
    Node *n = malloc(sizeof *n);
    if (!n) return NULL;
    n->data = value;
    n->next = NULL;
    return n;
}

void push_front(Node **head, int value) {
    Node *n = create_node(value);
    if (!n) return; /* handle allocation failure in production code */
    n->next = *head;
    *head = n;
}

Node *find(Node *head, int value) {
    for (Node *cur = head; cur; cur = cur->next) {
        if (cur->data == value) return cur;
    }
    return NULL;
}

void free_list(Node *head) {
    while (head) {
        Node *tmp = head;
        head = head->next;
        free(tmp);
    }
}

int main(void) {
    Node *head = NULL;
    push_front(&head, 3);
    push_front(&head, 5);
    push_front(&head, 7);

    Node *found = find(head, 5);
    if (found) printf("Found: %d\n", found->data);

    free_list(head);
    return 0;
}

Simple Bump Allocator (Demonstration)

This tiny allocator is intended for short-lived allocations (e.g., temporary workspace). It is not suitable for general-purpose allocation because it does not free individual blocks; you can reset the entire pool.

#include 
#include 
#include 
#include 

#define POOL_SIZE (1024 * 1024) /* 1 MiB for demo */
static uint8_t pool[POOL_SIZE];
static size_t pool_off = 0;

void *bump_alloc(size_t n) {
    /* align to 8 bytes */
    const size_t align = 8;
    size_t aligned = (n + (align - 1)) & ~(align - 1);
    if (pool_off + aligned > POOL_SIZE) return NULL; /* out of memory */
    void *p = &pool[pool_off];
    pool_off += aligned;
    return p;
}

void bump_reset(void) { pool_off = 0; }

/* Usage note: do not free individual allocations; use bump_reset() to reclaim all. */

Security and correctness notes:

• Check for overflow when computing sizes.
• Consider thread-safety: add locks if used across threads.
• Do not use for long-lived allocations unless you manage pool lifetime.

Benchmarking & Troubleshooting

Measuring allocation cost

Use clock_gettime(CLOCK_MONOTONIC) or clock() to measure elapsed time for repeated allocations and frees. Example approach:

1. Run a warm-up phase to avoid measuring cold-start effects.
2. Measure multiple iterations and compute median/mean.
3. Use compiler optimizations (-O2 or -O3) when measuring realistic behavior.

Compile example programs with:

gcc -std=c11 -O2 -Wall example.c -o example

Debugging tools

• Use AddressSanitizer with Clang/GCC: add -fsanitize=address -g to detect use-after-free and buffer overflows.
• Use Valgrind for memory leak detection: see https://valgrind.org.

Troubleshooting checklist

• Check all malloc/calloc/realloc return values.
• Validate pointer arithmetic and index bounds.
• Set freed pointers to NULL where appropriate to reduce use-after-free risk.
• Run static analyzers and sanitizers during development and CI.

Best Practices & Common Pitfalls

Actionable recommendations

• Always initialize pointers before use.
• Prefer size_t for sizes and arithmetic involving allocation sizes.
• Guard against integer overflow when computing memory size: check n > SIZE_MAX / sizeof(type) before multiplying.
• Use const to document and enforce immutability of pointed-to data when appropriate.
• Encapsulate allocation/deallocation logic behind helper functions to centralize error handling.
• Employ sanitizers (-fsanitize=address) and tools like Valgrind during development.

Common pitfalls