<!--
 Introducao `a Programacao - desde 2017 - Prof. Leo^nidas de Oliveira Branda~o
 Introdução à conversão inteiro/flutuante e divisões
 LInE (Laboratory of Informatics in Education) - http://www.usp.br/line
 IME - USP
 Material dida'tico
 Pode usar livrevemente este material para fins nao comerciais, devendo sempre fazer referencia `a autoria.
 Sugestoes/apontamento são bem vindos: leo@ime.usp.br (favor indicar no assunto "Material de introducao 'a programacao")
 Autoria: Prof. Leo^nidas de Oliveira Branda~o
 http://www.ime.usp.br/~leo
 http://line.ime.usp.br
 http://www.matemtica.br
-->

  <meta http-equiv='Content-Type' content='text/html; charset=UTF-8'>
  <meta name='keywords' content='mac0122, material, professores, leonidas de oliveira brandao'>
  <link rel='stylesheet' type='text/css' href='css_img_js_conf/all.css'>
  <link rel='stylesheet' type='text/css' href='css_img_js_conf/line_introducao_programacao.css'>
  <script src="css_img_js_conf/defineLInE.js"></script> <!-- para referencias 'a documentos internos -->
<div class="pagina">


<center><p>[
  <a href="declaracao" title="sobre declaracao de variaveis e tipos"
     onclick="frames['iFrame'].document.getElementById('declaracao').scrollIntoView();return false">Declaração</a> &nbsp; | &nbsp;
  <a href="#C" title="conversao entre tipo inteiro-flutuante em C"
     onclick="frames['iFrame'].document.getElementById('C').scrollIntoView();return false">Conversão</a> &nbsp; | &nbsp;
  <a href="#python" title="conversao de tipo inteiro-flutuante em Python"
     onclick="frames['iFrame'].document.getElementById('python').scrollIntoView();return false">Python</a> &nbsp; &nbsp;
 ]</p>
</center>


<p class="secao">Introdução à conversão inteiro/flutuante e divisões</p>

<!-- p>
<b>Alterações</b>:  - .
</p -->

<p>
  Nesta seção 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.
</p>

<p>
  Na seção seguinte apresentamos um resumo sobre variáveis inteiras e flutuantes tanto em <i>C</i> quanto
  em <i>Python</i> e nas duas seções seguintes individualizamos as explicações para cada uma das duas linguagens.
</p>

<a name="declaracao" id="declaracao"></a>
<span style="color: #0055AA;font-size:1.2em">Declaração de tipo <i>inteiro</i> e <i>flutuante</i> em <i>C</i> e em <i>Python</i></span>

<p>
  Como o próprio nome diz, uma variável inteira pode representar apenas números inteiros, mas o significado de uma variável
  em <i>ponto flutuante</i> 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 <tt>5/2 = 2.5</tt>.
  As explicações sobre a razão desse tipo de variável ser denotada por <i>ponto flutuante</i> é
  <a href="#" onclick="trocaPagina('introducao_float.html')" title="seguir para explicacao de float">explicada em outro texto</a>.
</p>

<p>
  <span style="color: #0055AA">Variável = posição de memória + tamanho (em <i>bits</i>).</span>
  Como explicado em outros textos, uma variável está associada à determinada posição de memória e à uma quantidade
  conhecida de <i>bits</i>, pois desse modo pode-se interpretar corretamente o valor ali representado.
  Desse modo podemos dizer que cada variável é de um <b>tipo</b> especĩfico, como <i>tipo inteiro</i> ou <i>tipo real/flutuante</i>.
</p>

<p>
  <span style="color: #0055AA">Definição de tipo.</span>
  Na linguagem <i>Python</i>, o <i>tipo</i> é definido na primeira vez que a variável é interpretada, por exemplo, 
  se ela recebe um valor inteiro, será inteira.
  Já na linguagem <i>C</i>, como é obrigatório declarar todas as variáveis que serão usadas, a associação é feita no momento dé
</p>

<p><span style="color: #0055AA">Formatador de tipo.</span>
  Para se conseguir registrar um valar digitado pelo usuário ou, inversamente, para se imprimir um valor, deve-se também
  saber como estão organizados os <i>bits</i> associados ao valor, alẽm de saber quantos <i>bits</i> determinada variável usa.
  Ou seja, existe um algoritmo interno para converter os <i>bits</i> para o valor legível (usualmente em decimal).
  Para isso as linguagens <i>C</i> e <i>Python</i>, dispõe de um <i>formatador</i> que indica qual o tipo a ser <b>impresso</b>
  (<i>saída</i>). A linguagem <i>C</i> também precisa desse formatador para a <b>leitura</b> (<i>entrada</i>).
</p>

<p>
  O <b>formatador para inteiro é o <tt>%d</tt></b> e o <b>formatador para flutuante é o <tt>%f</tt></b>.
  Entretanto não é acusado erro de compilação (<i>C</i>) ou interpretação (<i>Python</i>) se usar um formatador
  errado para imprimir uma variável, embora em <i>C</i> o efeito é desagradável, tanto imprimir inteiro com flutuante,
  quanto imprimir flutuante como inteiro, produz valores "estranhos" (por <i>Python</i> ser mais dinâmico, quase não
  se percebe essa dificuldade de conversão).
  Os demais tipos de variáveis tem outros formatadores.
</p>

<p>
  Nos três exemplos a seguir ilustramos como é a leitura e impressão de variáveis inteiras e flutuantes.
</p>

<p>
  <b>Exemplo 1 [<i>C</i>]</b>: ler 1 valor inteiro, ler 1 valor "real", imprimir na mesma linha os 2 valores lidos.
  <pre><verm>int</verm> v1; <verm>float</verm> v2; <verd>scanf</verd>("%d %f", &v1. &v2); <verd>printf</verd>("v1=%d, v2=%f\n", v1, v2);</pre>
</p>

<p>
  Na linguagem <i>Python</i> não é necessário declarar as variáveis, mas ao ler um valor é preciso convertê-lo para o tipo
  a ser trabalhado, além disso, em impressões pode-se usar os formatadores para <tt>%d</tt> para inteiro e  <tt>%f</tt> para flutuante.
</p>

<p>
  <b>Exemplo 2 [<i>Python</i>]</b>: ler 1 valor inteiro, ler 1 valor "real", imprimir em linhas separadas os 2 valores lidos.
  <pre style="font-size:0.8em">v1 = int(<verd>input</verd>()); v2 = float(<verd>input</verd>()); <cyan># ler 2 valores, o primeiro como int, o segundo como float</cyan>
<verd>print</verd>("v1=", v1); <verd>print</verd>("v2=", v2); <cyan># note que neste caso havera uma quebra de linha entre v1 e v2</cyan>
</pre>
</p>

<p>
  <b>Exemplo 3 [<i>Python</i>]</b>: ler 1 valor inteiro, ler 1 valor "real", imprimir na mesma linha os 2 valores lidos
    (usando diferente técnicas).
  <pre style="font-size:0.8em"><cyan># No Python pode-se imprimir sem mudar de linha usando o parametro ' , end = ""' assim: <verd>print</verd>("Algo ", end = "");</cyan>
<cyan># mas para isso precisa carregar a biblioteca 'print_function' como na linha abaixo</cyan>
from __future__ import print_function <cyan># no Python 3 esta linha e' desnecessaria...</cyan>

<verm>der</verm> main () : <cyan># declara uma funcao de nome 'main'</cyan>
  v1 = 2; v2 = 5.0; 
  <cyan># Tecnica 1 para imprimir na mesma linha: mais facil</cyan>
  <verd>print</verd>("v1=", v1, "v2=", v2);

  <cyan># Tecnica 2: o %d e %f indica que ali virao valores 'int' e 'float', respectivamente,</cyan>
  <cyan>#            e o ultimo % indica que a seguir deve vir uma lista com os valores para %d e %f (nessa ordem)</cyan>
  <verd>print</verd>("v1=%d, v2=%f\nxxx" % (v1, v2)); <cyan># dentro das aspas o \n forca uma quebra de linha => o xxx vai para a prox linha</cyan>

  <cyan># Tecnica 3: permite fazer uma impressao e NAO quebrar a linha, ou seja, o proximo 'print' vai para a mesma linha</cyan>
  <verd>print</verd>("v1=", v1, ", v2=", v2, end = ""); <cyan># o ultimo parametro 'end=""' manda nao quebrar a linha</cyan>
  <verd>print</verd>(" ***");                           <cyan># portanto, esses asteriscos irao para a mesma linha do 'v1= 5, v2= 2'</cyan>

main(); <cyan># invoque a funcao 'main()'</cyan>
</pre>
</p>

<a name="C" id="C"></a>
<span style="color: #0055AA;font-size:1.2em">Conversão de tipo em <i>C</i> (inteiro e "real")</span>

<p>
  Em <i>C</i> é 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).
</p>

<p>
  <b>Exemplo 4</b>: usar variáveis <tt><verm>int</verm> v1</tt> e <tt><verm>float</verm> v2</tt> e fazê-las receber o resultado de <tt>5 / 2</tt>.
  <pre style="font-size:0.8em">#include &lt;stdio.h&gt;
<verm>int</verm> main (void) {
  <verm>int</verm> v1;
  <verm>float</verm> v2;
  v1 = 5/2; <cyan>// como 5 e 2 sao inteiro => faz-se a divisao inteira!</cyan>
  v2 = 5/2; <cyan>// idem! (ou seja, o fato de v2 ser float nao altera o resultado)</cyan>
  <verd>printf</verd>("v1=%d, v2=%f\n", v1, v2); <cyan>// o resultado sera': v1=2, v2=2.000000</cyan>
  return 1; <cyan>// se foi algum outro programa que invocou este, devolva o valor 1</cyan>
  }</pre>
</p>

<p>
  Assim, se o desejado é que <tt>v2</tt> receba o valor <tt>2.5</tt>, então deve-se usar um conversor de tipo
  (<i>type cast</i>), convertendo ou o <tt>5</tt> ou o <tt>2</tt> para <i>float</i>.
  Assim:
  <tt>v2 = (float)5 / 2; <cyan>// ou v2 = 5 / (float) 2</tt>.</cyan>
</p>

<p>
  Agora se o interesse for obter o resto da divisão inteira, não é preciso de um truque "matemático", basta usar o
  operador especial <tt>%</tt>, como indicado no exemplo 5 abaixo.
</p>


<p>
  <b>Exemplo 5</b>: um programa para imprimir o resto da divisão inteira entre dois inteiros.
  <pre style="font-size:0.8em">#include &lt;stdio.h&gt;
<verm>int</verm> main (void) {
  <verm>int</verm> v1, v2;
  <verd>scanf</verd>("%d %d", &v1. &v2); <cyan>// solicita que sejam digitados 2 valores inteiros</cyan>

  <verd>printf</verd>("v1=%d, v2=%f\n", v1, v2); <cyan>// imprime o que foi digitado</cyan>

  <cyan>// Supondo que foi digitado 5 para v1 e 2 para v2, o proximo 'printf' imprime: resto da divisao entre 5 e 2 e': 1</cyan>
  <verd>printf</verd>("resto da divisao entre %d e %d e': %d\n", v1, v2, v1 % v2); <cyan>// note o "v1 % v2"</cyan>

  <cyan>// pode-se fazer a impressao ou armazenar o resto da divisao usando constantes</cyan>
  <verd>printf</verd>("%d\n", 5%2); <cyan>// imprime: 1</cyan>
  v1 = 5%2;            <cyan>// v1 recebe o resto da divisao inteira de 5 por 2 (ou seja, recebe 1)</cyan>
  return 1;
  }</pre>
</p>



<a name="python" id="python"></a>
<span style="color: #0055AA;font-size:1.2em">Conversão de tipo em <i>Python</i> (inteiro e "real")</span>

<p>
  Em <i>Python</i> existem vários opções para impressão, mas deve-se tomar cuidado com as variáveis/valores, pois
  dependendo do "tipo", o valor pode ser truncado.
  Outro cuidado que deve-se tomar é que, ao solicitar que o usuário digite um valor numérico, deve-se convertë-lo
  para o tipo desejado.
</p>

<p>
  <b>Exemplo 6</b>: usar variáveis <tt>v1</tt> e <tt>v2</tt>, a primeira para inteiro (<i>int</i>) e a segunda para "real"
  (ou ponto flutuante, (<i>float</i>)
  e fazê-las receber o resultado de <tt>5 / 2</tt>.
  <pre style="font-size:0.8em"><verm>der</verm> main () :
  v1 = 5/2;         <cyan># o resultado e' 2</cyan>
  v2 = float(5)/2); <cyan># obrigatorio converter um dos operandos para conseguir 2.5 - veja que "float(5/2)" resulta "2.0"</cyan>

  <cyan># imprimir de modo mais simples</cyan>
  <verd>print</verd>("v1=", v1, "v2=", v2);       <cyan># resultado: v1=2, v2=2.5</cyan>

  <cyan># agora imprimindo usando formatadores %d e %f e uma lista de valores (v1, v2)</cyan>
  <verd>print</verd>("v1=%d, v2=%d" % (v1, v2));  <cyan># resultado: v1=2, v2=2</cyan>
  <verd>print</verd>("v1=%f, v2=%f" % (v1, v2));  <cyan># resultado: v1=2.000000, v2=2.500000</cyan>
  <verd>print</verd>("v1=%d, v2=%f" % (v1, v2));  <cyan># resultado: v1=2, v2=2.500000</cyan>
main();
</pre>
</p>

<p>
  Note que no exemplo acima, aparece <tt>(v1, v2)</tt> que é uma <b>lista</b> do <i>Python</i>, no caso com dois
  valores numéricos, o primeiro deles será lançado sobre o formatador (no caso o <tt>%d</tt>)
  e o segundo deles irá para o segundo formatador (no caso o <tt>%f</tt>).
</p>
<p>  
  Outra nota deve ser feita sobre o significado dos <i>formatadores</i>, o <tt>%d</tt> prepara uma saída do tipo
  <i>int</i>, enquanto o <tt>%f</tt> é para saída de valores "reais" (na verdade <i>float</i>).
  Assim, mesmo que determinada variável (<tt>v2</tt> no caso) armazene <i>float</i>
  se usar o formatador <tt>%d</tt> será impressa a parte inteira do número (ou seja, ele é <b>truncado</b>).
</p>

<p>
  No exemplo abaixo, fazemos a leitura de um valor inteiro e de um valor "real".
  Precisamos usar as funções conversoras de tipo <tt>int(...)</tt> e <tt>float(...)</tt>,
  respectivamente para converter os valores lidos para <tt>int</tt> e para <tt>float</tt>, respectivamente.
</p>

<p>
  <b>Exemplo 7</b>: usar variáveis <tt><verm>int</verm> v1</tt> e <tt><verm>float</verm> v2</tt>.
  <pre style="font-size:0.8em"><verm>der</verm> main () :
  v1 = int(<verd>input</verd>());    <cyan># ler um valor do tipo inteiro</cyan>
  v2 = float(intput()); <cyan># ler um valor do tipo "float"</cyan>
  <verd>print</verd>("v1=%d, v2=%d" % (v1, v2));  <cyan># imprimir assim, o v2 sera' truncado para inteiro</cyan>
  <verd>print</verd>("v1=%d, v2=%f" % (v1, v2));  <cyan># aqui imprime corretamente v1 como "int" e v2 como "float"</cyan>
  <verd>print</verd>("v1=" + str(v1) + ", v2=" + str(v2)); <cyan># pode-se imprimir concatenando "strings" - a funcao "str(...)" converte valor para "string"</cyan>
main();
</pre>
</p>

<p>
  Do mesmo modo que <i>C</i>, a linguagem <i>Python</i> tem um operador que permite obter o resto da divisão inteira,
  que é o operador especial <tt>%</tt>, como indicado no exemplo 8 abaixo.
</p>


<p>
  <b>Exemplo 8</b>: um programa para imprimir o resto da divisão inteira entre dois inteiros.
  <pre style="font-size:0.8em"><verm>der</verm> main () :
  v1 = int(<verd>input</verd>());    <cyan># ler um valor do tipo inteiro</cyan>
  v2 = float(intput()); <cyan># ler um valor do tipo "float"</cyan>
  <verd>print</verd>("v1=%d, v2=%d" % (v1, v2));  <cyan># o que foi digitado</cyan>

  <verd>print</verd>("resto da divisao entre %d e %d e': %d" % (v1, v2, v1 % v2)); <cyan># apos o '%' deve vir uma lista (v1,v2,v1%v2)</cyan>

main();</pre>
</p>

  <p class="autoria">
    <a href="https://www.ime.usp.br/~leo" target="_blank" title="seguir para a pagina do prof. Leônidas">Leônidas de Oliveira Brandão</a><br/>
    <a href="http://www.ime.usp.br/~leo" target="_blank" title="seguir para a página do LInE">http://line.ime.usp.br</a>
  </p>

<p class="rodape">
  <b>Alterações</b>:<br/>
  2019/07/31: redesenhada a estrutura da página e vários pequenas correções;<br/>
  2018/04/02: versão inicial;
</p>

</div>