El puntero genérico: void * y el arte de borrar el tipo

C no tiene plantillas ni genéricos en el lenguaje, y sin embargo qsort ordena cualquier cosa. El truco cabe en un solo tipo: void *, la dirección desnuda, sin información de qué vive en ella. Escribir código genérico con él —y medir exactamente lo que cuesta— es el paso que separa a quien usa la librería estándar de quien podría haberla escrito.

El tipo sin tipo

Como tipo de retorno, void significa “nada”. Pero void * no es un puntero a nada: es una dirección de memoria sin tipo asociado. Guarda el dónde y olvida deliberadamente el qué.

C le concede un privilegio que ningún otro puntero tiene: cualquier puntero a objeto se convierte a void * y de vuelta sin cast explícito, y la norma garantiza que el viaje de ida y vuelta preserva el valor exacto.

int   n  = 42;
int  *pi = &n;
void *pv = pi;         // conversion implicita: legal y sin cast
int  *otra = pv;       // y de vuelta: otra == pi, garantizado

Esta conversión bidireccional implícita es exclusiva de C. En C++ el camino de vuelta exige un cast, y de ahí viene la costumbre —importada y equivocada— de castear el resultado de malloc.

Hay tres cosas que void * no puede hacer, y las tres por el mismo motivo: el compilador no conoce ni el tamaño ni la representación de lo apuntado.

void *p = malloc(16);
*p;              // ERROR: no se puede desreferenciar un tipo incompleto
p + 1;           // ERROR en C estandar: no hay aritmetica sobre void
sizeof(void);    // ERROR: void no tiene tamano

GCC y Clang admiten como extensión la aritmética sobre void * tratándolo como char *. Compila con -std=c23 -pedantic y desaparecerá el permiso: para recorrer bytes, el tipo correcto y portable es unsigned char *.

flowchart LR
I[int asterisco] -->|implicita| V[void asterisco]
D[double asterisco] -->|implicita| V
S[struct Nodo asterisco] -->|implicita| V
V -->|implicita de vuelta| I
V --> X[el compilador ya no sabe el tipo ni el tamano]
style V fill:#89b4fa,color:#11111b
style X fill:#f38ba8,color:#11111b

La receta genérica: base, tamaño y comparador

Mira la firma de qsort y verás toda la técnica condensada:

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

El array llega como dirección sin tipo (base), la cardinalidad como nmemb, y el tamaño de cada elemento viaja como dato en tiempo de ejecución (size). Esa es la pieza clave: size es la información de tipo que el sistema estático perdió, reinyectada como un número. Lo que el compilador ya no sabe, lo sabe el programador y lo pasa a mano.

El comparador reconstruye el tipo en su interior, en el único punto donde vuelve a conocerse:

static int cmp_int(const void *a, const void *b) {
    int x = *(const int *)a;
    int y = *(const int *)b;
    return (x > y) - (x < y);   // nunca restes: x - y puede desbordar
}

int v[] = { 5, 2, 9, 1 };
qsort(v, 4, sizeof v[0], cmp_int);

Con esa receta escribes tus propios genéricos. Aquí una búsqueda lineal con la misma forma que bsearch:

void *buscar(const void *clave, const void *base, size_t n, size_t tam,
             int (*cmp)(const void *, const void *)) {
    const unsigned char *p = base;          // unico tipo legal para avanzar
    for (size_t i = 0; i < n; i++) {
        const void *elem = p + i * tam;     // aritmetica en bytes
        if (cmp(clave, elem) == 0) return (void *)elem;
    }
    return nullptr;
}

Y un intercambio que sirve para cualquier tipo, moviendo bytes en bruto:

void intercambiar(void *a, void *b, size_t tam) {
    unsigned char *x = a, *y = b;
    for (size_t i = 0; i < tam; i++) {
        unsigned char t = x[i]; x[i] = y[i]; y[i] = t;
    }
}

Lo que cuesta perder el tipo

El genérico de C no es gratis, y un ingeniero serio conoce la factura. Son cinco cargos distintos.

Verificación cero. Nadie comprueba que el comparador que pasas corresponda al tipo del array. qsort(v, 4, sizeof(long), cmp_int) compila sin una queja y produce basura silenciosa. El contrato existe solo en tu cabeza y en la documentación.

Llamada indirecta por comparación. El comparador se invoca a través de un puntero, así que no hay inlining: cada comparación es un salto indirecto, un marco de pila y dos desreferencias. Ordenar un millón de int con qsort suele ser dos o tres veces más lento que una ordenación monomórfica que el compilador puede especializar.

Movimiento byte a byte. El intercambio genérico copia con un bucle de bytes; la versión tipada mueve una palabra en una instrucción.

Alineación. Convertir un void * a un tipo con requisito de alineación más estricto es comportamiento indefinido si la dirección no está alineada, aunque leerla parezca funcionar en x86.

Aliasing. Reinterpretar bytes a través de un puntero de otro tipo choca con la regla de aliasing estricto —la lección que viene a continuación.

Cuando el conjunto de tipos es cerrado y conocido en compilación, C23 ofrece la alternativa sin coste: _Generic despacha por tipo en tiempo de compilación, con verificación y sin indirección.

#define maximo(a, b) _Generic((a),  \
    int:    max_int,                \
    long:   max_long,               \
    double: max_double              \
)((a), (b))

Aquí no se borra nada: el compilador elige la función correcta, la puede inlinear y el error de tipo se detecta al compilar. void * para colecciones heterogéneas y librerías; _Generic y typeof para operaciones sobre un conjunto finito de tipos.