<!--
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 <stdio.h>
<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>