Why C’s void* Pointer Is the Secret to Generic Programming

Why void* matters in C

C’s strong, static type system guarantees safety but forces developers to write separate code for each data type. The void* pointer provides a way to bypass this restriction, acting as a universal type that can hold the address of any object.

Generic programming with void*

Functions like the standard library’s qsort() achieve “write once, use everywhere” by accepting void* arguments for the data array and the comparison callback. This lets the same sorting routine handle integers, floats, or user‑defined structs.

void qsort(void *base, size_t nmemb, size_t size,
          int (*compar)(const void *, const void *));

base

– pointer to the first element of any array type. compar – comparison function that receives two void* pointers to elements of any type.

Example usage for sorting an integer array:

// integer comparison function
int compare_ints(const void *a, const void *b) {
    return (*(int *)a) - (*(int *)b);
}

int arr[] = {5, 2, 8, 1, 3};
qsort(arr, 5, sizeof(int), compare_ints);

Memory manipulation abstraction

Low‑level system code often needs to allocate or copy raw memory without caring about the stored type. Functions such as malloc(), memcpy(), and memset() all use void* to treat memory as an untyped byte sequence.

void *malloc(size_t size);
void *memcpy(void *dest, const void *src, size_t n);
void *memset(void *s, int c, size_t n);

Interface design glue

In modular programming, void* is ideal for generic callbacks and thread arguments. For instance, pthread_create() takes a void *arg that can point to any user‑defined data structure, allowing the thread routine to interpret it as needed.

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                  void *(*start_routine)(void *), void *arg);

void *thread_function(void *arg) {
    struct thread_data *my_data = (struct thread_data *)arg;
    // use my_data ...
    return NULL;
}

struct thread_data data = { /* ... */ };
pthread_create(&thread, NULL, thread_function, &data);

Costs of using void*

The flexibility of void* comes at the expense of type safety. Misinterpreting the pointed‑to type can cause memory corruption, crashes, or undefined behavior.

// dangerous example
void *data = malloc(sizeof(int));
*(double *)data = 3.14; // type mismatch – may corrupt memory

Overusing void* also harms readability; code becomes a “black box” that is hard to understand and maintain.

void process_data(void *data, int type) {
    // decide actual type based on 'type'
    switch (type) {
        case 1: /* handle int */ break;
        case 2: /* handle float */ break;
        // ...
    }
}

C language philosophy

The pervasive use of void* reflects C’s design philosophy: the language assumes programmers know what they are doing and gives them full control, even if that means sacrificing safety. Modern languages provide safer generic mechanisms, but void* remains indispensable in low‑level system code.