intr_prog/introducao_char.html

<!--
 Introdução à Programação - 2017 - Prof. Leoônidas de Oliveira Brandão
 Introdução aos caracteres
 LInE (Laboratory of Informatics in Education) - http://www.usp.br/line
 IME - USP
 Material didático
 Pode usar livrevemente este material para fins não comerciais, devendo sempre fazer referência à autoria.
 Sugestões/apontamento são bem vindos: leo@ime.usp.br (favor indicar no assunto "material de introducao 'a programacao")
 Prof. Leônidas de Oliveira Brandã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">


<p class="secao">Introdução aos caracteres</p>


<center><p>[
  <a href="#caracteres" title="Introdução aos caracteres">Erros</a> |
  <a href="#ascii" title="O código ASCII para representar caracteres">Código ASCII</a> |
  <a href="#io" title="Entrada/saída de caracteres">Entrada/saída</a></a>
 ]</p>
</center>


<p>
Nesta seção examinaremos resumidamente como utilizar caracteres tanto em <em>C</em> quanto em <em>Python</em>.
</p>


<a name="caracteres">
<p class="secao">Interpretando sequência de <i>bits</i> como número ou caractere</p>
</a>

<p>
  Como citado na seção sobre 
  <a href="#" onclick="trocaPagina('introducao_var.html')" title="variaveis">variáveis</a>, a informação básica
  nos computadores digitais é uma sequência de <i>bits</i> e o contexto é quem indica como estes <i>bits</i> devem ser interpretados.
  exemplo, a sequência <tt>1000001</tt> poderia ser interpretada como um valor inteiro (neste caso seria o valor
  <i>65 = 1*2<sup>6</sup>+1*2<sup>0</sup></i>) ou como um caractere (nesse caso a letra <i>A</i>, vide abaixo explicação
  sobre código <i>ASCII</i>).
  De modo semelhante, se a sequência <tt>110000</tt> deve ser interpretada como caractere, seria o dígito <i>0</i>,
  por outro lado, se for interpretada como inteiro (desconsiderando a questão do sinal), seria o
  <i>48 = 1*2<sup>5</sup>+1*2<sup>4</sup> = 32 + 16</i>).
  Ou seja, existe uma tabela associando valor numérico e caractere, como explicado na seção abaixo.
</p>

<p>
  Resumidamente o tratamento de dados em um computador digital, se resume à processar sequências de digitos.
  Assim, ao tentar examinar determinado dado em memória, deve-se saber em que posição da memória o dado está em um quanto <i>bits</i> tem tal dado.
  A figura ilustra isso, com 3 variáveis de tamanho 1 <i>bytes</i> (<i>a</i>, <i>b</i> e <i>c</i>) e uma ocupando 2 <i>bytes</i> (<i>x</i>).
  No caso de caracteres (símbolos que devem ser apresentados, como é o caso dos <i>dígitos</i> e das <i>letras</i>), basta existir
  uma <i>associação</i> (ou <i>mapeamento</i>) entre os <i>bits</i> e o símbolo a ser mostrado. Claro que está associação depende também do tamanho,
  quanto <i>bits</i> são usados para representar cada símbolo.
  Na seção seguinte apresento a primeira tabela de associação entre <i>bits</i> e símbolos, a
  <a href="#ascii" title="seguir para seção da tabela ASCII">tabela ASCII</a>.
</p>

<center>
  <img src="img/img_intr_char_memoria.png" title="Ilustracao de RAM com variável 'a' no endereço P, 'b' iniciando em P+1 e assim por diante"/>
  <br/>
  <i>Fig. 1. Representação da memória, com 3 variáveis usando 1 <i>bytes</i> (8 <i>bits</i>) e outra usando 2 <i>bytes</i>.</i>
</center>

<p>
  Mas o tratamento de números <i>reais</i> apresentam questões mais difíceis, para começar não existem valores que,
  por maior que seja a precisão do equipamento, seria impossível representá-los.
  Um exemplo simples é o valor correspondente à fração <i>1/3</i>, que é uma <i>dízima periódica</i>, portanto com
  dígitos (<i>0.3333...</i>).
  Além disso existe a dificuldade de representar número grande e número muito próximos de zero.
  O truque usual para <i>simular</i> reais (representação em <i>ponto flutuante</i>), estude esse assunto no texto sobre
  <a href="#" onclick="trocaPagina('introducao_float.html')" title="seguir para secao sobre ponto flutuante">representação em ponto flutuante</a>.
</p>



<a name="ascii">
<p class="secao">Código ASCII</p>
</a>

<p>
Um primeiro padrão para representar os caracteres é o 
<a href="https://en.wikipedia.org/wiki/ASCII" title="ver detalhes na WikiPedia"
   target="_blank" i><b>American Standard Code for Information Interchange</b></a>.
O padrão ASCII é bastante antigo, ainda da década de 1960 e por isso utiliza apenas 8 <i>bits</i> para representar todos os possíveis
caracteres, o que resultava em um número reduzidíssimo de 512 códigos/símbolos distintos.
</p>

<p>
Como o código ASCII foi baseado no alfabeto em lingua Inglesa, eles presentam apenas caracteres sem acentos.
Usualmente associamos um natural a cada símbolo, assim no ASCII pode-se associar caracteres aos <b>códigos ASCII</b>
0 até 512.
</p>

<p>
Como exemplos de código ASCII a letra 'A' é associada ao natural 65, o 'B' ao 66 e assim por diante.
Do mesmo modo, o 'a' é associada ao natural 97 e o caractere 'z' ao 122.
Já o natural 48 é associado do dígito '0', o 49 ao '1' e assim por diante até o 57 associado '9'.
</p>


<a name="io">
<p class="secao">Entrada e saída de caracteres em <i>C</i> e em <i>Python</i></p>
</a>

<p>
Como já citado nas outras seções, o contexto deve definir como sequências de <i>bits</i> devem ser tratadas.
Para tratar como caractere deve-se indicar isso ao computador de alguma forma.
Tanto a linguagem <i>C</i> como a linguagem <i>Python</i> dispõe um tipo especial variável para tratar com caracteres.
</p>

<p> 
Na linguagem <i>C</i> tem o tipo <tt>char</tt>, que precisa do formatador <tt>%c</tt>, mas pode-se imprimir uma
variável <tt>char</tt> como inteiro e vice-versa, neste caso usa-se seu código ASCII.
Já em <i>Python 2</i> é preciso de uma função especial para leitura (a <tt>raw_input()</tt>) e na impressão
não é preciso qualquer diferenciação, pois <i>Python</i> aplica um filtro para tratar se a variávem sendo impressa
é inteira, flutuante ou caractere. Vide  <a href="#tab2">tabela 1</a> abaixo.
</p>
<center>
<a name="tab2">
Tab. 1. Sobre a leitura de caracteres em <i>C</i> e em <i>Python</i></a>
<br/>
<table class="tbCodeLinCol">
 <tr><th>C </th> <th>Python 2</th> <th>Python 3</th></tr>
 <tr valign="top"><td><table class="tbCode">
   <tr><td><pre>char x; // declaracao de variavel em "ponto flutuante"
scanf("%c", &x); // leia como "caractere"
<verd>printf</verd>("%c", x); // imprima como "caractere"
</pre></td></tr>
 </table></td>
 <td><table class="tbCode"><pre># Vale notar: se o usuario digitar uma "string", como
# "nome", a variavel x recebera' a "string" toda
x = raw_input(); # leia como "caractere"
<verd>print</verd>(x);

</pre></td></tr>
   </table></td>
 <td><table class="tbCode"><pre># Vale notar: se o usuario digitar uma "string", como
# "nome", a variavel x recebera' a "string" toda
x = input(); # leia como "caractere"
<verd>print</verd>(x);

</pre></td></tr>
   </table></td>
   </tr>
</table></center>
</p>


<p>
Vale notar que para atribuir constantes do tipo caractere, é
necessário que um único caractere esteja cercado por aspas simples.
Por exemplo, para atribuir a constante 'a' à uma variável do tipo
caractere de nome <tt>varc</tt> deve-se usar: <tt>varc = 'a';</tt> (o
finalizador ';' é opcional em <i>Python</i>).
</p>

<p> 
Abaixo um exemplo de código que imprime primeiro o caractere associado ao código ASCII dado e depois
o contrário. Ao rodar este código será impresso os caracteres de código 48, 49, 97, 98, 65 e 66, respectivamente
'0', '1', 'a', 'b', 'A' e 'B'.
<center>
Tab. 2. Sobre conversão entre o caractere ASCII e seu código inteiro<br/>
<table class="tbCodeLinCol">
 <tr><th>C </th> <th>Python 2</th></tr>
 <tr valign="top"><td><table class="tbCode">
   <tr><td><pre>#include &lt;stdio.h&gt;
<verm>int</verm> main (void) {
  <verm>int</verm>          <cyan>// Criando 6 variaveis como (implicitamente) do tipo "int".</cyan>
    val1 = 48, <cyan>// Cada variavel recebera um valor inteiro que depois sera'</cyan>
    val2 = 49, <cyan>// interpretado como caractere.</cyan>
    num1 = 97, 
    num2 = 98, 
    Num1 = 65, 
    Num2 = 66; 
  <verm>char</verm>            <cyan>// Declarando variaveis tipo caractere</cyan>
    charN1 = '0', <cyan>// NOTE que para constantes do tipo</cyan>
    charN2 = '1', <cyan>// caractere, deve-se usar aspa simples</cyan>
    Char1  = 'A', 
    Char2  = 'B', 
    char1  = 'a', 
    char2  = 'b'; 
  <verd>printf</verd>(" int | codigo\n"); <cyan>// '\n' usado para forcar quebra de linha na impressao</cyan>
  <verd>printf</verd>("  %d | %c\n", val1, val1);
  <verd>printf</verd>("  %d | %c\n", val2, val2);
  <verd>printf</verd>("  %d | %c\n", num1, num1);
  <verd>printf</verd>("  %d | %c\n", num2, num2);
  <verd>printf</verd>("  %d | %c\n", Num1, Num1);
  <verd>printf</verd>("  %d | %c\n", Num2, Num2);
  <verd>printf</verd>(" int | codigo\n");
  <verd>printf</verd>(" %c | %d\n", charN1, charN1);
  <verd>printf</verd>(" %c | %d\n", charN2, charN2);
  <verd>printf</verd>(" %c | %d\n", char1,  char1);
  <verd>printf</verd>(" %c | %d\n", char2,  char2);
  <verd>printf</verd>(" %c | %d\n", Char1,  Char1);
  <verd>printf</verd>(" %c | %d\n", Char2,  Char2);
  return 0;
  }</pre></td></tr>
 </table></td>
 <td><table class="tbCode"><pre><verm>def</verm> main():
  val1 = 48 <cyan># Criando 6 variaveis como (implicitamente) do tipo "int".</cyan>
  val2 = 49 <cyan># Cada variavel recebera um valor inteiro que depois sera'</cyan>
  num1 = 97 <cyan># interpretado como caractere.</cyan>
  num2 = 98 
  Num1 = 65 
  Num2 = 66 
  <verd>print</verd>(" int | codigo")
  <verd>print</verd>(" ", val1, " | ", chr(val1)) <cyan># A funcao chr(...) devolve</cyan>
  <verd>print</verd>(" ", val2, " | ", chr(val2)) <cyan># o caractere associado ao</cyan>
  <verd>print</verd>(" ", num1, " | ", chr(num1)) <cyan># codigo ASCII dado</cyan>
  <verd>print</verd>(" ", num2, " | ", chr(num2))
  <verd>print</verd>(" ", Num1, " | ", chr(Num1))
  <verd>print</verd>(" ", Num2, " | ", chr(Num2))
  charN1 = '0' <cyan># NOTE que para constantes do tipo</cyan>
  charN2 = '1' <cyan># caractere, deve-se usar aspa simples</cyan>
  Char1 = 'A' 
  Char2 = 'B' 
  char1 = 'a' 
  char2 = 'b' 
  <verd>print</verd>(" int | codigo")
  <verd>print</verd>("  ", charN1, " | ", ord(charN1)) <cyan>#</cyan> A funcao ord(...) devolve</cyan>
  <verd>print</verd>("  ", charN2, " | ", ord(charN2)) <cyan>#</cyan> o codigo ASCII do caractere dado</cyan>
  <verd>print</verd>("  ", char1, " | ", ord(char1))
  <verd>print</verd>("  ", char2, " | ", ord(char2))
  <verd>print</verd>("  ", Char1, " | ", ord(Char1))
  <verd>print</verd>("  ", Char2, " | ", ord(Char2))
main()</pre></td></tr>
   </table></td></tr>
</table></center>
</p>

<p>
  <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/10: nova versão, sem a parte de "float";<br/>
  2019/07/31: acerto no formato da página e em várias frases;<br/>
  2017/05/01: versão inicial
</p>

</div>