Suponha que você precise representar os valores indicados nos itens abaixo em um programa escrito na Linguagem C. Indique o tipo de dado mais adequado para cada caso, explicando o porquê da escolha.
Temperaturas na escala Celsius de -90.0^{\circ} \mathrm{Ca}+180.0^{\circ} \mathrm{C} com exatidão de 0.5^{\circ} \mathrm{C}

Passo 1

O enunciado pede que eu escolha o tipo de dado em C mais adequado para representar temperaturas na escala Celsius no intervalo de -90,0^\circ C até +180,0^\circ C com exatidão de 0,5^\circ C.\n
Informações fornecidas:
  • intervalo mínimo: -90,0^\circ C\n
  • intervalo máximo: +180,0^\circ C\n
  • passo/precisão desejada: 0,5^\circ C\n
    Objetivo deste passo: deixar claro o que é pedido e quais dados tenho para decidir o tipo.

Passo 2

Vou transformar os requisitos em propriedades numéricas que orientam a escolha do tipo.\n
  1. Para trabalhar com precisão de 0,5^\circ C é útil pensar em uma escala inteira: multiplico as temperaturas por 2 para que o incremento de 0,5 vire incremento unitário. Assim defino a variável inteira auxiliar s tal que
s = 2 \times T,
onde T é a temperatura em graus Celsius.\n
2) Aplicando isso às extremidades do intervalo: para T=-90,0^\circ C e T=+180,0^\circ C obtenho
s_{\min} = 2\times(-90,0) = -180,
s_{\max} = 2\times(+180,0) = +360.
Portanto, na escala inteira preciso representar todos os valores inteiros de -180 até +360.\n
3) Contagem de valores distintos (opcional para intuição): há 360-(-180)+1 = 541 valores possíveis — isto é pequeno.

Passo 3

Agora identifico opções práticas em C e os critérios para escolher:
  • tipos inteiros com escala fixa (fixed-point): armazenar s como inteiro (por exemplo int16_t, int, short). Vantagens: representação exata dos passos de 0,5^\circ C, nenhuma imprecisão binária do ponto flutuante, comparações e incrementos exatos, geralmente menos memória e mais velocidade em sistemas embarcados.
  • ponto flutuante (float ou double): float tem 24 bits de mantissa (~7 decimal dígitos) e double tem 53 bits (~15 dígitos). Observação importante: o valor 0,5 é exatamente representável em ponto flutuante binário (é 1/2), e qualquer múltiplo inteiro de 0,5 também é exatamente representável quando o inteiro multiplicador é pequeno o bastante. Assim, armazenar valores como float ou double funcionaria sem perda exata para essa grade específica. Porém, operações aritméticas subsequentes podem introduzir pequenas imprecisões e o uso de ponto flutuante costuma ser mais custoso em termos de desempenho e memória em alguns ambientes.

Passo 4

Comparação prática e escolha do método:\n
  • Fixed-point (escala por 2) com inteiro traz exatidão total para a malha 0,5^\circ C e é mais simples para comparação, ordenação, armazenamento em formatos compactos e transmissão. Também evita dependência da aritmética de ponto flutuante.\n
  • Float/double: aceitáveis e simples de entender, e para este caso particular (passo 0,5) um float armazenará corretamente os valores exatos. Contudo, por robustez (por exemplo, se for necessário salvar, comparar ou fazer muitas operações inteiras) eu prefiro fixed-point.

Passo 5

Escolha do tamanho do inteiro (verificação de capacidade):\n
Preciso representar valores inteiros de s entre -180 e +360.\n
  • int16_t (tipo inteiro com sinal de 16 bits, definido em <stdint.h>) tem intervalo -32768 até +32767. Esse intervalo inclui confortavelmente -180 a +360.\n
  • int8_t (8 bits) tem intervalo -128 a +127 e seria insuficiente porque +360 não cabe.\n
  • Poderia usar int ou short, mas int16_t é explícito quanto ao tamanho e evita dependência de plataforma.\n
    Logo int16_t é suficiente e apropriado.

Passo 6

Como usar na prática (fórmulas e exemplos):\n
  • Para armazenar uma temperatura T em graus Celsius (multiplo de 0,5) faço
s = 2 \times T
e guardo s em uma variável do tipo int16_t.\n
  • Para recuperar o valor em graus (por exemplo para imprimir) uso
T = \frac{s}{2,0}
(observe que aqui divido por 2,0 para obter um valor em ponto flutuante na hora de mostrar).\n
Exemplos concretos:
  • T=-90,0^\circ C \Rightarrow s=2\times(-90)= -180 (cabe em int16_t)\n
  • T=-89,5^\circ C \Rightarrow s=2\times(-89,5)= -179\n
  • T=+180,0^\circ C \Rightarrow s=360\n
    Assim todas as temperaturas possíveis mapeiam para inteiros entre -180 e 360, armazenáveis sem perda em int16_t.\n
    Observação: se for necessário só armazenar e calcular com soma/subtração simples, essa abordagem evita qualquer erro de arredondamento.

Passo 7

Resumo dos prós e contras breves:\n
  • int16_t com escala por 2 (fixed-point): precisão exata na grade de 0,5^\circ C, menor uso de memória, operações inteiras exatas, portável quando usar <stdint.h>.\n
  • float: também representaria exatamente os valores discretos aqui, mas traz possíveis pequenas imprecisões em operações e custo maior em alguns sistemas; aceitável se você preferir manipular temperaturas diretamente como números reais, mas menos robusto para comparações exatas.

Resposta

int16_t

Exercícios relacionados