Uma das formas de converter strings em números inteiros ou em ponto flutuante e vice-versa é utilizado as funções sscanf() e sprintf(). Consulte em livros e na Internet algumas funções da biblioteca stdlib.h que podem ser utilizadas com esse propósito. Quais são essas funções? Como elas são utilizadas?

Passo 1

O enunciado pede que eu consulte e apresente funções da biblioteca padrão C (arquivo de cabeçalho stdlib.h) que podem ser usadas para converter strings em números inteiros ou de ponto flutuante e vice‑versa. Você mencionou que já conhece sscanf() e sprintf() (essas duas vêm de stdio.h). Eu devo listar quais funções em stdlib.h servem para esse propósito e explicar como usá‑las, mostrando exemplos e cuidados (erros, detecção de conversão, bases etc.). As informações relevantes a partir do enunciado: preciso indicar funções de stdlib.h para conversão string → número e comentar sobre conversão número → string (observando que sprintf()/snprintf() vêm de stdio.h). Não há figura ou dado ausente.

Passo 2

Visão geral curta (sem resolver nada ainda): há duas famílias principais de funções em stdlib.h que fazem conversão de string para número:
  • As versões “simples” e antigas: atoi, atol, atoll, atof — fáceis de usar, mas sem boa verificação de erro.
  • As versões “robustas” recomendadas: strtol, strtoul, strtoll, strtoull, strtod, strtof, strtold — fornecem ponteiro para o resto da string (endptr) e sinalizam overflow/underflow via errno.
Para converter número → string, a função padrão portátil é snprintf()/sprintf() (essas são de stdio.h). Em algumas implementações existem itoa/ltoa mas elas não são padrão e não pertencem garantidamente a stdlib.h.

Passo 3

Explicando as funções simples (fáceis, sem checagem robusta). Prototypes (estes protótipos estão em stdlib.h):
\text{int atoi(const char *nptr);}
\text{long int atol(const char *nptr);}
\text{long long int atoll(const char *nptr);}
\text{double atof(const char *nptr);}
O que fazem (ideia):
  • Cada função analisa a string apontada por nptr, ignora espaços iniciais, aceita um sinal + ou - e lê dígitos até um caractere não numérico.
  • Retornam o valor convertido (int, long, long long, double).
  • Não há forma de distinguir erro de conversão (por exemplo, quando a string não começa com dígito) ou overflow: elas simplesmente retornam 0 (ou comportamento indefinido em alguns casos de overflow em implementações antigas). Por isso, hoje em dia recomenda‑se usar as funções strto* (a seguir) quando precisar de robustez.
Exemplo (conceitual):
  • Dada a string " -123abc":
    • atoi(" -123abc") retorna -123.
    • atof("3.14xyz") retorna 3.14.

Passo 4

Agora as funções robustas (recomendadas). Começando por inteiros:
Prototypes principais:
\text{long int strtol(const char *nptr, char **endptr, int base);}
\text{unsigned long int strtoul(const char *nptr, char **endptr, int base);}
\text{long long int strtoll(const char *nptr, char **endptr, int base);}
\text{unsigned long long int strtoull(const char *nptr, char **endptr, int base);}
Como funcionam (passo a passo):
  1. nptr aponta para a string que será convertida.
  2. endptr é um ponteiro para char* que, se não nulo, recebe o endereço do primeiro caractere na string que não foi usado na conversão. Isso permite detectar se houve conversão alguma. (Se você passar NULL em endptr, não recebe essa informação.)
  3. base especifica a base numérica: valores válidos são 2 a 36, ou 0. Se base for 0 a função deduz a base: prefixo "0x"/"0X" → base 16; prefixo "0" → base 8 (em algumas implementações antigas); caso contrário base 10.
  4. Em caso de sucesso retorna o valor convertido. Se nenhum dígito válido for encontrado, a função retorna 0 e, se endptr não for NULL, *endptr será igual a nptr (ou seja, nada foi convertido).
  5. Para detectar overflow/underflow, use errno (inclua <errno.h>). Se ocorrer overflow/underflow, a função retorna LONG_MAX, LONG_MIN (ou limites correspondentes) e errno é definido como ERANGE.
Exemplo completo e seguro (passo a passo):
  • Quisemos converter a string " -0x1fZ " para inteiro com detecção de erros.
    1. Inicialize errno = 0;.
    2. Chame char *end; long val = strtol(nptr, &end, 0);.
    3. Se end == nptr então não houve conversão (string não tinha dígitos).
    4. Se errno == ERANGE então ocorreu overflow/underflow.
    5. Se *end != '\0' e *end não for apenas espaços, tem caracteres extras após o número (pode ser erro dependendo do caso).
Observações sobre base:
  • Se você sabe que a string contém um número decimal, use base = 10.
  • Se quiser aceitar "0x" hex e "0" octal automática, passe base = 0.

Passo 5

Agora para ponto flutuante:
Prototypes:
\text{double strtod(const char *nptr, char **endptr);}
\text{float strtof(const char *nptr, char **endptr);}
\text{long double strtold(const char *nptr, char **endptr);}
Como funcionam:
  • Muito parecidas com strtol mas para números de ponto flutuante. Elas reconhecem notações como "3.14", "-2.5e6", "0.1E-3", etc.
  • endptr tem o mesmo papel: aponta para o primeiro caractere que não foi usado na conversão.
  • Em caso de overflow/underflow, errno é definido como ERANGE e o valor retornado será HUGE_VAL, HUGE_VALF ou HUGE_VALL (ou 0.0 em underflow), dependendo da função.
  • Se endptr aponta para nptr após a chamada, então nada foi convertido.
Exemplo:
  • Para converter " 6.022e23 test":
    • char *end; errno = 0; double x = strtod(nptr, &end);
    • Se end == nptr → falha de conversão.
    • Se errno == ERANGE → overflow/underflow.

Passo 6

Comparação prática entre as famílias e recomendações para prova:
  • atoi/atof etc.: rápidos e simples, mas não servem quando você precisa detectar erros (string inválida) ou quando a entrada pode causar overflow. Em provas, mencione que existe mas prefira as strto*/strt* para trabalho correto.
  • strtol/strtod etc.: são as funções “certas” para conversão segura: permitem checar se a conversão ocorreu e detectar overflow via errno. Sempre mostrar na prova que você inicializa errno = 0 antes e verifica após a chamada.

Passo 7

Exemplos concretos com passo a passo de como usar em código (explicados de forma que você possa reproduzir na prova):
Exemplo 1 — converter string para long com base automática e checagem:
  1. Código conceitual:
\text{errno = 0;}
\text{char *s = " -0x1fG";}
\text{char *end;}
\text{long v = strtol(s, \&end, 0);}
  1. Interpretação passo a passo:
  • strtol ignora espaços e lê -0x1f como hex → valor -31.
  • Após chamada: se end == s → nada convertido (não é o caso).
  • Se errno == ERANGE → overflow aconteceu.
  • Se *end é 'G' (não espaço) → há caracteres extras depois do número; talvez entrada inválida dependendo do contexto.
Exemplo 2 — converter string para double e verificar:
\text{errno = 0;}
\text{char *s = "3.14abc";}
\text{char *end;}
\text{double d = strtod(s, \&end);}
  • d recebe 3{,}14.
  • end aponta para "abc", logo a string tinha sufixo não numérico.
  • Se end == s então não houve conversão.
Exemplo 3 — conversão número → string (forma portátil e segura):
Use snprintf (vem de stdio.h):
Prototipo importante:
\text{int snprintf(char *str, size\_t size, const char *format, ...);}
Passo a passo:
  • Reserve um buffer char buf[32];.
  • Chame int n = snprintf(buf, sizeof(buf), "%d", valor);.
  • snprintf escreve no buffer com limite de tamanho e retorna número de caracteres que teria escrito (sem contar '\0'). Se n >= sizeof(buf) então houve truncamento.
  • Essa é a maneira padrão e segura de transformar números em strings em C.
Observação: sprintf escreve sem limite e pode causar overflow do buffer; prefira snprintf.

Passo 8

Erros comuns e dicas práticas para a prova (marque mentalmente):
  • Não use atoi/atof se você precisa detectar erro de entrada. Cite isso na prova.
  • Sempre use strto* com endptr para saber se a string inteira foi um número (compara *end com '\0' ou avança passando só espaços).
  • Sempre inicialize errno = 0; antes de chamar strto*/strt* e verifique errno == ERANGE depois para detectar overflow.
  • Para bases: lembre que strtol(..., base=0) detecta 0x e 0 prefixos; base=10 força decimal.
  • Para número → string, prefira snprintf. Evite itoa/ltoa porque não são padrão.

Resposta

atoi — converte string para int (simples, sem verificação de erro).
atol — converte string para long (simples, sem verificação de erro).
atoll — converte string para long long (simples, sem verificação de erro).
atof — converte string para double (simples, sem verificação de erro).
strtol — converte string para long com detecção de erros via endptr e errno; aceita parâmetro base.
strtoul — converte string para unsigned long com endptr/errno e base.
strtoll — converte string para long long com endptr/errno e base.
strtoull — converte string para unsigned long long com endptr/errno e base.
strtod — converte string para double com endptr/errno (reconhece notação exponencial).
strtof — converte string para float com endptr/errno.
strtold — converte string para long double com endptr/errno.
Para número → string: use snprintf/sprintf (preferir snprintf para evitar overflow); funções não padronizadas como itoa/ltoa existem em algumas implementações, mas não são parte garantida da biblioteca padrão.

Exercícios relacionados