[ Problema | Declaração | Conversão ]
Introdução à conversão inteiro/flutuante e divisões
Neste texto apresentaremos a conversão entre variáveis inteiras e flutuantes, além de destacar como obter o quociente e o resto da divisão entre inteiros.
Na seção seguinte apresentamos um resumo sobre variáveis inteiras e flutuantes considerando a linguagem C e na seção seguintes apresentamos alguns detalhes sobre como converter inteiro para flutuante.
1. Problema da divisão com inteiros (resultar sempre inteiro)
Uma regra da linguagem C (não apenas dela) é que ao fazer operações envolvendo inteiros, o resultado é sempre inteiro.
Assim ao executar o comando
Poderia-se pensar que trocar o formatador de inteiro (o %d) para o correspondente de "flutuante" o resultado poderia ser diferente, mas ele piora:
Cód. 1. Código ilustrando a operação com inteiros ser realizada com precisão de inteiros.#include <stdio.h>int main (void ) {printf ("%d %d\n", 9/2, 10/3);// 9 = 4*2+1 e 10 = 3*3 + 1 => 4 3 printf ("%f %f\n", 9/2, 10/3);// o resultado por ficar pior: 0.000000 0.000000 printf ("%d %d\n", 9%2, 10%3);// o resto da divisao inteira: 1 1 }
No código acima também ilustramos que é possível pegar o resto da divisão inteira, o que é possível via operador %.
Na seção 3 veremos duas formas de contornar esse problema e conseguir os valores 4.500000 3.333333.
2. Declaração de tipo inteiro e flutuante em C
Como o próprio nome diz, uma variável inteira pode representar apenas números inteiros, mas o significado de uma variável em ponto flutuante não é tão óbvio, mas simplificadamente, podemos entender que é o tipo de variável que permite trabalhar com valores "reais", por exemplo, para podermos armazenar valores como 5/2 = 2.5. As explicações sobre a razão desse tipo de variável ser denotada por ponto flutuante é explicada em outro texto.
Definição de tipo. Na linguagem C é obrigatório declarar (inicalmente) todas as variáveis que serão usadas, desse modo ao declarar uma variável uma quantidade conveniente de memória será associada a tal variável (como ilustrado na fig. 1).
Variável = posição de memória + tamanho (em bits). Como explicado em outros textos, uma variável está associada à determinada posição de memória e à uma quantidade conhecida de bits, pois desse modo pode-se interpretar corretamente o valor ali representado. Desse modo podemos dizer que cada variável é de um tipo especĩfico, como tipo inteiro ou tipo real/flutuante. Na fig. 1 ilustramos duas variáveis em memória, uma inteira e uma flututante.
Fig. 1. Ilustração de variáveis na memória e qual o seu "tamanho" (simplificadamente supondo inteiro com 16 bits e flutuante com 40 bits.
Formatador de tipo.
Para se conseguir registrar um valor digitado pelo usuário ou, inversamente, para se imprimir um valor, deve-se também
saber como estão organizados os bits associados ao valor, além de saber quantos bits determinada variável usa.
Ou seja, deve existir um algoritmo interno para converter os bits para o valor legível (usualmente em decimal).
Em C, tanto para a leitura (entrada) quanto para a impressão (saída),
deve-se utilizar um formatador (e.g. %d para inteior e %f para flutuante).
Para leitura de um inteiro e um flutuante usa-se scanf("%d %f", &i, &f);
e para impressão printf("%d %f\n", i, f);.
Os demais tipos de variáveis tem outros formatadores.
Assim, a linguagem C usa como formatador para inteiro o %d e como formatador para flutuante é o %f.
A inversão desse formatadores provoca resultados mais "estranhos", quer dizer se tentar imprimir uma
variável inteira com formatador flutuante ou vice-versa, o resultado pode ser muito distindo do valor (e.g. int a=7; printf("a=%f\n", a); pode resultar valor 0).
No exemplo a seguir ilustramos como é a leitura e impressão de variáveis inteiras e flutuantes na linguagem C
Exemplo 1 [C]: ler 1 valor inteiro, ler 1 valor "real", imprimir na mesma linha os 2 valores lidos.
int v1;float v2;scanf ("%d %f", &v1. &v2);printf ("v1=%d, v2=%f\n", v1, v2);
3. Conversão de tipo em C (inteiro e "real")
Em C é preciso cuidado ao realizar operações com variáveis, por exemplo se realizar uma divisão entre variáveis (ou constante) inteiras, o resultado é um valor inteiro, mesmo que a variável armazenando o resultado seja "real" (flutuante).
Exemplo 2: usar variáveis
Cód. 2. Código ilustrando a operação com inteiros ser realizada com precisão de inteiros.#include <stdio.h>int main (void) {int v1;float v2; v1 = 5/2;// como 5 e 2 sao inteiro => faz-se a divisao inteira! v2 = 5/2;// idem! (ou seja, o fato de v2 ser float nao altera o resultado) printf ("v1=%d, v2=%f\n", v1, v2);// o resultado sera': v1=2, v2=2.000000 return 1;// se foi algum outro programa que invocou este, devolva o valor 1 }
Assim, se o desejado é que as variáveis recebam o valor 2.5, então pode-se converter o tipo da operação
de modo implícito ou explícito.
Para o modo implícito basta usar 5.0 ou 2.0, enquanto o modo explícito emprega o conversor
(float) ((float)5 ou (float)2).
Em Inglês o termo utilizado é o type cast, assim:
v2 = (float)5 / 2;
Desse modo, se o interesse for obter o resto da divisão inteira, não é preciso de um truque "matemático", basta usar o operador especial %, como indicado no exemplo 3 abaixo.
Exemplo 3: um programa para imprimir o resto da divisão inteira entre dois inteiros.
Cód. 3. Código ilustrando como passar para operação com flutuantes (conversor de tipo implícito ou explícito).#include <stdio.h>int main (void) {float v1, v2; v1 = 5.0/2;// usando 5.0 (ou 2.0) => faz-se a divisao flutuante! v2 = (float)5/2;// convertendo 5 (ou 2) para float => faz-se a divisao flutuante! printf ("v1=%f, v2=%f\n", v1, v2);// o resultado sera': v1=2, v2=2.000000 // Supondo que foi digitado 5 para v1 e 2 para v2, o proximo 'printf' imprime: resto da divisao entre 5 e 2 e': 1 printf ("resto da divisao entre %d e %d e': %d\n", (int)v1, (int)v2, (int)v1 % (int)v2);// note o "v1 % v2" // pode-se fazer a impressao ou armazenar o resto da divisao usando constantes printf ("%d\n", 5%2);// imprime: 1 v1 = 5%2;// v1 recebe o resto da divisao inteira de 5 por 2 (ou seja, recebe 1) return 1; }
Leônidas de Oliveira Brandão
http://line.ime.usp.br
Alterações:
2024/03/17: versão expliva para C;
2021/06/14: numeração de seções e pequenas correções;
2019/07/31: redesenhada a estrutura da página e vários pequenas correções;
2018/04/02: versão inicial;