Cadenas en C

C no tiene un tipo cadena. Tiene una convención: una secuencia de char que termina cuando aparece un byte cero. Esa decisión, tomada para ahorrar un par de bytes por objeto en máquinas con kilobytes de memoria, definió la ergonomía y la seguridad del software durante medio siglo. Todo lo demás se deduce de ella: que averiguar la longitud sea una operación lineal, que ninguna función pueda comprobar si cabe lo que va a escribir, que un solo byte perdido convierta una cadena en un recorrido sin final por la memoria del proceso. Entender esta convención a fondo es entender por qué las cadenas de C no son un tipo, sino un contrato que nadie vigila.

El terminador nulo como estructura de datos

Una cadena en C es un array de char con una invariante añadida: en algún punto de él hay un byte de valor cero, y ese byte marca el final. La longitud no se guarda en ninguna parte; se descubre recorriendo.

char saludo[] = "Hola";
/* en memoria: 'H' 'o' 'l' 'a' '\0'  ->  5 bytes, longitud 4 */

sizeof saludo;      /* 5: el array completo, con el terminador */
strlen(saludo);     /* 4: caracteres hasta el cero, sin contarlo */

Esa diferencia de uno entre capacidad y longitud es el error clásico. Un buffer de n bytes almacena como mucho n - 1 caracteres útiles, porque el terminador ocupa sitio. Cada vez que reserves espacio para texto, el + 1 debe estar escrito y justificado.

El coste de strlen

strlen no puede hacer nada inteligente: recorre byte a byte hasta encontrar el cero. Es Θ de n, con n la longitud de la cadena, y no existe implementación que mejore esa cota, por muy vectorizada que esté.

size_t mi_strlen(const char *s) {
    const char *p = s;
    while (*p) p++;        /* recorre hasta el terminador */
    return (size_t)(p - s);
}

Las implementaciones reales de la libc leen palabras completas de 8 o 16 bytes y detectan el cero con trucos de manipulación de bits o con instrucciones SIMD, pero eso solo reduce la constante: sigue tocando toda la cadena. Y aquí aparece el patrón patológico:

/* Cuadratico: strlen se reevalua en cada iteracion */
for (size_t i = 0; i < strlen(s); i++)
    procesar(s[i]);

/* Lineal: la longitud se calcula una sola vez */
size_t n = strlen(s);
for (size_t i = 0; i < n; i++)
    procesar(s[i]);

Joel Spolsky bautizó el primer caso como el algoritmo del pintor Schlemiel: el pintor que vuelve al bote de pintura tras cada brochazo, y cada vez camina más. La versión más costosa del mismo error es concatenar en bucle con strcat, que recorre el destino entero para localizar su final antes de cada añadido: construir una cadena de un megabyte a base de trozos pequeños puede pasar de milisegundos a minutos.

flowchart TD
A[Cadena de C] --> B[La longitud no se guarda]
B --> C[Hay que recorrer hasta el byte cero]
C --> D[strlen cuesta lineal en la longitud]
D --> E[strlen dentro de la condicion del bucle]
E --> F[Coste cuadratico]
D --> G[strlen una vez fuera del bucle]
G --> H[Coste lineal]
C --> I[Si falta el terminador se lee memoria ajena]
style H fill:#a6e3a1,color:#11111b
style I fill:#f38ba8,color:#11111b

Dónde vive cada cadena

Tres orígenes con propiedades radicalmente distintas, y confundirlos es la segunda familia de bugs más común:

const char *malo(void) {
    char local[] = "temporal";
    return local;          /* puntero colgante: el array muere aqui */
}

const char *bueno(void) {
    return "temporal";     /* literal estatico: sobrevive al retorno */
}

Los modos de fallo estructurales

Casi todos los fallos con cadenas se reducen a cuatro violaciones de invariante, y conviene saberlos nombrar:

char d[8];

strcpy(d, "una cadena mucho mas larga");  /* 1. Escritura fuera de limites */

char sin_cero[4] = {'a','b','c','d'};
strlen(sin_cero);                          /* 2. Lectura fuera de limites   */

char *p = malloc(8);
strncpy(p, origen, 8);                     /* 3. Truncado sin terminador    */
printf(p);                                 /* 4. Cadena de formato ajena    */

El primero corrompe la pila o el montón y es la base histórica de la ejecución de código arbitraria. El segundo lee hasta encontrar un cero por casualidad y puede filtrar memoria contigua, como hizo Heartbleed. El tercero es el regalo envenenado de strncpy, que no termina el destino si el origen llena el buffer exacto. El cuarto convierte datos en instrucciones para printf y permite leer y hasta escribir memoria con %n.

Hay un quinto modo, más sutil, que aparece en cuanto el texto viene de fuera: el cero incrustado. Si un atacante mete un byte nulo en mitad de una entrada, todo el código que trate esa entrada como cadena verá una versión truncada, mientras que el código que la trate como bloque de bytes con longitud verá el original completo. Esa discrepancia entre dos capas que validan cosas distintas ha producido bypasses de validación de rutas y de certificados durante años.

/* Para datos que pueden contener ceros, la cadena no es la abstraccion correcta */
void *memchr(const void *s, int c, size_t n);   /* busca acotado por longitud */
int   memcmp(const void *a, const void *b, size_t n);

La regla práctica: si el dato viene de la red, de un fichero o del usuario, trátalo como buffer con longitud hasta que hayas validado explícitamente que no contiene ceros y que puede ascender a cadena.