Conversión robusta de strings a números en C

En C, convertir una cadena de caracteres en un valor numérico parece una tarea trivial, pero la implementación puede determinar si tu programa es robusto o un colapso de errores silenciosos. La función atoi (ASCII to Integer) es la forma más simple de hacerlo, pero es extremadamente peligrosa en entornos de producción. El problema radica en su falta de diagnóstico: atoi no puede distinguir entre el valor numérico cero ("0") y una cadena que no contiene números válidos ("abc"), y si el valor en el string excede los límites de un int, el resultado es un comportamiento indefinido (UB).

Para manejar datos de forma profesional, la familia de funciones strtoX (como strtol para long o strtod para double) es el estándar. Estas funciones operan bajo un mecanismo de estado: requieren que resetees errno antes de la llamada, devuelven un puntero (endptr) que indica dónde se detuvo la conversión, y modifican errno si ocurre un desbordamiento de rango (ERANGE). Debes usar este patrón siempre que proceses datos provenientes de archivos, redes o entrada de usuario. Si utilizas atoi para parsear configuraciones o paquetes de red, tu programa podría continuar ejecutándose con valores basura tras un desbordamiento, lo cual es un vector crítico de seguridad y fallos de lógica.

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <limits.h>
#include <string.h>
#include <stdbool.h>

/* 
 * Intenta parsear un string a un entero largo de forma segura.
 * Retorna true si la conversión fue exitosa y completa.
 */
bool parse_long_safe(const char *str, long *out_value) {
    char *endptr;
    errno = 0; // Es imperativo resetear errno antes de la llamada

    long val = strtol(str, &endptr, 10);

    // 1. Verificar si hubo desbordamiento (ERANGE)
    // Si errno es ERANGE, la función ya asignó LONG_MAX o LONG_MIN a 'val'
    if (errno == ERANGE) {
        return false;
    }

    // 2. Verificar si el puntero de parada es el mismo que el inicio (no hubo conversión)
    if (endptr == str) {
        return false;
    }

    // 3. Verificar si hay caracteres residuales (ej: "123abc")
    // En parsing estricto, si el final no es el fin de la cadena, es un error.
    if (*endptr != '\0') {
        return false;
    }

    *out_value = val;
    return true;
}

int main(void) {
    // Casos de prueba: éxito, basura, desbordamiento, y contenido parcial
    const char *test_cases[] = {
        "42",           // Éxito
        "  -123",       // Espacios permitidos al inicio
        "9999999999999999999999", // Desbordamiento
        "abc",          // Sin números
        "12.5",         // Contiene basura para un entero (el punto)
        "0",            // Valor cero real
        ""              // String vacío
    };
    const int num_tests = sizeof(test_cases) / sizeof(test_cases[0]);

    printf("%-25s | %-10s | %-10s\n", "Input", "Resultado", "Valor");
    printf("----------------------------------------------------------\n");

    for (int i = 0; i < num_tests; i++) {
        long value = 0;
        bool success = parse_long_safe(test_cases[i], &value);

        if (success) {
            printf("%-25s | %-10s | %ld\n", test_cases[i], "OK", value);
        } else {
            printf("%-25s | %-10s | %-10s\n", test_cases[i], "ERROR", "N/A");
        }
    }

    // Conversión inversa: de número a string de forma segura
    long numero_original = 1337;
    char buffer[32];
    // snprintf es preferible sobre sprintf por evitar desbordamientos de buffer
    int written = snprintf(buffer, sizeof(buffer), "%ld", numero_original);

    if (written > 0 && written < (int)sizeof(buffer)) {
        printf("\nConversión inversa: %ld -> \"%s\"\n", numero_original, buffer);
    }

    return 0;
}

Desglose del código

En la función parse_long_safe, el primer paso crítico es errno = 0;. Como errno es una variable global (o thread-local), su estado puede haber sido modificado por cualquier función anterior. Si no lo reseteamos, una llamada exitosa a strtol podría dejar un residuo de un error anterior, llevándonos a conclusiones falsas.

El uso de endptr es lo que realmente separa a un programador junior de uno experimentado. Al recibir strtol, el puntero endptr se actualiza para apuntar al primer carácter que no es parte del número convertido. En el caso del test "12.5", endptr apuntará al carácter . . Al verificar if (*endptr != '\0'), estamos implementando una validación estricta que rechaza strings que no sean puramente numéricos, algo que atoi ignoraría silenciosamente.

Finalmente, para la conversión inversa, hemos evitado el uso de itoa (que no forma parte del estándar ISO C) y hemos optado por snprintf. Al especificar sizeof(buffer), garantizamos que nunca escribiremos fuera de los límites de la memoria, protegiendo la integridad del stack.

El error frecuente

El error más común es confiar en atoi para procesar datos externos. Observa este escenario:

int main() {
    char *input_user = "error_en_input";
    int valor = atoi(input_user);
    // Si el usuario escribe "0" o "no_es_numero", 'valor' será 0.
    // No hay forma de saber si el usuario quería el número 0 o si falló el parseo.
}

Si input_user es "9999999999999999999999", atoi simplemente devolverá un valor errático debido al desbordamiento, lo que puede causar un comportamiento indefinido en la lógica de tu aplicación. Un análisis con AddressSanitizer no siempre detectará esto como un error de memoria, pero UBSan (Undefined Behavior Sanitizer) te alertará sobre el desbordamiento aritmético.

Tratar la entrada de datos como potencialmente corrupta es la base de un código de sistema robusto.

N° 59