strtol, strtoll

long      strtol( const char*          str, char**          str_end, int base );

long      strtol( const char* restrict str, char** restrict str_end, int base );

long long strtoll( const char* restrict str, char** restrict str_end, int base );

Interpreta un valor entero en una cadena de bytes apuntada por str.

Descarta cualquier carácter de espacio en blanco (identificado mediante la llamada a isspace) hasta que se encuentra el primer carácter que no es espacio en blanco, luego toma tantos caracteres como sea posible para formar una representación numérica entera válida base-n (donde n=base) y los convierte a un valor entero. El valor entero válido consta de las siguientes partes:

• (opcional) signo más o menos
• (opcional) prefijo (0) que indica base octal (se aplica solo cuando la base es 8 o 0)
• (opcional) prefijo (0x o 0X) que indica base hexadecimal (se aplica solo cuando la base es 16 o 0)
• una secuencia de dígitos

El conjunto de valores válidos para base es {0, 2, 3, ..., 36}. El conjunto de dígitos válidos para enteros en base-2 es {0, 1}, para enteros en base-3 es {0, 1, 2}, y así sucesivamente. Para bases mayores que 10, los dígitos válidos incluyen caracteres alfabéticos, comenzando desde Aa para un entero en base-11, hasta Zz para un entero en base-36. Se ignora el caso de los caracteres.

El locale C instalado actualmente puede aceptar formatos numéricos adicionales.

Si el valor de base es 0, la base numérica se detecta automáticamente: si el prefijo es 0, la base es octal; si el prefijo es 0x o 0X, la base es hexadecimal; de lo contrario, la base es decimal.

Si el signo menos formó parte de la secuencia de entrada, el valor numérico calculado a partir de la secuencia de dígitos se niega como si se aplicara un menos unario en el tipo de resultado.

Las funciones establecen el puntero apuntado por str_end para que apunte al carácter posterior al último carácter numérico interpretado. Si str_end es un puntero nulo, se ignora.

Si la str está vacía o no tiene la forma esperada, no se realiza ninguna conversión y (si str_end no es un puntero nulo) el valor de str se almacena en el objeto apuntado por str_end.

Parámetros

Valor de retorno

• Si tiene éxito, se devuelve un valor entero correspondiente al contenido de str.
• Si el valor convertido queda fuera del rango del tipo de retorno correspondiente, se produce un error de rango (estableciendo errno a ERANGE) y se devuelve LONG_MAX, LONG_MIN, LLONG_MAX o LLONG_MIN (según el signo del valor y el tipo de retorno).
• Si no se puede realizar ninguna conversión, se devuelve 0.

Ejemplo

#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
    // parsing with error handling
    const char* p = "10 200000000000000000000000000000 30 -40 junk";
    printf("Parsing '%s':\n", p);

    for (;;)
    {
        // errno can be set to any non-zero value by a library function call
        // regardless of whether there was an error, so it needs to be cleared
        // in order to check the error set by strtol
        errno = 0;
        char* end;
        const long i = strtol(p, &end, 10);
        if (p == end)
            break;
 
        const bool range_error = errno == ERANGE;
        printf("Extracted '%.*s', strtol returned %ld.", (int)(end-p), p, i);
        p = end;
 
        if (range_error)
            printf("\n --> Range error occurred.");
 
        putchar('\n');
    }
    
    printf("Unextracted leftover: '%s'\n\n", p);
 
    // parsing without error handling
    printf("\"1010\" in binary  --> %ld\n", strtol("1010", NULL, 2));
    printf("\"12\"   in octal   --> %ld\n", strtol("12",   NULL, 8));
    printf("\"A\"    in hex     --> %ld\n", strtol("A",    NULL, 16));
    printf("\"junk\" in base-36 --> %ld\n", strtol("junk", NULL, 36));
    printf("\"012\"  in auto-detected base --> %ld\n", strtol("012",  NULL, 0));
    printf("\"0xA\"  in auto-detected base --> %ld\n", strtol("0xA",  NULL, 0));
    printf("\"junk\" in auto-detected base --> %ld\n", strtol("junk", NULL, 0));
}

Parsing '10 200000000000000000000000000000 30 -40 junk':
Extracted '10', strtol returned 10.
Extracted ' 200000000000000000000000000000', strtol returned 9223372036854775807.
 --> Range error occurred.
Extracted ' 30', strtol returned 30.
Extracted ' -40', strtol returned -40.
Unextracted leftover: ' junk'

"1010" in binary  --> 10
"12"   in octal   --> 10
"A"    in hex     --> 10
"junk" in base-36 --> 926192
"012"  in auto-detected base --> 10
"0xA"  in auto-detected base --> 10
"junk" in auto-detected base --> 0

Referencias

Véase también