intr_prog/c_introducao_leituras.html

<!--
Introdução à entrada de dados em C
m, n = map(int, raw_input().split());
href: line_introducao_float.html ; line_introducao_char.html
-->

  <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> <!-- referencia documentos internos -->
<div class="pagina">


<!--
declaracao
io_simples
ex_io_simples
io_composto
-->

<a name="declaracao">
<p class="secao">Qual a diferença entre <i>declarar</i> e usar uma variável?</p>
</a>

<p>
  Uma <a href=#" onclick="trocaPagina('introducao_var.html#declaracao')" "introducao_var.html#declaracao" title="ver explicacao">variável</a>
  nada mais é que um nome associado à uma posição de <i>memória</i> do computador:
  a posição de seu <i>bit</i> inicial e o número de <i>bits</i> usados para representar aquele tipo de variável.
  Como a linguagem <i>C</i> é <b style="color:#0000aa" title="Necessário traduzir tudo para linguagem da máquina">compilada</b>,
  nela é necessário <b style="color:#0000aa" title="Reservar espaço na memória e associar esse espaço a um nome">declarar</b> cada variável
  e isso (geralmente) é feito no início da função.
  Uma vez que variável foi declarada, pode-se usá-la (recebendo valores ou em expressões).
  <pre style="font-size:0.9em"><verm>int</verm> main (<verm>void</verm>) {
  <verm>int</verm> n, i=0; <cyan>// declara 2 variaveis para inteiro de nome 'n' e 'i' (i sendo iniciada com valor 0)</cyan>
  <verm>float</verm> x = 0.5, y; <cyan>// declara 2 variaveis para inteiro de nome 'x' e 'y' (x sendo iniciada com valor 0.5)</cyan>
  ...
  }</pre>
  <i>Cód. 1. Código ilustrando a declaração de variáveis inteiras e flutuantes.</i>
</p>

<p>
  Outro conceito essencial às variáveis é o de
  <b style="color:#0000aa" title="Alterar o valor guardado pela variável">atribuição</b> de valor.
  Sua sintaxe em <i>C</i>, e em muitas outras linuguagens, é usar do
  <b style="color:#0000aa" title="lado esquerdo da atribuição">lado esquerdo</b> da atribuição um nome de variável e do
  <b style="color:#0000aa" title="lado direito da atribuição">lado direito</b> da atribuição uma expressão aritméitca válida.
  No código 1, <tt>i=0</tt> e <tt>x=0.5</tt> são atribuições, tendo como <i>lado esquerdo</i> as variáveis <i>i</i> e <i>x</i>
  e como <i>lado direito</i> as expressões constantes <i>0</i> e <i>0.5</i>.
</p>

<p>
  Ainda usando como estrutura o código 1, outro exemplo de atribuição poderia ser <tt>i = n/2</tt>, que tem como
  <i>lado direito</i> a expressão <i>n/2</i>.
  Como no código 1 a variável <i>n</i> é do tipo inteiro, o mesmo para a constante <i>2</i> (se desejasse <i>flutuante</i> deveria usar <i>2.0</i>),
  então seu resultado é o <b style="color:#00aa00" title="a/b = q &#8658; q é o quociente">quociente da divisão inteira da divisão</b>.
  Mas vale adiantar outra possibilidade de "forçar" o resultado a ser <i>flutuante</i>, usar o coversor de tipo:
  <tt style="color:#00aa00" title="o valor de n é convertido para float, daí o restante da conta usa flutuante">x = (<verm>float</verm>)n/2</tt>.
  <!--
   &#11013; black left arrow
   &#11013; black right arrow
   &#8658;  Rightwards Double Arrow
  -->
</p>

<p>
  A figura 1 ilustra a associação de espaço em memória (<i>RAM</i>) para duas variáveis,
  são associados 16 <i>bits</i> à variável de nome <i>n</i> para valores inteiros, seguido da associação de
  32 <i>bits</i> para a variável de nome <i>x</i>, que deve guardar valores "reais".
  Nota-se que a variável "real" tem um esquema mais "complicado", ela implementa o conceito
  de <a href="#" onclick="trocaPagina('introducao_float.html')" title="clique aqui para estudar ponto flutuante" targe="_blank">ponto flutuante</a>,
  usando o padrão 
  <a href="https://en.wikipedia.org/wiki/Integer_%28computer_science%29" title="ler a respeito IEEE 754 na WikiPedia" target="_blank">
  IEEE 754</a> (o primeiro <i>bit</i> é o sinal <i>s</i>; os 8 <i>bits</i>
  seguintes correspondente ao expoente <i>e</i> e os últimos 23 à mantissa <i>m</i> - valor de <i>x</i> é s x m x 10<sup>e</sup>, sendo
  <i>m</i> entre 0 e 1).
</p>

<center><img src="img/var_memoria1.jpg" title="Ilustracao de inteiro de 16 bits e do modelo float IEEE 754 com 32 bits em memoria"/>
<br/>
<i>Fig. 1. Representação da memória com agrupamentos em <i>bytes</i> (8 <i>bits</i>).</i>
</center>

<!--
https://en.wikipedia.org/wiki/Integer_%28computer_science%29
int = -32,768 to 32,767, from -(2^15) to 2^15-1 
https://en.wikipedia.org/wiki/Single-precision_floating-point_format
  float = 32 bits
  IEEE 754 single-precision binary floating-point format: binary32
  Sign bit: 1 bit ; Exponent width: 8 bits ; Significand precision: 24 bits (23 explicitly stored)
  float = 0/1 0.mantissa x 10^e
              24 bits      8
-->


<a name="io_simples">
<p class="secao">O que são "entradas de dados" e "saídas de dados"?</p>
</a>

<p>
  Um <b>algoritmo</b> é uma sequência finita de passos, que ao ser aplicado à um conjunto de dados (<b>entradas</b>) deve produzir sempre as mesmas
  <b>saídas</b>.
  Por exemplo, o algoritmo da divisão ao ser aplicado sobre valores fixados <i>a</i> e <i>b</i>, deve
  produzir sempre o mesmo valor <i>q</i> (de tal forma que <i>q * b = a</i>).
</p>

<p>
  Por outro lado, um 
  <b style="color:#0000aa" title="um algoritmo implementado em alguma linguagem">programa</b>, em <i>C</i> ou em qualquer outra linguagem,
  nada mais é que a implementação de um <b>algoritmo</b> na referida linguagem.
  Desse modo, para este programa ser usado, o
  <b style="color:#0000aa" title="quem usa o programa">usuário</b> (aquele que está executando) deve fornecer um conjunto de 
  <b>dados de entrada</b>, na ordem adequada (pois <i>a/b</i> geralmente não é o mesmo que <i>b/a</i>), para que o
  programa possa ser executado e produzir as <b>saída</b> desejadas.
</p>

<center><img src="img/img_computador_io.png" title="ilustracao processamento entradas x saidas"/>
<br/><i>Fig. 2. Ilustração da existência de um algoritmo que aplicado sobre as entradas produz as respectivas saídas.</i>
</center>

<p>
  Podemos usar o mesmo exemplo da divisão para ilustar a necessidade dos <i>dados de entrada</i> adequados.
  Para que um algoritmo para a divisão de dois números reais seja adequadamente executado,
  devem ser fornecidos os dois valores reais, o primeiro será o
  <b style="color:#0000aa" title="em a/b &#8658; parte de cima é o numerador &#8658; a é o numerador">numerador</b> e o segundo será o
  <b style="color:#0000aa" title="em a/b &#8658; parte de baixo é o denominador &#8658; b é o denominador">denominador</b>.
  Assim, se o <i>usuário</i> digitar apenas um valor, o programa ficará parado até
  <!--  &#8658; = Rightwards Double Arrow -->
  que ele digite o segundo valor.
</p>

<sabermais title="para saber um pouco mais">
  Vale observar que, usando uma linguagem como <i>C</i>, não existe a necessidade de implementar algo tão básico (a <i>divisão</i>, pois
  isso é feito por um algoritmo implementado no processador do computador.
  Na verdade, desde a proposta inicial do matemática
  <a href="https://en.wikipedia.org/wiki/John_von_Neumann" target="_blank" title="Examinar a página sobre John von Neumann na WikiPedia em Inglês"
  >John von Neumann</a>, existe uma
  <a href="https://en.wikipedia.org/wiki/Arithmetic_logic_unit" target="_blank" title="Examinar a página ULA na WikiPedia em Inglês"
  ><b style="color:#0000aa">unidade lógico/aritmética</b></a> especialmente projetada para realizar as
  operações lógicas e aritméticas.
  Embora, o modelo inicialmente proposto por <i>von Neumann</i> preconizase o uso de
  <i>ponto fixo</i>, não o <i>flutuante</i>.
</sabermais>
<br/>


<a name="ex_io_simples">
<p class="secao">Saídas de dados simples: inteiro, real e texto em <i>C</i></p>
</a>
<!-- ./introducao/codigos/testes/teste_input.c -->

<p>
  A linguagem <i>C</i> preconiza o uso de <b style="color:#00aa00">formatador</b> para cada tipo de variável, tanto
  para as <i>entradas</i> quanto para as <i>saídas</i>.
  Os formatadores básicos são:
  <center><i>Tab. 1. Formatadores de acordo com tipo, com exemplo para entra e para saída em <i>C</i></i><br/>
<table class="tableCode thBg">
 <tr>
   <th class="thBg" >Tipo de variável</th><th class="thBg" >Tipo em <i>C</i></th>
   <th class="thBg" >Leitura</th><th class="thBg" >Impressão</th></tr>
  <tr>
 <tr>
   <td>Inteiro</td><td class="code"><verm>int</verm> a, b;</td>
   <td class="code"><verd>scanf</verd>("%d %d", &a, &b);</td><td class="code"><verd>printf</verd>("%d %d\n", a, b);</td></tr>
 <tr>
   <td>Caractere</td><td class="code">char a, b;</td>
   <td class="code"><verd>scanf</verd>("%c %c", &a, &b);</td><td class="code"><verd>printf</verd>("%c %c\n", a, b);</td></tr>
 <tr>
   <td>Flutuante</td><td class="code"><verm>float</verm> a, b;</td>
   <td class="code"><verd>scanf</verd>("%f %f", &a, &b);</td><td class="code"><verd>printf</verd>("%f %f\n", a, b);</td></tr>
 <tr>
   <td>Duplo</td><td class="code">double a, b;</td>
   <td class="code"><verd>scanf</verd>("%lf %lf", &a, &b);</td><td class="code"><verd>printf</verd>("%lf %lf\n", a, b);</td></tr>
</table></center>
</p>

<p>
  Em <i>C</i> a conversão entre inteiros e caracteres é direta, basta trocar o formatador.
  Isso é possível devido à conversão inteiro-binário e binário-caractere.
  Para isso utiliza-se a primeira tabela de representação de caracteres que se popularizou, a tabela
  <b style="color:#00aa00" title="American Standard Code for Information Interchange: código de 8 bits para caracteres">ASCII</b>.
  Para saber mais consulte o texto
  <a href="#" onclick="trocaPagina('introducao_char.html')" title="seguir para introdução aos caracteres">introdutório sobre caracteres</a>.
  Na tabela 1, o código à esquerda ilustra como testar a tabela <i>ASCII</i>.
</p>


<!-- ∑ N-Ary Summation
     HTML-code:      &#8721; -->
<!-- ./introducao/codigos/introducao_leituras_c.c -->
<p>
<center><i>Tab. 1. Exemplo de códigos para entrada e saída de inteiros e "reais" para o C 2</i><br/>
<table class="tableCode thBg">
 <tr>
   <th>Exemplo de tabela
       <b style="color:#00aa00" title="American Standard Code for Information Interchange: código de 8 bits para caracteres">ASCII</b></th>
   <th>Exemplo de tabela numérica &#8721;<sub>i=0</sub><sup>10</sup> 0.5<sup>i</sup></th></tr>
 <tr>
   <td><pre style="font-size: 0.8em;">#include &lt;stdio.h&gt;

<verm>void</verm> main (<verm>void</verm>) {
  <verm>int</verm> i;
  <verd>printf</verd>("Int | ASCII\n");
  for (i=48; i<91; i++) {
    <verd>printf</verd>(" %2d |  '%2c'\n", i, i);
    <cyan>// "Pular" os caracteres:</cyan>
    if (i==57) <cyan>// 58=':' 59=';' 60='<' 61='='</cyan>
      i = 64;  <cyan>// 62='>' 63='?' 64='@'</cyan>
    }
  }</pre></td>
  <td><pre style="font-size: 0.8em;">#include &lt;stdio.h&gt;
<verm>void</verm> main (<verm>void</verm>) {
  <verm>float</verm> soma = 0, pot = 1;
  <verm>int</verm> i;
  <verd>printf</verd>("Int | Soma 0.5^0+...+0.5^i\n");
  for (i=0; i<11; i++) {
    soma += pot;
    <verd>printf</verd>(" %2d |             %8.2f\n", i, soma);
    pot *= 0.5 * pot;
    }
  }</pre></td></tr>
</table></center>
</p>

<p>  
  Se o <i>usuário</i>
  desejar inserir outra coisa (em geral uma <i>cadeia de caracteres</i> - "<i>string</i>")
  deve-se usar uma função especial (vide <tt>raw_input</tt> a seguir).
</p>


<a name="io_composto">
<p class="secao">Entradas de dados em <i>C</i></p>
</a>
<!-- ./introducao/codigos/testes/teste_input.py -->

<p>
  Em <i>C</i> o processo para <i>leitura</i> de valores via teclado é tratado em <i>lote</i>, quer dizer,
  durante a execução de um programa, a cada momento que o usuário <i>digitar</i> uma sequẽncia de valores e pressionar
  a tecla para registro (<i>Enter</i>), todos os valores digitados serão armazenador em um <i>reservatório</i>
  (em Inglês <i>buffer</i>) e a cada momento que o programa encontrar um comando para <i>leitura</i> será usado a
  próxima parte disponível do <i>reservatório</i>.
  <br/>
  Para verficar a existência do <i>reservatório</i>, experimente testar o código 2, de dois modos:
  <ol>
  <li> digitando todos os valores e um único <i>Enter</i> (<tt>CR</tt>) ao final (i.e. algo como
    <tt style="color:#00aa00" title="digitar '2 3 ABD D E 0.5 2.3' (sem apóstrofe) e teclar Enter">2 3 ABD D E 0.5 2.3 CR</tt>)
    </li>
  <li> digitando cada um dos 9 itens teclando <i>Enter</i> em diferentes locais
    (e.g. como:
    <tt style="color:#00aa00" title="digitar '2' depois CR, '3' depois CR, 'ABD' depois CR e assim por diante"
        >2 CR 3 CR ABD CR D CR E CR 0.5 CR 2.3 CR</tt>).
    </li>
  </ol>
  Você deverá notar que em ambos os modos todos os valores serão corretamente capturados, com qualquer variação de <i>Enter</i>
  (<tt>CR</tt>)
  <i style="color:#00aa00" title="Por exemplo, não é adequado teclar CR no meio do '0.5', ou seja, não pode ser '0. CR 5'">adequado</i>,
  os valores serão armazenados nas variáveis <i>i1, i1, c1, c2, c3, c4, c5, x</i> e <i>y</i> da mesma forma.
</p>


<p>
<center><i>Tab. 2. Exemplo de código para entrada de valors, caracteres e "reais"</i><br/>
<table class="tableCode thBg">
 <tr>
   <th>Exemplo de código para entrada em <i>C</i></th></tr>
 <tr>
   <td><pre style="font-size: 0.8em;">#include &lt;stdio.h&gt;
<verm>void</verm> main (<verm>void</verm>) {
  <verm>float</verm> x, y;
  <verm>int</verm> i1, i2;
  char c1, c2, c3, c4, c5;                  
  <verd>printf</verd>("Digite 9 itens, separados por espaco em branco (2 int, 5 char, 2 float): "); <cyan>// neste ordem: inteiro, inteiro</cyan>
  <verd>scanf</verd>("%d %d %c %c %c %c %c %f %f", &i1, &i2, &c1, &c2, &c3, &c4, &c5, &x, &y);
  <cyan>// Experimente comentar a linha acima e testar com variacoes como abaixo (sera igual)</cyan>
  <cyan>// <verd>scanf</verd>("%d %d", &i1, &i2);</cyan>
  <cyan>// <verd>scanf</verd>("%c %c %c %c %c", &c1, &c2, &c3, &c4, &c5);</cyan>
  <cyan>// <verd>scanf</verd>("%f %f", &x, &y);</cyan>
  <verd>printf</verd>("i1=%d, i2=%d, c1=%c, c1=%c, c1=%c, c1=%c, c1=%c, x=%f, y=%f\n", i1, i2, c1, c2, c3, c4, c5, x, y);
  }</pre></td></tr>
</table></center>
</p>

<p>  
  Experimente copiar e colar cada um dos códigos acima em seu ambiente para programação <i>C</i> preferido.
  Procure alterar o código até que esteja certo de ter assimilado a sintaxe e os detalhes de cada conceito aqui explorado.
</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/>
  2020/08/17: primeira versão do texto
</p>

</div>