ao atribuir um valor a uma variavel ela se converte de acordo ? [RESOLVIDO]

1. ao atribuir um valor a uma variavel ela se converte de acordo ? [RESOLVIDO]

alberto roberto
adminbuster

(usa Gentoo)

Enviado em 05/08/2022 - 19:23h

test2 = (5 / 9) * (test1 - 32); <-- ambos test1 e test2 são float
printf("\n%.0f\t%.1f", test1, test2); <-- alguma valor na conta acima deve ser racional se não o test2 vira só em 0

o numero não deveria se convertido para flaot já que a variavel test2 é ?


  


2. MELHOR RESPOSTA

Paulo
paulo1205

(usa Ubuntu)

Enviado em 06/08/2022 - 01:13h

Sempre que você tem uma operação aritmética em que um dos operandos tem precisão menor que a do outro, o de menor precisão é promovido para o tipo do de maior precisão.

Contudo, olhe a sua expressão.
(5/9)*(temp1-32) 


Você tem três operações, a saber:

    • 5/9, cujos dois operandos, 5 e 9 são inteiros, de modo que a divisão é completamente inteira, produzindo um quociente inteiro igual a 0, e gerando um valor temporário inteiro que eu vou chamar de t1;

    • temp1-32, que tem um operando float (temp1) e outro int (32), implicando uma promoção do valor inteiro para float antes de realizar a subtração, que gera um valor temporário de ponto flutuante que eu vou chamar de t2;

    • t1*t2, na qual um dos operandos é inteiro e o outro é de ponto flutuante, implicando a conversão do primeiro para ponto flutuante, para então realizar a multiplicação, produzindo o valor final da expressão.


Note que:

    • 5/9 é uma operação com dois operandos constantes, então o compilador normalmente vai calcular o valor dessa expressão em tempo de compilação, de modo que essa divisão provavelmente não será observável no código objeto, já compilado.

    • Mais ainda, como o valor resultante da divisão é 0, nos nossos PCs com processadores Intel e AMD, em vez de guardar esse valor na memória e depois carregá-lo para algum registrador, é tipicamente mais vantajoso emitir diretamente código que zera o valor de um registrador (por exemplo, fazendo um XOR do registrador consigo mesmo). Além disso, como o compilador vai inferir que o valor constante vai ser convertido para ponto flutuante, pode já emitir código que produz o valor zero já em ponto flutuante, sem passar pelas etapas de produzir primeiro um zero inteiro, e depois o converter.

    • De modo semelhante, a constante 32 nunca é usada como inteiro antes de precisar ser convertida para ponto flutuante, de modo que o compilador pode optar por armazená-la no código compilado já convertida para ponto flutuante, assim evitando a etapa de conversão de tipo de dado durante a execução.

    • Você provavelmente só vai conseguir observar que existe uma subtração e uma multiplicação se compilar o programa sem nenhuma otimização. Se ligar otimizações, é possível que o compilador identifique uma multiplicação com um dos fatores iguais a zero, e já decida simplesmente substituir toda a expressão por um valor de ponto flutuante nulo.

    • Você pode evitar todas as conversões de tipo — e, mais do que isso, um resultado nulo para uma fração própria quando expressa com numerador e denominador inteiros — se tomar o cuidado de já colocar suas constantes como ponto flutuante, tal como mostra o exemplo abaixo.
float temp_celsius, temp_farenheit;
/* ... */
temp_celsius=(5.0f/9.0f)*(temp_farenheit-32.0f);



... Então Jesus afirmou de novo: “(...) eu vim para que tenham vida, e a tenham plenamente.” (João 10:7-10)





Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts