En C, la palabra “string” es una convención, no un tipo de dato nativo. A diferencia de lenguajes como Python o Java, donde las cadenas son objetos complejos con una longitud intrínseca, en C una cadena es simplemente un array de tipo char que termina con un byte especial llamado carácter nulo ('\0', cuyo valor numérico es 0).

Esta decisión de diseño permite que el lenguaje sea extremadamente simple y eficiente; el compilador no necesita gestionar metadatos ocultos para cada texto, solo necesita una regla: “lee bytes hasta que encuentres un cero”. Por ello, siempre que necesites manejar texto en C, deberás gestionar tú mismo ese byte final. Si intentas trabajar con texto sin considerar este terminador, el programa seguirá leyendo direcciones de memoria adyacentes buscando un cero, lo que provocará que leas basura de la memoria o que el programa colapse con un error de segmentación.

Existen dos formas principales de crear estas secuencias. La primera es mediante literales de cadena, como "Hola". Cuando escribes esto, el compilador reserva espacio en una sección de memoria de solo lectura (segmento de datos) y guarda los caracteres más el \0. Por eso, si intentas modificar un literal directamente, el programa fallará. La segunda es mediante arrays de caracteres, donde el compilador reserva espacio en la pila (stack) y copia los caracteres allí; esto te permite modificar el contenido libremente.

Ejemplo de gestión de cadenas

#include <stdio.h>
#include <string.h>

int main(void) {
    // 1. Literal de cadena: apunta a memoria de solo lectura.
    // No puedes hacer mensaje_const[0] = 'X'; porque daría error de ejecución.
    const char *mensaje_const = "Hola, mundo";

    // 2. Array de caracteres: copia el contenido en la pila (stack).
    // Es mutable: puedes cambiar sus letras.
    char mensaje_mutable[] = "Programar en C";

    // 3. Concatenación en tiempo de compilación:
    // El preprocesador une estos dos literales en uno solo.
    char frase[] = "Hola, " "amigo";

    // 4. Strings vacíos: 
    // Tienen longitud 0, pero necesitan 1 byte para el '\0'.
    char vacia[] = "";

    printf("Constante: %s\n", mensaje_const);
    printf("Mutable:   %s\n", mensaje_mutable);
    printf("Frase:    %s\n", frase);
    printf("Vacia:    '%s'\n", vacia);

    // La función strlen [estándar C] cuenta caracteres hasta el '\0',
    // pero NO incluye el '\0' en el conteo.
    size_t longitud = strlen(mensaje_mutable);

    printf("\nAnálisis de '%s':\n", mensaje_mutable);
    printf("  Longitud (strlen): %zu\n", longitud);
    printf("  Espacio real ocupado (bytes): %zu\n", longitud + 1);

    // Modificación segura en el array
    mensaje_mutable[0] = 'p'; 
    printf("Modificado: %s\n", mensaje_mutable);

    return 0;
}

Desglose del código

En el ejemplo, observa la diferencia crítica entre mensaje_const y mensaje_mutable. mensaje_const es un puntero que apunta a una dirección de memoria donde el sistema operativo ha marcado el área como “read-only”. Si intentaras cambiar la ‘H’ por una ‘X’, el procesador dispararía una excepción de protección de memoria. En cambio, mensaje_mutable reserva un bloque de memoria en la pila del proceso; el compilador calcula automáticamente que necesita 14 bytes (13 letras + el \0 implícito) y te permite alterarlos.

Al usar strlen(mensaje_mutable), la función recorre la memoria byte a byte comparando cada valor. Cuando llega a la posición donde está el \0, se detiene y devuelve el número de pasos realizados. Por eso, siempre que declares un array para guardar una cadena que vas a recibir (por ejemplo, con scanf), debes asegurarte de que el tamaño del array sea al menos strlen(input) + 1.

Finalmente, fíjate en la variable frase. Al escribir "Hola, " "amigo", sin comas ni operadores, le estás indicando al compilador que los trate como una única entidad. Esto es una optimización de compilación muy útil para evitar líneas de código excesivamente largas.

El error frecuente

El error más clásico para un principiante es olvidar el espacio para el terminador nulo al declarar un buffer.

// ERROR CRÍTICO: El buffer es demasiado pequeño
char buffer[5] = "Hola"; 
// Esto funciona porque "Hola" son 4 chars + '\0' = 5 bytes.

char buffer_corto[4] = "Hola"; 
// ERROR: "Hola" requiere 5 bytes. Al no caber el '\0', 
// la memoria queda "abierta".

Si intentas usar printf("%s", buffer_corto) en este segundo caso, la función no encontrará un cero después de la ‘a’. Seguirá leyendo la memoria de tu programa (la variable de al lado, la dirección de retorno de la función, etc.) hasta que encuentre un byte con valor cero por pura casualidad. Esto es comportamiento indefinido (Undefined Behavior): puede que tu programa parezca funcionar hoy, pero fallará mañana o será vulnerable a ataques de desbordamiento de búfer. Herramientas como AddressSanitizer (-fsanitize=address) detectarán esto de inmediato al ejecutar el código.

Recuerda siempre: en C, el tamaño del contenedor es la longitud del texto más uno.

N° 56