Apostila de Algoritmos

Conceitos Bsicos de
Linguagem de Programao C


1

Sumrio

CAPTULO I Introduo.............................................................................1

Linguagens de Programao - Definio...............................................1

Programao em linguagem simblica ..................................................1

Lio 1 - Entrada/Sada .........................................................................2

Lio 2 - Variveis e Constantes............................................................7

Lio 3 - Operadores e funes matemticas .......................................11

Lio 4 - Estruturas condicionais - Decises if...else.............................15

Lio 5 - Estruturas condicionais - Decises switch...case....................19

Lio 6 - Estruturas de repetio ..........................................................22

Lio 7 - Desvios ...................................................................................26

CAPTULO II Trabalhando com tela em modo texto.................................29

CAPTULO III Trabalhando com tela em modo grfico.............................37

CAPTULO IV Arquivos de dados .............................................................47

APNDICE A- Funes diversas..................................................................58

APNDICE B- Tabela ASCII ........................................................................60


2
CAPTULO I
Introduo

Linguagens de Programao - Definio

Um computador uma mquina capaz de executar operaes, mas para que "ele" saiba o que e
como executar preciso programa-lo. Um programa de computador nada mais que um conjunto
de instrues, escrito atravs de uma linguagem prpria, que orienta o computador a realizar uma
determinada tarefa.
A nica linguagem que o computador "entende" a chamada Linguagem de Mquina, que
formada por um conjunto de cdigos numricos, prprios para comandar a mquina. Porm, estes
cdigos so extremamente complicados para o entendimento humano, por isso surgiram as
linguagens simblicas.
Uma linguagem simblica , na realidade, um conjunto de palavras e regras facilmente
compreendidas pelo homem, mas para que o computador as entenda existe a necessidade de uma
traduo para a linguagem de mquina. Este processo de traduo denominado "compilao".

Diagrama esquemtico do processo de criao de um programa:

(a) (b) (c)

(a) O programa fonte um arquivo "texto" digitado pelo programador. Este arquivo contm as instrues
necessrias para que o computador realize a tarefa desejada. Utiliza-se a linguagem simblica,
genericamente chamada de linguagem de programao.
(b) O programa fonte lido pelo compilador , que traduz as instrues da linguagem simblica para a
linguagem de mquina. Neste processo so apontados os eventuais erros existentes no programa fonte, e
enquanto houver erros o compilador no gerar o programa executvel (em linguagem de mquina),
neste caso o programador dever retornar ao editor e corrigir os erros apontados.
(c) Aps o processo de compilao, se no forem detectados erros, ser criado o programa executvel (em
linguagem de mquina). Este programa receber o sufixo .EXE e poder ser executado atravs do prompt
do MS-DOS.

Programao em linguagem simblica

A linguagem C uma linguagem simblica de fcil entendimento, que possui uma sintaxe bastante
estruturada e flexvel, tornando sua programao bem simplificada.
Para criarmos um programa, seja qual for a linguagem simblica utilizada, devemos primeiramente
definir um algoritmo capaz de resolver o problema. Na realidade o algoritmo a estratgia que
devemos utilizar para ordenar as idias que sero, posteriormente, convertidas em instrues. Uma
das ferramentas para a elaborao de algoritmos a pseudo-linguagem: uma forma de escrever as
instrues utilizando o portugus de maneira estruturada.

ATENO
Para que o estudo da linguagem C ganhe maior produtividade, esta apostila encontra-se dividida em
lies que partem de um nvel mais baixo at um nvel mais alto de complexidade. Trabalharemos
com exemplos prticos, onde, sempre que possvel, mostraremos o algoritmo em linguagem Inter-S
e o programa fonte correspondente em linguagem C. As instrues sero comentadas e
exemplificadas no final de cada lio.

Programa
Fonte
(em linguagem
simblica)
Compilador
Programa
executvel
(em linguagem
de mquina)

3
Lio 1 - Entrada/Sada

Objetivo: Criar um programa que leia 2 nmeros do teclado e mostre o resultado da soma dos
mesmos. (Nome do programa: LICAO1)

Soluo:
Algoritmo em Inter-S Programa fonte em Linguagem C
// Programa: Lio 1
// Autor : <nome-do-aluno>
// Data : 99/99/9999

Rotina
Declare valor1, valor2, resultado Numerico
Receba valor1
Receba valor2
Resultado = valor1 + valor2
Escreva resultado
FimRotina

/* Programa Licao1
Autor: <nome-do-aluno>
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>

main() {
int valor1, valor2, resultado;
scanf("%d",&valor1);
resultado = valor1 + valor2;
printf("%d",resultado);
}

Comentrios:

Observe que as primeiras linhas do algoritmo em Inter-S iniciam-se com duas barras (//). Estas
linhas no so reconhecidas como instrues, servem para introduzirmos comentrios quaisquer. Na
codificao em linguagem C os comentrios so colocados entre os caracteres /* e */. Observe que,
no nosso exemplo, estas linhas trazem uma pequena documentao do programa: nome (LICAO1),
autor (nome do programador) e data de criao, mas o programador poder escrever o que achar
necessrio para documentar o programa, desde que esta documentao se inicie com os caracteres
/* (barra-asterisco) e termine com os caracteres */ (asterisco-barra).

Em seguida, ainda observando a codificao do programa fonte, existem duas linhas que chamamos
de diretivas de compilao (#include <...>). Estas diretivas sero tratadas mais adiante, no momento
basta saber que elas sero necessrias para que o programa funcione adequadamente.

As linhas seguintes expressam o algoritmo propriamente dito. Na linguagem Inter-S determinamos o
incio do algoritmo com a palavra Rotina, que expresso como main() { na codificao em
linguagem C; o final da rotina dado pela expresso FimRotina que na codificao em linguagem C
aparece como um fechamento de chave ( } ).
Veja abaixo a descrio das demais linhas do algoritmo Inter-S e o formato correspondente em
linguagem C:

Declare valor1, valor2, resultado Numrico
A expresso Declare processa a declarao das variveis que sero utilizadas pela rotina.
Definimos os nomes das variveis e o tipo de dado que elas armazenaro. Neste exemplo
estamos declarando as variveis valor1, valor2 e resultado, as quais recebero dados
numricos.
O formato desta instruo em linguagem C o seguinte:


Onde int indica que as variveis da lista sero numricas inteiras (sem decimais).

4
Receba valor1
Esta instruo determina a leitura da entrada padro (no nosso caso o teclado), e coloca o
contedo lido na varivel especificada: valor1. Em outras palavras, esta instruo aguarda que
um dado seja digitado, colocando-o na varivel valor1.
Instruo correspondente em linguagem C:


Onde scanf uma funo para a leitura do teclado. Entre parnteses indicamos o tipo da
informao a ser lida: "%d" (indica que o dado ser numrico), aps a vrgula informamos qual
a varivel que receber o dado: &valor1. (o smbolo & um ponteiro necessrio neste caso, que
permite a alocao do valor da varivel em um endereo especfico de memria).

Receba valor2
Instruo idntica anterior, mudando apenas a varivel que receber a informao: valor2.


Esta uma instruo de atribuio: efetuado um clculo (valor1+valor2) e o resultado
colocado na varivel resultado, ou seja, a varivel resultado receber a soma dos contedos das
variveis valor1 e valor2.


Escreva resultado
Esta instruo envia uma informao para a sada padro (no nosso caso o vdeo). Escreva
resultado faz com que o contedo da varivel resultado seja escrito no vdeo.


Onde printf uma funo para a escrita em tela. Entre parnteses indicamos o tipo da
informao a ser escrita: "%d" (indica que o dado numrico), aps a vrgula informamos qual
a varivel cujo contedo ser exibido: resultado.

Nota importante: Toda linha de instruo em linguagem C deve ser finalizada com um ponto-e-
vrgula (;)

Digitando o programa fonte e criando o cdigo executvel

Um programa em linguagem simblica pode ser digitado atravs de qualquer editor que gere textos
no formatados. Podemos utilizar, por exemplo, o EDIT do MS-DOS ou o Bloco de Notas do
Windows, porm, a linguagem C nos oferece um editor prprio onde, alm de digitarmos o
programa, podemos compila-lo gerando o programa executvel. A seguir esto descritos os
procedimentos para que voc digite e compile o programa LICAO1:

5

- Aps iniciar o Windows e efetuar o login, v para o prompt do MS-DOS;

- Digite o seguinte comando: CD\TC201 e tecle <enter> ;

- Digite TC e tecle <enter>. Isto far com que o editor da linguagem C seja executado. Inicie a
digitao do programa fonte. Digite o programa LICAO1 da mesma forma que ele est
apresentado na pgina 2, mas para voc no precisar virar a pgina, cuidamos de reproduzi-lo
abaixo:

/* Programa Licao1
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>

main() {
}

Obs.: Letras maisculas e minsculas so interpretadas de forma diferente pelo compilador C, portanto,
digite as instrues acima da mesma maneira que esto apresentadas.

- Aps a digitao grave o programa utilizando o comando FILE /SAVE . Ser solicitado o nome
com o qual o arquivo ser gravado, digite LICAO1.C (todo programa fonte em linguagem C deve
possuir sufixo .C)

- Execute o programa atravs do comando RUN/RUN. No caso de existirem erros de digitao, o
programa no ser executado. Neste caso o interpretador acusar as linhas erradas. Aps o
acerto das mesmas repete-se o processo de execuo. Para criar o programa executvel use o
comando COMPILE/MAKE EXE FILE.

- Saia do editor executando o comando FILE / EXIT. No prompt do MS-DOS voc poder verificar
que um arquivo com nome LICAO1.EXE foi criado (utilize o comando DIR). Este arquivo o
programa executvel. Para faz-lo funcionar basta digitar LICAO1 e teclar <enter>.

Implementando novos comandos no programa LICAO1

Voc percebeu que, do ponto de vista esttico, o programa ficou "feio". A tela no foi apagada e no
existem informaes sobre o que fazer. O usurio quando executar este programa no saber o que
deve ser feito. Devemos, portanto, introduzir algumas instrues para melhorar o visual e tornar o
programa mais "amigvel". Observe como ficar o programa com a colocao dessas novas
instrues:

6

// Programa: Lio 1
// Data : 99/99/9999

Rotina
Declare valor1, valor2, resultado Numerico
Limpa
Escreva "Programa LICAO1"
Escreva "Digite o 1
valor:"
Receba valor1
Escreva "Digite o 2
valor:"
Receba valor2
Escreva "Soma dos valores:"
Escreva resultado
FimRotina

/* Programa Licao1
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>

main() {
clrscr();
printf("Programa LICAO1\n");
printf("Digite o 1
valor:");
printf("Digite o 2
valor:");
printf("Soma dos valores:");
}

As novas instrues:

Limpa
Faz com que a tela seja "apagada", ou seja, deixa a tela totalmente limpa. importante o uso dessa
instruo para evitar a poluio visual da aplicao. A funo correspondente em linguagem C :
clrscr();

Escreva "Programa LICAO1"
J vimos que a instruo Escreva faz com que algo seja escrito na tela. Quando a expresso a ser
escrita aparece entre aspas significa que queremos que o texto seja colocado na tela da mesma
forma em que foi escrito. Neste caso, estamos instruindo o computador a escrever a expresso
Programa LICAO1 no vdeo. Instruo correspondente em linguagem C:

printf("Programa LICAO1\n");

Dizemos que a expresso que aparece entre aspas uma constante alfanumrica.
Observe que no final da constante foram colocados os caracteres \n (barra invertida e letra n). Em
linguagem C isto significa que deve ser "saltada" uma linha aps o texto escrito. Se estes caracteres
forem omitidos, a prxima instruo de escrita far a exibio do texto na mesma linha da anterior.

As outras instrues introduzidas so instrues tambm de escrita: Escreva (printf), que tm o
mesmo formato da descrita acima.

Faa as implementaes sugeridas em seu programa fonte (LICAO1.C), compile e execute-o
novamente. Observe as melhorias!


7

Exerccios de fixao

a) Elabore um programa em linguagem C para receber trs nmeros pelo teclado e exibir a mdia
aritmtica dos mesmos. D-lhe o nome de EXERC1A. (Faa o algoritmo em Inter-S e a
codificao em linguagem C). Para calcular a mdia utilize a seguinte frmula:

(Valor1 + Valor2 + Valor3) / 3

Note que o operador de diviso representado por uma barra (/). Utilize-a tanto na linguagem Inter-
S como na codificao do programa em linguagem C. Os parnteses determinam a prioridade do
clculo, neste caso temos que a soma dos valores ser executada antes da operao de diviso.

b) Elabore um programa para exibir o quadrado de um nmero digitado D-lhe o nome de
EXERC1B. (Faa o algoritmo em Inter-S e a codificao em linguagem C).

Neste exerccio voc dever utilizar a operao de multiplicao, cujo operador um asterisco (*).


8
Lio 2 - Variveis e Constantes

O programa proposto na lio 1 trabalhou com trs variveis: valor1, valor2 e resultado.
Percebemos, intuitivamente, que as variveis so necessrias para que um programa receba e
processe informaes. Mas o que so na realidade?
Nesta lio explicaremos o que so e como utiliza-las dentro de um programa.

! Variveis so posies de memria que o computador reserva para armazenar os dados
manipulados pelo programa. Estas posies devem ser reservadas (declaradas) no incio do
programa, a partir da ficam disponveis para receberem qualquer contedo. Este contedo pode ser
alterado quando necessrio (da o nome varivel, pois o contedo pode variar).

Na declarao de uma varivel, devemos informar o nome da mesma (identificador) e qual o tipo
de dado que ela receber.

Os nomes ou identificadores devem obedecer s seguintes regras de construo:

Devem comear por uma letra (a - z , A - Z) ou um underscore ( _ ).
O resto do identificador deve conter apenas letras, underscores ou dgitos (0 - 9). No pode
conter outros caracteres. Em C, os identificadores podem ter at 32 caracteres.
Letras maisculas so diferentes de letras minsculas: Por exemplo: MAX, max, Max so nomes
diferentes para o compilador.

Ao "batizarmos" uma varivel, ou seja, ao atribuirmos um nome uma varivel, devemos escolher
um nome sugestivo, que indique o contedo que ela receber. Por exemplo:
Valor1 " Varivel que armazenar o primeiro valor
Valor2 " Varivel que armazenar o segundo valor
Resultado " Varivel que armazenar o resultado de um clculo qualquer

claro que o programador ter toda a liberdade de escolher o nome que quiser, mas imagine se
uma varivel que deva receber o valor de um produto tiver como nome Ze_Mane ? Tecnicamente
no teria problema algum, pois o nome Ze_Mane est dentro das regras da linguagem, porm, no
tocante documentao do programa, teramos um grande problema. Neste caso o programa
estaria melhor documentado se o nome da varivel fosse, por exemplo, Valor_produto.

Aps atribuir o nome devemos indicar o tipo de informao que a varivel vai receber. Temos,
basicamente, dois tipos: variveis numricas e variveis alfanumricas.

Variveis numricas: So definidas para receberem dados numricos, ou seja, nmeros que
podero ser utilizados em clculos diversos.
A linguagem C classifica os dados numricos em: inteiro, ponto flutuante e dupla preciso.
Uma varivel numrica inteira pode receber um valor inteiro entre -32768 a 32767.
Uma varivel numrica de ponto flutuante pode receber um nmero real de at 7 dgitos.
Uma varivel numrica de dupla preciso pode receber um nmero real de at 15 dgitos.

Variveis alfanumricas: So definidas para receberem dados do tipo texto ou caractere. Podem
armazenar letras, caracteres especiais, nmeros, ou a combinao de todos eles, porm, nunca
podero ser utilizadas em clculos, pois a caracterstica deste tipo meramente "texto".
Quando definirmos uma varivel alfanumrica em linguagem C, devemos indicar tambm o tamanho
da mesma, ou seja, quantos caracteres ela poder comportar.

! Constantes: Assim como as variveis, so posies de memria que armazenam contedos
numricos ou alfanumricos. As formas e regras para a construo de constantes so as mesmas
das variveis, a nica diferena est no conceito de funcionamento: uma constante recebe um
contedo inicial que no sofre alterao durante a execuo do programa ( um contedo
constante!).

9

O programa LICAO2, apresentado abaixo, mostra os formatos das instrues para a declarao de
variveis e constantes, tanto em Inter-S como em linguagem C:

// Programa: Lio 2
// Data : 99/99/9999

Rotina
Declare produto Caractere
Declare qtde Numerico
Declare preco Numerico
Declare total Numerico
Limpa
Escreva "Digite o nome do produto:"
Receba produto
Escreva "Digite o preco do produto:"
Receba preco
Escreva "Digite a quantidade:"
Receba qtde
total = qtde * preco
Escreva "O valor total do produto "
Escreva produto
Escreva " : "
Escreva total
FimRotina

/* Programa Licao2
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>

main() {
char produto[10];
int qtde;
float preco;
double total;
clrscr();
printf("Digite o nome do produto:");
scanf("%10s",produto);
printf("Digite o preco do produto:");
scanf("%f",&preco);
printf("Digite a quantidade:");
scanf("%d",&qtde);
total = qtde * preco;
printf("O valor do produto ");
printf(produto);
printf(" : ");
printf("%f",total);
}

Comentrios:

O programa apresentado solicitar pelo teclado o nome do produto (que poder ter no mximo 10
caracteres), o preo do produto (numrico real de 7 dgitos) e a quantidade (numrico inteiro). Far o
clculo: quantidade x preo, colocando o resultado na varivel total (numrico real de 15 dgitos).
Finalmente exibir no vdeo o valor total do produto.
Para uma melhor compreenso do programa, vamos analisa-lo linha a linha:

Programa fonte em Linguagem C Comentrios
/* Programa Licao2
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>

main() {
char produto[10];
int qtde;
float preco;
double total;
clrscr();
printf("Digite o nome do produto:");
printf("Digite o preco do produto:");
scanf("%f",&preco);
printf("Digite a quantidade:");
scanf("%d",&qtde);
total = qtde * preco;

Documentao
Documentao
Documentao
Final da documentao
Diretiva de compilao
Diretiva de compilao

Rtulo da rotina principal
Declara a varivel produto como alfanumrica de 10 caracteres
Declara a varivel qtde como numrica inteira
Declara a varivel preco como numrica real de 7 dgitos
Declara a varivel total como numrica real de 15 dgitos
Limpa a tela
Escreve na tela a expresso "Digite o nome do produto"
Recebe pelo teclado o contedo da varivel produto
Escreve na tela a expresso "Digite o preo do produto"
Recebe pelo teclado o contedo da varivel preco
Escreve na tela a expresso "Digite a quantidade"
Recebe pelo teclado o contedo da varivel qtde
Calcula qtde x preco e coloca o resultado na varivel total
Escreve na tela a expresso "O valor do produto "

10
printf("O valor do produto ");
printf(produto);
printf(" : ");
printf("%f",total);
}

Escreve na tela o contedo da varivel produto
Escreve na tela a expresso " : "
Escreve na tela o contedo da varivel total
Finaliza a rotina principal

As novas instrues:

Observe que as novidades existentes no programa LICAO2 esto presentes nas declaraes das
variveis e nas formas de solicit-las pelo teclado (scanf) e escrev-las no vdeo (printf).
No momento da declarao de uma varivel devemos inicialmente informar o tipo de dado que ela
receber, utilizando um dos seguintes identificadores de tipo:

Char " Declara a varivel como alfanumrica
Int " Declara a varivel como numrica inteira
Float " Declara a varivel como numrica real de 7 dgitos
Double " Declara a varivel como numrica real de 15 dgitos

No caso da declarao de uma varivel do tipo alfanumrica, devemos indicar aps o nome da
mesma, a quantidade de caracteres que ela suportar. Esta quantidade expressa entre colchetes -
[ ]. Na omisso desta definio, a varivel suportar apenas um caracter. Exemplos:

Char produto[10]; " Declara a varivel produto como alfanumrica com o tamanho de 10
caracteres.
Char resposta; " Declara a varivel resposta como alfanumrica com o tamanho de 1
caractere.

A funo scanf (recebimento de dados pelo teclado) tambm deve ser ajustada de acordo com o
tipo de informao. Observe a instruo abaixo:


No programa, esta instruo tem a finalidade de receber o contedo da varivel produto. Note que
devemos informar o tipo e o tamanho do dado atravs da expresso "%10s", onde o nmero 10
indica o tamanho e a letra s indica que a varivel uma String (o nome utilizado para identificar uma
varivel alfanumrica com tamanho superior a 1 caractere).

Na tabela abaixo encontramos a relao dos formatos para a declarao, recebimento pelo teclado
(scanf) e escrita no vdeo (printf) dos diversos tipos de dados:

Formato da declarao Formato do scanf Formato do printf

int numero;
float numero;
double numero;
char letra;
char texto[20];

scanf("%d",&numero);
scanf("%f",&numero);
scanf("%f",&numero);
scanf("%c",&letra);
scanf("%20s",texto);

printf("%d",numero);
printf("%f",numero);
printf("%f",numero);
printf("%c",letra);
printf(texto);


11
Exerccios de fixao

a) Elabore um programa em linguagem C para receber as seguintes informaes:

Nome : Alfanumrico de 15 caracteres;
Dia do nascimento: Numrico inteiro;
Ms do nascimento: Numrico inteiro;
Ano do nascimento: Numrico inteiro;
Valor da mesada: Numrico real de 7 dgitos.

Aps o recebimento destas informaes, o programa dever apagar a tela e escrev-las no
vdeo.
D o nome EXERC2A ao programa. (Faa o algoritmo em pseudo-linguagem e a codificao
em linguagem C).

b) Implemente o programa EXERC2A para mostrar no final a renda anual (valor da mesada
multiplicado por 12). Grave-o como EXERC2B.


12
Lio 3 - Operadores e funes matemticas

Nas lies anteriores tivemos a oportunidade de trabalhar com algumas operaes matemticas:
adio, multiplicao e diviso. Nesta lio estudaremos, alm dos operadores, algumas funes
matemticas importantes disponveis na linguagem C.

Operadores
Existem cinco operadores aritmticos em C. Cada operador aritmtico est relacionado a uma
operao aritmtica elementar: adio, subtrao, multiplicao e diviso. Existe ainda um operador
(%) chamado operador de mdulo cujo significado o resto da diviso inteira. Os smbolos dos
operadores aritmticos so:

Operador Operao
+ adio.
- subtrao.
* multiplicao
/ diviso
% mdulo (resto da diviso inteira)

Exemplo: Algumas expresses aritmticas:
1+2 a-4.0 b*c valor_1/taxa num%2

Os operandos das expresses aritmticas devem ser constantes numricas ou identificadores de
variveis numricas. Os operadores +, -, * e / podem operar nmeros de todos os tipos
(inteiros ou reais) porm o operador % somente aceita operandos inteiros.

Exemplo: Expresses vlidas
Expresso Valor
6.4 + 2.1 8.5
7 - 2 5
2.0 * 2.0 4.0
6 / 3 2
10 % 3 1

Uma restrio ao operador de diviso (/) que o denominador deve ser diferente de zero. Se
alguma operao de diviso por zero for realizada ocorrer um erro de execuo do programa (run-
time error), o programa ser abortado e a mensagem divide error ser exibida.

Quando mais de um operador se encontram em uma expresso aritmtica as operaes so
efetuadas uma de cada vez respeitando algumas regras de precedncia: Estas regras de
precedncia so as mesmas da matemtica elementar.
Os operadores de multiplicao (*), diviso (/) e mdulo (%) tem precedncia sobre os operadores
de adio (+) e subtrao (-). Entre operadores de mesma precedncia as operaes so efetuadas
da esquerda para a direita.

Exemplo: Observe, nas expresses abaixo, o seu valor e a ordem das operaes efetuadas:
Expresso Valor Ordem
1 + 2 - 3 0 + -
24 - 3 * 5 9 * -
4 - 2 * 6 / 4 + 1 2 * / - +
6 / 2 + 11 % 3 * 4 11 / % * +

A ordem de precedncia dos operadores pode ser quebrada usando-se parnteses: ( ). Os
parnteses so, na verdade, operadores de mais alta precedncia e so executados primeiro.
Parnteses internos so executados primeiro que parnteses externos.

13

Exemplo: Observe, nas expresses abaixo, o seu valor e a ordem das operaes efetuadas:
Expresso Valor Ordem
1 + (2 - 3) 0 - +
(24 - 3) * 5 105 - *
(4 - 2 * 6) / 4 + 1 -1 * - / +
6 / ((2 + 11) % 3) * 4 24 + % / *

Observe que os operadores e os operandos deste exemplo so os mesmos do exemplo anterior. Os
valores, porm, so diferentes pois a ordem de execuo das operaes foi modificada pelo uso dos
parnteses.

O Programa LICAO3A, apresentado abaixo, demonstra algumas operaes matemticas. Ele solicita
o valor do salrio bruto e um percentual de desconto, calcula e exibe o valor do salrio lquido:

// Programa: Lio3A
// Data : 99/99/9999

Rotina
Declare bruto, liq, perc Numerico
Limpa
Escreva "Digite o salario bruto: "
Receba bruto
Escreva "Digite o percentual: "
Receba perc
liq = bruto-(bruto*perc/100)
Escreva "Salario liquido: "
Escreva liq
FimRotina

/* Programa Licao3A
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>

main() {
float bruto, liq, perc;
clrscr();
printf("Digite o salario bruto:");
scanf("%f",&bruto);
printf("Digite o percentual:");
scanf("%f",&perc);
liq = bruto-(bruto*perc/100);
printf("Salario liquido: ");
printf("%f",liq);
}

Comentrios:

Observe a instruo para o clculo do salrio lquido:

liq = bruto-(bruto*perc/100);

A utilizao de parnteses necessria neste caso. Eles determinam a prioridade do clculo:
primeiramente efetuada a operao: bruto*perc/100 (pois est entre parnteses), o resultado,
em seguida, subtrado de bruto.

Funes
Uma funo um sub-programa (tambm chamado de sub-rotina). Esta sub-rotina recebe
informaes, as processa e retorna outra informao. Por exemplo, podemos ter uma funo que
receba um valor numrico, calcule sua raiz quadrada e retorne o valor obtido. Existem dois tipos de
funes: funes de biblioteca e funes de usurio. Funes de biblioteca so funes escritas
pelos fabricantes do compilador e j esto pr-compiladas, isto , j esto escritas em cdigo de
mquina. Funes de usurio so funes escritas pelo programador. Nesta lio trataremos
somente das funes de biblioteca.

14

Para podermos usar uma funo de biblioteca devemos incluir a biblioteca na compilao do
programa. Esta incluso feita com o uso da diretiva #include colocada antes da rotina principal,
como j observamos nos programas anteriores.

Vejamos algumas funes matemticas da biblioteca math.h:

Funes trigonomtricas do ngulo arco, em radianos:
sin(arco); // seno
cos(arco); // coseno
tan(arco); // tangente
asin(arco); // arco-seno
acos(arco); // arco-coseno
atan(arco); // arco-tangente

Funcoes de arredondamento:
ceil(num) ; // Exemplo: ceil(3.2) == 3.0;
floor(num) ; // Exemplo: floor(3.2) == 4.0;

Funes diversas:
log(num); // Logaritmo natural (base e)
log10(num); // Logaritmo decimal (base 10)
pow(base, exp); // Potenciacao: pow(3.2,5.6)=3.2
5.6
.
sqrt(num); // Raiz quadrada: sqrt(9.0)=3.0.

Para utilizar uma destas funes introduza a linha de comando #include <math.h> no cabealho
de seu programa. A partir deste momento voc poder, dentro de qualquer rotina, utilizar qualquer
funo da biblioteca math.h. O programa abaixo exemplifica a utilizao de funes matemticas.
Ele solicita um nmero pelo teclado, calcula e mostra a raiz quadrada e o cubo deste nmero:

// Programa: Lio3B
// Data : 99/99/9999

Rotina
Declare num, resultado Numerico
Limpa
Escreva "Digite um nmero: "
Receba num
resultado = raiz(num)
Escreva "Raiz Quadrada do nmero: "
Escreva resultado
resultado = num^3
Escreva "Cubo do nmero: "
Escreva resultado
FimRotina
/* Programa Licao3B
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>
#include <math.h>

main() {
float num, resultado;
clrscr();
printf("Digite um nmero: ");
scanf("%f",&num);
resultado = sqrt(num);
printf("Raiz quadrada do nmero: ");
printf("%f",resultado);
resultado = pow(num,3);
printf("\nCubo do nmero: ");
}

Nota: A linguagem Inter-S no possui diretivas, pois todas as funes j esto includas no
compilador.

15

Exerccios de fixao

a) Elabore um programa em linguagem C que receba as variveis numricas de ponto flutuante
(float) w e z e mostre o resultado das seguintes expresses matemticas:

w + z (w+100) x V z V w
2
+ z
2

2 w

Obs: Grave o programa fonte como EXERC3.

3
a1)
a2) a3)

16
Lio 4 - Estruturas condicionais - Decises if...else

Todos os programas vistos at agora continham instrues que eram executadas em uma seqncia
linear, ou seja, as instrues eram executadas uma a uma, de cima para baixo, incondicionalmente.
Uma estrutura condicional permite que o programa faa a escolha do que executar, de acordo com
uma condio. A linguagem C nos oferece comandos para trabalharmos com dois tipos de
estruturas condicionais: if...else e switch...case. Nesta lio estudaremos a estrutura if...else.

Estrutura de deciso if...else (se...ento...seno)
A estrutura if...else a mais simples estrutura de controle do C. Esta estrutura permite executar um
entre vrios blocos de instrues. O controle de qual bloco ser executado dado por uma condio
(expresso lgica ou numrica). Esta estrutura pode se apresentar de dois modos diferentes:
condicional simples ou composta.

Condicional simples - Deciso de um bloco (if...)
A estrutura de deciso de um bloco permite que se execute (ou no) um bloco de instrues
conforme o valor de uma condio seja verdadeiro ou falso. O fluxograma desta estrutura
mostrado na figura 4.1.
condio
bloco
V
F

Figura 4.1: Fluxograma da estrutura de deciso if...

O programa LICAO4A ilustra a utilizao de uma estrutura condicional simples. O programa
receber pelo teclado um nmero, se o nmero for positivo ser calculada e mostrada sua raiz
quadrada, caso contrrio, ou seja, se o nmero for negativo, nada ser feito:

// Programa: Lio4A
// Data : 99/99/9999

Rotina
Declare num, resultado Numerico
Limpa
Receba num
Se num > = 0 entao
resultado = raiz(num)
Escreva "Raiz quadrada: "
Escreva resultado
FimSe
FimRotina
/* Programa Licao4A
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>
#include <math.h>

main() {
float num, resultado;
clrscr();
scanf("%f",&num);
if(num >= 0) {
printf("Raiz Quadrada: ");
}
}


17
A estrutura de deciso demonstrada tem como primeiro comando a avaliao de uma expresso:
Se num >= 0, em seguida encontram-se os comandos que sero executados caso a avaliao seja
verdadeira. Este bloco de comandos finalizado com a instruo FimSe. Observe o uso da
edentao, ou seja, o bloco de comandos encontra-se alinhado a partir de uma margem mais
direita. Este procedimento necessrio para garantir um melhor entendimento do algoritmo.
Note que na codificao em linguagem C o bloco de comandos que ser executado no caso da
condio ser verdadeira encontra-se entre chaves ( { } ), observe tambm que utilizamos a
edentao na codificao em linguagem C.
Reproduzimos abaixo a estrutura de deciso utilizada no programa LICAO4A:

if(num >= 0) {
printf("Raiz Quadrada: ");
}

O comando if (se) processa a avaliao da expresso que se encontra entre parnteses, que no
nosso caso : num > = 0 (na realidade feita uma pergunta: num maior ou igual a zero?). Se a
resposta for verdadeira o bloco de instrues que se encontra entre chaves ser executado; caso a
resposta seja falsa, ou seja, se num no for maior ou igual a zero, o bloco no ser executado.

Condicional composta: Deciso de dois blocos (if...else)
Tambm possvel escrever uma estrutura que execute um entre dois blocos de instrues. A figura
4.2 mostra o fluxograma correspondente a esta estrutura de deciso.

condio?
bloco 1 bloco 2

Figura 4.2: Fluxograma da estrutura de deciso if...else

O programa LICAO4B, apresentado a seguir, ilustra a utilizao de uma estrutura condicional
composta. O programa receber pelo teclado um nmero, se o nmero for par ser exibida a
mensagem "Nmero par", caso contrrio ser exibida a mensagem "Nmero mpar":

// Programa: Lio4B
// Data : 99/99/9999

Rotina
Declare num, resto Numerico
Limpa
/* Programa Licao4B
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>
#include <math.h>

main() {
int num, resto;
clrscr();
S N

18
Receba num
resto = num mod 2
Se resto = 0 entao
Escreva "Nmero par"
Senao
Escreva "Nmero mpar"
FimSe
FimRotina
scanf("%d",&num);
resto = num % 2;
if(resto = = 0) {
printf("Nmero par");
} else {
printf("Nmero mpar");
}
}

Inicialmente devemos esclarecer o processo utilizado para descobrir se o nmero par ou mpar.
Sabemos que nmeros pares so mltiplos de 2, portanto, se dividirmos um nmero par por 2
teremos 0 (zero) como resto da diviso. Se o nmero for mpar, teremos 1 (um) como resto da
diviso por 2. Observe os exemplos abaixo:

16 dividido por 2 igual a 8, com resto 0 (zero) - indica nmero par.

15 dividido por 2 igual a 7, com resto 1 (um) - indica nmero mpar.

J vimos que em linguagem C temos um operador matemtico que nos retorna o resto de uma
diviso: o operador mdulo, representado pelo caracter %. As divises acima podem ser
representadas em C da seguinte forma:

resto = 16 % 2 " a varivel resto receber contedo 0 (zero), pois no existe resto nesta diviso.
resto = 15 % 2 " a varivel resto receber contedo 1 (um), pois o resto da diviso 1.

Observe no programa LICAO4B que a estrutura de deciso contm dois blocos de comandos. O
primeiro encontra-se logo aps o comando if, e o segundo aps o comando else:

if(resto = = 0) {
printf("Nmero par");
} else {
printf("Nmero mpar");
}

Neste trecho do programa, primeiramente feita a pergunta: resto = 0 ?. Se a resposta for
verdadeira ser executado o primeiro bloco: printf("Nmero par") , caso contrrio, ou seja, se
o resto no for igual a zero, ser executado o bloco definido logo aps o comando else:
printf("Nmero mpar"). Observe que os dois blocos so delimitados por chaves { }.

Para concluirmos esta lio, estudaremos os operadores relacionais lgicos, os quais nos permite
a construo das expresses condicionais requeridas pelo comando if. Nos exemplos desta lio,
utilizamos os operadores relacionais de igualdade (= =) e maior ou igual (>=). Vamos conhecer os
demais:
15 2
1 7
16 2
0 8

19

Operadores relacionais
Nas expresses que so avaliadas pelo comando if, utilizamos operadores de relao, os quais
nos permite verificar se um determinado valor igual ou no a um outro, se maior ou menor, etc.
Operadores relacionais verificam a relao de magnitude e igualdade entre dois valores. So seis
os operadores relacionais em C:

Operador Significado
> maior que
< menor que
>= maior ou igual a (no menor que)
<= menor ou igual a (no maior que)
= = igual a
!= no igual a (diferente de)

Operadores lgicos
At aqui ainda no tivemos a oportunidade de utilizar os operadores lgicos. So operadores que
utilizam a lgica booleana para a construo de expresses condicionais. Por exemplo: se eu quiser
que uma determinada rotina seja executada somente quando os valores de duas variveis (x e y)
sejam iguais a zero, eu construo a seguinte expresso:

Pseudo-linguagem Linguagem C
Se x = 0 e y = 0 entao ... if (x = = 0 && y = = 0) { ...

Por outro lado, se eu quiser que uma determinada rotina seja executada quando o valor de uma das
duas variveis seja igual a zero, ou seja, se x for igual a zero ou y for igual a zero, eu construo a
seguinte expresso:

Pseudo-linguagem Linguagem C
Se x = 0 ou y = 0 entao ... if (x = = 0 y = = 0) { ...

So trs os operadores lgicos da linguagem C: &&, e !. Estes operadores tm a mesma
significao dos operadores lgicos Booleanos AND, OR e NOT.

Exerccio de fixao

Elabore um programa em linguagem C que receba um ano (numrico inteiro) e informe se o ano
bissexto ou no (anos bissextos so mltiplos de 4, portanto, se a diviso do ano por 4 gerar resto
igual a zero, o ano bissexto - use o operador %). Grave o programa como EXERC4.


20
Lio 5 - Estruturas condicionais - Decises switch...case

A estrutura switch...case uma estrutura de deciso que permite a execuo de um conjunto de
instrues a partir de pontos diferentes, conforme o resultado de uma expresso de controle. O
resultado desta expresso comparado ao valor de cada um dos rtulos, e as instrues so
executadas a partir desde rtulo. A figura 5.1 mostra o fluxograma lgico desta estrutura.

conjunto 1
conjunto N
conjunto 2
conjunto D
...
expresso
rotulo 1
rotulo N
default
rotulo 2

Figura 5.1: Fluxograma da estrutura switch...case.

O valor de expresso avaliado e o fluxo lgico ser desviado para o conjunto cujo rtulo igual ao
resultado da expresso e todas as instrues abaixo deste rtulo sero executadas. Caso o
resultado da expresso for diferente de todos os valores dos rtulos ento conjunto d executado.
Os rtulos devem ser expresses constantes diferentes entre si. O rtulo default opcional.

Esta estrutura particularmente til quando se tem um conjunto de instrues que se deve executar
em ordem, porm pode-se comear em pontos diferentes.

O programa LICAO5A, demonstrado a seguir, ilustra o uso da instruo switch em um menu de
seleo. Neste exemplo, o programa iniciar o processo de preparao de um bolo a partir de um
estgio qualquer dependendo do valor recebido:

21

// Programa: Lio5A
// Data : 99/99/9999

Rotina
Declare selecao Numerico
Limpa
Escreva "Selecione o estgio:"
Receba selecao
Caso selecao
Seja =1 faca Escreva "Obter ingredientes"
Seja =2 faca Escreva "Juntar"
Seja =3 faca Escreva "Bater a massa"
Seja =4 faca Escreva "Colocar na forma"
Seja =5 faca Escreva "Levar ao forno"
CasoNao faca Escreva "Fim"
FimCaso
FimRotina
/* Programa Licao5A
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>

main() {
int selecao;
clrscr();
printf("Selecione o estgio: ");
scanf("%d",&selecao);
switch(selecao) {
case 1:printf("Obter ingredientes\n");
case 2:printf("Juntar \n");
case 3:printf("Bater a massa\n");
case 4:printf("Colocar na forma\n");
case 5:printf("Levar ao forno\n");
default:printf("Fim\n");
}
}

Neste exemplo, o programa recebe um nmero que corresponde seleo do estgio. Se a varivel
selecao receber valor 1, ento sero executados os procedimentos a partir do rtulo case 1; se
selecao receber valor 2, sero executados os procedimentos a partir do rtulo case 2, e assim por
diante. Observe que existem 5 rtulos (case 1 a case 5) e um rtulo default, se a varivel selecao
receber um contedo fora do intervalo de 1 a 5, somente o procedimento aps o rtulo default ser
executado. Lembramos que o rtulo default opcional, ou seja, o programador pode utiliza-lo ou
no.
Na codificao em Inter-S, observaremos que somente uma das instrues SEJA ser executada,
caracterstica que difere da estrutura switch da linguagem C.

A instruo break.
Existem situaes em uma estrutura de deciso switch...case em que desejamos que somente um
procedimento seja executado (como ocorre normalmente com a instruo CASO no Inter-S). Para
esta finalidade utilizamos a instruo break, a qual faz com que a execuo da estrutura seja
encerrada aps a execuo do procedimento selecionado. O programa LICAO5B, demonstrado a
seguir, ilustra a utilizao de uma estrutura switch...case que executa apenas um dos
procedimentos rotulados.

Programa fonte em Linguagem C
/* Programa Licao5B
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>

main() {
int selecao;
clrscr();
printf("Selecione o estgio: ");
scanf("%d",&selecao);
switch(selecao) {
case 1: printf("Obter ingredientes\n"); break;
case 2: printf("Juntar ingredientes\n"); break;

22
case 3: printf("Bater a massa\n"); break;
case 4: printf("Colocar na forma\n"); break;
case 5: printf("Levar ao forno\n"); break;
default: printf("Fim\n");
}
}

Note que o programa apresentado parecido com o LICAO5A, a nica diferena est na utilizao
da instruo break. Esta instruo garante que somente um dos procedimentos ser executado, de
acordo com o valor da varivel selecao, compatibilizando o algoritmo em linguagem C com o
algoritmo Inter-S

Exerccio de fixao

Elabore um programa em linguagem C que receba duas variveis numricas e atravs de uma
estrutura de deciso switch...case mostre a soma destas variveis, ou a subtrao, ou a
multiplicao ou a diviso, de acordo com o valor recebido em uma terceira varivel. Grave o
programa como EXERC5.


23
Lio 6 - Estruturas de repetio

Estruturas de repetio permitem que um bloco de instrues seja executado, repetidamente, uma
quantidade controlada de vezes. A linguagem C possui 3 estruturas de repetio: do...while, while e
for.

Estrutura do...while

Esta uma estrutura bsica de repetio condicional. Permite a execuo de um bloco de instrues
repetidamente. Sua sintaxe a seguinte:

do{
bloco
}while(condio);

onde: condio uma expresso lgica ou numrica.
bloco um conjunto de instrues.

Esta estrutura faz com que o bloco de instrues seja executado pelo menos uma vez. Aps a
execuo do bloco, a condio avaliada. Se a condio verdadeira o bloco executado outra
vez, caso contrrio a repetio terminada. O fluxograma desta estrutura mostrado na figura 6.1:

bloco
condio? V
F

Figura 6.1: Fluxograma da estrutura do...while.

O programa LICAO6A, demonstrado abaixo, utiliza uma estrutura do...while para receber um
nmero pelo teclado e mostrar o quadrado do mesmo. A estrutura ser encerrada quando o nmero
digitado for menor ou igual a zero, ou seja, ser executada enquanto o nmero for maior que zero:

// Programa: Lio6A
// Data : 99/99/9999

Rotina
Declare num Numerico
/* Programa Licao6A
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>

main() {
float num;

24
Limpa
Repita
Receba num
Escreva "Quadrado: "
Escreva num*num
AteQue num <= 0
FimRotina
clrscr();
do {
printf("\nDigite um nmero: ");
scanf("%f",&num);
printf("Quadrado: ");
printf("%f", num*num);
} while(num > 0);
}

Observe que as instrues existentes entre os comandos do e while sero executadas enquanto o
valor da varivel num for maior que zero.
Note que no algoritmo Inter-S o final da estrutura representado pela expresso AteQue, ou seja, a
estrutura ser repetida at que algo seja verdadeiro. J no algoritmo em linguagem C a estrutura
finalizada pela expresso while, ou seja, a estrutura ser repetida enquanto algo for verdadeiro.

Estrutura while

A estrutura de repetio condicional while semelhante a estrutura do...while. Sua sintaxe a
seguinte:

while(condio){
bloco
}

onde: condio uma expresso lgica ou numrica.
bloco um conjunto de instrues.

Esta estrutura faz com que a condio seja avaliada em primeiro lugar. Se a condio verdadeira
o bloco executado uma vez e a condio avaliada novamente. Caso a condio seja falsa a
repetio terminada sem a execuo do bloco. Observe que nesta estrutura, ao contrrio da
estrutura do...while, o bloco de instrues pode no ser executado nenhuma vez, basta que a
condio seja inicialmente falsa. O fluxograma desta estrutura mostrada na figura 6.2:
bloco
condio?
V
F

Figura 6.2: Fluxograma da estrutura while.

25

O programa LICAO6B, demonstrado abaixo, ilustra a utilizao de uma estrutura while. O programa
faz o mesmo que o programa anterior (LICAO6A), porm, a estrutura de repetio diferente:

// Programa: Lio6B
// Data : 99/99/9999

Rotina
Declare num Numerico
Num = 1
Limpa
Enquanto num > 0 Faca
Receba num
Escreva "Quadrado: "
Escreva num*num
FimEnquanto
FimRotina
/* Programa Licao6B
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>

main() {
float num;
num = 1;
clrscr();
while(num > 0) {
printf("\nDigite um numero: ");
scanf("%f",&num);
printf("Quadrado: ");
printf("%f", num*num);
}
}

Observe que o programa acima tem o mesmo objetivo do programa LICAO6A: recebe um nmero
pelo teclado e mostra o quadrado do mesmo enquanto o nmero for maior que zero. Note tambm
que a varivel num foi iniciada com o valor 1 (num = 1), isto foi necessrio para que a estrutura
pudesse ser iniciada, pois se o valor de num, na primeira vez, fosse menor ou igual a zero, a
estrutura no seria executada e o programa terminaria.

Estrutura for

A estrutura for muito semelhante s estruturas de repetio vistas anteriormente, entretanto
costuma ser utilizada quando se quer um nmero determinado de ciclos. A contagem dos ciclos
feita por uma varivel chamada de contador. A estrutura for , as vezes, chamada de estrutura de
repetio com contador. Sua sintaxe a seguinte:

for(inicializao; condio; incremento){
bloco
}

onde: inicializao uma expresso de inicializao do contador.
condio uma expresso lgica de controle de repetio.
incremento uma expresso de incremento do contador.
bloco um conjunto de instrues a ser executado.

Esta estrutura executa um nmero determinado de repeties usando um contador de iteraes. O
contador inicializado na expresso de inicializao antes da primeira iterao. Por exemplo: i =
0; ou cont = 20. Ento o bloco executado e depois de cada iterao, o contador incrementado
de acordo com a expresso de incremento. Por exemplo: i=i+1 ou cont = cont-2. Ento a
expresso de condio avaliada: se a condio for verdadeira, o bloco executado novamente e
o ciclo recomea, se a condio for falsa termina-se o lao. Esta condio , em geral, uma
expresso lgica que determina o ultimo valor do contador. Por exemplo: i <= 100 ou cont > 0.


26
O programa LICAO6C, demonstrado abaixo, ilustra a utilizao da estrutura for. O contador i
inicializado com o valor 1. O bloco repetido enquanto a condio i <= 10 for verdadeira. O
contador incrementado com a instruo i=i+1. Esta estrutura, deste modo, mostra na tela os
nmeros 1, 2, ..., 9, 10.

// Programa: Lio6C
// Data : 99/99/9999

Rotina
Declare i Numerico
Limpa
Para i=1 Ate 10 Faca
Escreva i
FimPara
FimRotina
/* Programa Licao6C
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>

main() {
int i;
clrscr();
for(i=1; i<=10; i=i+1) {
printf("%d",i);
}
}

interessante notar que a mesma estrutura lgica pode ser implementada usando as estruturas for
ou do...while:

Exemplo: As seguintes instrues so plenamente equivalentes:

i = 1; for(i = 1; i <= 10; i=i+1){
do{ printf("%d",i);
printf("%d",i); }
i=i+1;
}while(i <= 10);

Obs.: Quando necessrio, podemos interromper a execuo dos comandos de uma estrutura de
repetio utilizando a instruo break. Como j vimos na lio anterior, a instruo break promove
o encerramento da estrutura, independentemente da condio de controle ser verdadeira ou falsa.

Exerccios de fixao

a) Elabore um programa em linguagem C que receba um nmero inteiro e mostre a tabuada de 1 a
10 deste nmero. Utilize a estrutura do...while. Grave o programa como EXERC6A.

b) Faa outro programa de tabuada, semelhante ao EXERC6A, usando agora a estrutura while.
Grave-o como EXERC6B.

c) Faa mais um programa, semelhante aos anteriores, utilizando a estrutura for. Grave-o como
EXERC6C.


27
Lio 7 - Desvios

Desvios so instrues que desviam a seqncia de execuo dos comandos para um outro ponto
especificado do programa. Temos na linguagem C, basicamente, 2 tipos de desvios incondicionais:
goto (o mesmo que a instruo VaPara do Inter-S) e funo definida pelo usurio
(correspondente instruo SubRotina do Inter-S).

Desvio VaPara (goto).

Esta instruo chamada de desvio de fluxo. A instruo desvia o programa para um rtulo (posio
identificada) no programa. So raros os casos onde a instruo goto necessria, no entanto, h
certas circunstncias, onde usada com prudncia, ela pode ser til.

Sintaxe: A sintaxe da instruo goto a seguinte:

goto rtulo;
...
rtulo:
...

onde rtulo um identificador vlido.

O programa LICAO7A, demonstrado abaixo, mostra um lao de repetio onde se l valores para o
clculo de uma mdia. Foram usadas duas instrues goto:

// Programa: Lio7A
// Data : 99/99/9999

Rotina
Declare val, soma Numerico
Declare num Numrico
Limpa
Escreva "Digite valores:"
[Inicio]
Escreva "Valor: "
Receba val
Se val <= 0 Entao
VaPara Fim
FimSe
num = num + 1
soma = soma + val
VaPara Inicio
[Fim]
Escreva "Mdia: ", soma / num
FimRotina
/* Programa Licao7A
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>

main() {
float val, soma;
int num;
clrscr();
printf("Digite valores:");
inicio:
printf("\nValor:");
scanf("%f",&val);
if(val <= 0){
goto fim;
}
num = num + 1;
soma = soma + val;
goto inicio;
fim:
printf("Mdia: %f",soma/num);
}

Observe a existncia de dois rtulos no programa acima: Inicio e Fim (note que os rtulos devem
ser seguidos por dois-pontos : ). Para processar um desvio basta utilizar a instruo goto indicando
o rtulo do ponto para onde queremos desviar o fluxo.


28

Desvio Funo

Na pgina 12 (lio 3) vimos o conceito de funes. Dissemos que funes so sub-programas
escritos em um local fora da rotina principal (main).
Vimos tambm que existem dois tipos de funes: de biblioteca e definidas pelo programador. Na
lio 3 estudamos algumas funes de biblioteca, mais precisamente da biblioteca matemtica
math.h. Agora estudaremos as funes definidas pelo programador, que tambm podem ser
chamadas de SubRotinas, pois so blocos de instrues definidos em um ponto fora da rotina
principal.
Diferente do que ocorre com um desvio do tipo VaPara, um desvio SubRotina sempre retorna ao
ponto de chamada aps a execuo das instrues definidas naquele procedimento.

O programa LICAO7B, demonstrado abaixo, ilustra a utilizao de duas funes. A primeira,
preparar_tela, um procedimento que no requer parmetros, ou seja, no necessita de nenhuma
informao para que as instrues nele existentes sejam executadas. A segunda, media, um
procedimento que requer dois parmetros para que seja executado. Observe o programa e em
seguida faremos os devidos comentrios:

// Programa: Lio7B
// Data : 99/99/9999

Rotina
Declare valor1, valor2, y Numerico
//
Declare media Numerico
Processe Preparar_tela
Escreva "Digite o 1 valor:"
Receba valor1
Escreva "Digite o 2 valor:"
Receba valor2
Processe media
Escreva "Media: "
Escreva y
FimRotina

SubRotina Preparar_tela
Limpa
Escreva "Programa LICAO7B"
FimSubRotina

SubRotina Media
//
y = (a + b) / 2
//
FimSubRotina
/* Programa Licao7B
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>

main() {
float valor1, valor2, y;
void preparar_tela();
float media(float, float);
preparar_tela();
printf("Digite o 1 valor:");
scanf("%f",&valor1);
printf("Digite o 2 valor:");
scanf("%f",&valor2);
y = media(valor1, valor2);
printf("Mdia: ");
printf("%f",y);
}

void preparar_tela() {
clrscr();
printf("Programa LICAO7B\n");
}

float media(float a, float b) {
float c;
c = (a + b) / 2;
return (c);
}

Comentrios

No programa acima utilizamos 2 funes: preparar_tela e media. Observe que devemos declarar
estas funes assim como declaramos as variveis, com a diferena de que devemos indicar o tipo
de dado que a funo retornar e o tipo dos dados que serviro de parmetros:

29
Observe a instruo abaixo:

void preparar_tela();

Esta instruo est declarando a funo preparar_tela, indicando que ela no retornar nenhum
dado, ou seja, uma funo vazia (void). Ao mesmo tempo informa que a funo no receber
nenhum parmetro, pois no existe nenhuma indicao entre os parnteses.

A instruo de declarao da funo media tem caractersticas diferentes:

float media(float, float);

O indicador de tipo float, utilizado no incio da instruo, informa que a funo retornar um dado
numrico de ponto flutuante. Os indicadores float que se encontram entre parnteses, indicam que a
funo receber dois parmetros do tipo numrico de ponto flutuante.

Aps a declarao das funes, estas podem ser chamadas em qualquer ponto dentro da rotina
principal (main). Observe a instruo de chamada da funo preparar_tela:

preparar_tela();

Esta instruo promover a execuo dos comandos existentes dentro da funo preparar_tela, os
quais esto definidos aps o encerramento da rotina principal. Aps a execuo destes comandos, o
programa retornar instruo subseqente chamada da funo.

Observe agora a instruo de chamada da funo media:

y = media(valor1, valor2);

Esta instruo est atribuindo varivel y o valor retornado pela funo media, a qual ter como
parmetros os contedos das variveis valor1 e valor2.
Note que, dentro da funo, estes parmetros sero tratados como a e b. Uma outra varivel est
sendo declarada dentro da funo: a varivel c. Esta varivel receber o resultado do clculo da
mdia de a e b, o qual ser o retorno da funo:

float media(float a, float b) {
float c;
c = (a + b) / 2;
return (c);
}

Exerccios de fixao

a) Crie o programa EXERC7A utilizando como base o programa LICAO6C (pgina 25), substituindo
a estrutura de repetio for por desvios goto.

b) Elabore um programa para calcular e mostrar a mdia de 4 notas bimestrais, informadas pelo
teclado. Crie uma funo para o clculo. Grave o programa como EXERC7B.


30
CAPTULO II
Trabalhando com tela em modo texto

Comandos para recebimento e exibio de dados em tela padro (modo texto)
Neste captulo estudaremos os comandos bsicos para o recebimento e sada de dados utilizando
tela em modo texto.
Como j sabido, o objetivo de todo e qualquer programa de computador o processamento dos
dados de entrada de forma a gerar os dados de sada. Como podemos perceber, os comandos de
entrada e sada de informaes sempre estaro presentes em nossos programas.
Nas outras apostilas deste site tivemos a oportunidade de utilizar as funes scanf (entrada de
dados) e printf (sada de dados). Nesta apostila estudaremos estas e outras funes para o
recebimento e exibio de dados, porm, antes de nos aprofundarmos neste estudo, necessrio
um conhecimento sobre as funes de vdeo (tela).

A linguagem C oferece dois modos para a exibio de dados em vdeo: modo texto e modo grfico.
No modo texto podemos utilizar apenas os caracteres pertencentes tabela ASCII
*
(letras, dgitos e
caracteres especiais), ao passo que no modo grfico podemos construir imagens mais sofisticadas
desenhando-as ponto-a-ponto ou utilizando funes prontas para o traado de linhas, crculos,
retngulos, etc.

* Tabela ASCII (Americam Standard Code for Information Interchange - Tabela de cdigo padro
americano para a troca de informaes) uma tabela adotada pelos fabricantes de
computadores que contm os cdigos internos para a representao dos caracteres (letras,
dgitos, sinais grficos, caracteres especiais e de controle).

Tela em modo texto

O modo texto o modo de tela chamado "default", ou seja, o modo padro.
Trabalhar no modo texto muito simples, como voc pde perceber: basta utilizar a funo printf
para escrever as informaes na tela, porm, esta funo no nos permite determinar em qual local
da tela a informao deve ser escrita.
A tela em modo texto contm 25 linhas (numeradas de 1 a 25) sendo que cada linha contm 80
colunas (numeradas de 1 a 80), formando assim uma matriz de 80 colunas por 25 linhas.
Uma posio de tela referenciada pelo nmero da coluna seguido do nmero da linha. Por
exemplo, a referncia (6,3) representa a posio dada pela interseo da coluna 6 com a linha 3:

1 2 3 4 5 6 .................................... 80
1
2
3 (6,3)
4
.
.
.
.
.
25

Em analogia ao par cartesiano, as colunas representam o eixo X e as linhas o eixo Y. Um ponto de
tela (posio) sempre referenciado pelo nmero da coluna seguido pelo nmero da linha
separados por vrgula, assim como na representao cartesiana: X,Y.
A linguagem C oferece algumas funes teis para a escrita em tela, a saber:

.

31

Antes da apresentao das funes, convm explicarmos as abreviaturas e convenes que
utilizamos na representao de suas formas sintticas (sintaxe):

const_char " Significa uma constante alfanumrica qualquer (texto qualquer entre aspas).
lista_var " Significa um nome de varivel ou uma lista de variveis separadas por vrgula.
Colchetes [ ] " Os argumentos entre colchetes so opcionais, ou seja, no so obrigatrios.

Funo printf() - (print formated) - escrita formatada
Objetivo: Permite a escrita de informaes na tela, a partir da posio do cursor.
Sintaxe.: printf(const_char,[lista_var])

Exemplos:

Algoritmo Inter-S Linguagem C
Escreva "Ola pessoal" printf("Ola pessoal");
Escreva vl printf("%d",vl);
Escreva "Valor=" , vl printf("Valor= %d",vl);

Note que nos dois ltimos exemplos a varivel vl uma varivel numrica, sendo assim, dentro
da constante alfanumrica const_char , devemos indicar o tipo de dado que a varivel armazena,
atravs dos caracteres %d. Estes caracteres so chamados de controle, pois indicam ao
compilador qual o formato do dado que ser escrito na tela. Por enquanto nossos exemplos
utilizaram apenas variveis numricas inteiras (nmeros inteiros) que tm o formato %d. Mais
adiante estudaremos os demais tipos de variveis suportados pela linguagem C.

Funo cprintf() - (color print formated) - escrita formatada em cores
Objetivo: Permite a escrita de informaes na tela, a partir da posio do cursor, usando cores.
Sintaxe.: cprintf(const_char,[lista_var])

Exemplos:

Escreva "Ola pessoal" cprintf("Ola pessoal");
Escreva vl cprintf("%d",vl);
Escreva "Valor=" , vl cprintf("Valor= %d",vl);

Note que a funo cprintf idntica funo printf, a diferena que cprintf aceita definies de
cores, mas para que a sada seja colorida necessrio definir as cores de fundo e de letra antes
de seu uso, isto feito atravs das funes textbackground() e textcolor(), conforme a seguinte
sintaxe:
textcolor(cor_de_letra);
textbackground(cor_de_fundo);

Onde cor_de_letra e cor_de_fundo so nmeros inteiros referentes s cores da palheta padro
(16 cores no modo texto). Cada cor representada por um nmero, conforme tabela abaixo:

Cor N Cor N Cor N Cor N
Preto 0 Vermelho 4 Cinza escuro 8 Vermelho claro 12
Azul 1 Magenta 5 Azul claro 9 Magenta claro 13
Verde 2 Marrom 6 Verde claro 10 Amarelo 14
Ciano 3 Cinza claro 7 Ciano claro 11 Branco 15

- As cores a partir da nmero 8, inclusive, no podem ser utilizadas como cor de fundo.
- Para que a cor fique piscante, adicione 128 ao seu nmero. Veja exemplos:

32

Exemplo 1:

textcolor(15);
textbackground(1);
cprintf(" Vichinsky ");

Escreve a expresso Vichinsky com letras brancas (cor n 15) sobre fundo azul (cor n 1)

Exemplo 2:

textcolor(142);
textbackground(4);
cprintf(" Alerta! ");

Escreve a expresso Alerta! com letras amarelas piscantes (cor n 14 + 128) sobre fundo
vermelho (cor n 4)

Funo gotoxy() - (go to position x, y) - posicionamento do cursor
Objetivo: Colocar o cursor em uma posio definida da tela.
Sintaxe.: gotoxy(coluna, linha)

Esta funo posiciona o cursor em uma determinada coluna (x) e linha (y) permitindo que as
informaes de sada sejam escritas a partir desta posio. As funes printf e cprintf, como j
vimos, escrevem as informaes a partir da posio do cursor, portanto, trabalhando com gotoxy
juntamente com as funes de escrita podemos obter bons resultados de tela. Veja exemplo:

textcolor(15);
textbackground(1);
gotoxy(1,1); cprint(".-------------------.");
gotoxy(1,2); cprint("| Exemplo de tela |");
gotoxy(1,3); cprint("| Linguagem C |");
gotoxy(1,4); cprint("'-------------------'");

Com este trecho de programa teremos uma moldura abrangendo as linhas 1 a 4, a partir da
coluna 1, com letras brancas e fundo azul.

Funo clrscr() - (clear screen) - limpeza de tela
Objetivo: Limpar (apagar) a tela.
Sintaxe.: clrscr()

Esta funo faz com que a tela seja apagada, preenchendo-a com a cor definida para o segundo
plano (fundo). Exemplo:

textbackground(2);
clrscr();

Estas instrues fazem com que a tela seja apagada, preenchendo-a com a cor n 2 (verde).

33

Alguns recursos interessantes
No trecho de programa que serviu como exemplo da funo gotoxy, fizemos uma moldura de tela
utilizando caracteres bsicos do teclado. Reveja o cdigo:

textcolor(15);
textbackground(1);
gotoxy(1,1); cprint(".-------------------.");
gotoxy(1,2); cprint("| Exemplo de tela |");
gotoxy(1,3); cprint("| Linguagem C |");
gotoxy(1,4); cprint("'-------------------'");

Estas instrues geraro o seguinte efeito na tela:

Para dar uma esttica melhor moldura podemos utilizar o conjunto de caracteres semi-grficos
do computador. Estes caracteres no se encontram no teclado, mas podem ser extrados atravs
da combinao de um cdigo numrico com a tecla ALT. Observe que para a construo da
moldura utilizamos os seguintes caracteres: ponto (.), hfen (-), barra vertical (|) e apstrofo ('),
mas poderamos utilizar os caracteres semi-grficos, mostrados a seguir:

Os caracteres apresentados acima no existem no teclado, para extra-los devemos manter
pressionada a tecla ALT e digitar o cdigo correspondente utilizando o teclado reduzido (teclado
numrico). Por exemplo, para extrair o caracter do canto direito superior da moldura basta
pressionarmos a tecla ALT e digitarmos 218, soltando a tecla ALT em seguida. Com este
processo obteremos um programa com o seguinte aspecto:

textcolor(15);
textbackground(1);
gotoxy(1,1); cprint(" ");
gotoxy(1,2); cprint(" Exemplo de tela ");
gotoxy(1,3); cprint(" Linguagem C ");
gotoxy(1,4); cprint(" ");

.-------------------.
| Exemplo de tela |
| Linguagem C |
'-------------------'

218 196 194 191
179
195
192 193 217
180
Note que, durante a
digitao, os caracteres
aparecero unidos, dando
um efeito de linhas
contnuas.

34

Neste caso, o efeito ser o seguinte:

Podemos desta forma obter telas com um aspecto bastante profissional.

Funo scanf() - (scan formated) - entrada formatada
Objetivo: Permite a leitura formatada de informaes via teclado.
Sintaxe.: scanf(const_char,[lista_var])

Exemplos:

Receba vl scanf("%d",&vl);
Receba "Digite o valor",vl printf("Digite o valor");scanf("%d",&vl);

Note que vl uma varivel numrica, sendo assim, dentro da constante alfanumrica const_char ,
devemos indicar o tipo de dado que a varivel receber, atravs dos caracteres %d. Estes
caracteres so chamados de controle, pois indicam ao compilador qual o formato do dado que
ser recebido (lembre-se que as funes de entrada printf e cprintf tambm exigem esses
caracteres de controle).
No segundo exemplo acima, observe que utilizamos um texto que ser escrito na tela antes do
recebimento do valor. Em Inter-S a instruo feita atravs do comando Receba, informando-se
entre aspas o texto a ser apresentado na tela e o nome da varivel que receber o contedo
digitado, separando-os com vrgula (,). Em linguagem C este comando deve ser feito em duas
etapas: com a funo printf (ou cprintf) colocamos o texto que dever aparecer na tela e em
seguida utilizamos a funo scanf para receber o contedo da varivel.

Resumo

Vimos at agora as funes para entrada e sada de dados utilizadas no modo texto. Com elas
podemos construir telas sofisticadas utilizando os recursos de cores, posicionamento do cursor para
escrever ou receber informaes a partir de qualquer linha ou coluna da tela, etc.
Veja no quadro sinptico as funes estudadas:

Exemplo de tela
Linguagem C

35

Quadro sinptico de funes
Funo Objetivo Exemplo
printf() Sada formatada printf("Ola pessoal");
cprintf Sada formatada em cores cprintf("Ola pessoal");
textcolor() Definio da cor do texto textcolor(9);
textbackground() Definio da cor do segundo plano textbackground(4);
gotoxy() Posicionamento do cursor gotoxy(10,5);
clrscr() Apaga a tela clrscr();
scanf() Entrada formatada scanf("%d",valor1);

Juntando tudo

Para ilustrar a aplicao das funes estudadas, vamos partir de um exerccio resolvido que solicita
dois dados pelo teclado e processa a soma dos mesmos, e ento, anexaremos a ele algumas
"benfeitorias" que o deixaro com um visual mais interessante.

1 passo: Programa original

// Programa Soma.ALG
// Autor: Vichinsky
// Data: 01/01/2000

Rotina
Declare N1, N2, Soma Numericos
Receba "Digite o primeiro nmero", N1
Receba "Digite o segundo Nmero", N2
Soma = N1 + N2
Escreva "Soma", Soma
FimRotina

/* Programa SOMA.C
Autor: Vichinsky
Data.: 01/01/2000
*/
#include <stdio.h>
#include <conio.h>

main() {
int n1, n2, soma;
printf("Digite o 1 nmero");scanf("%d",&n1);
printf("Digite o 2 nmero");scanf("%d",&n2);
soma = n1 + n2;
printf("Soma %d",soma);
}

Encontra-se aqui o algoritmo e o cdigo fonte do programa original SOMA.C. Se voc ainda no o
digitou, faa-o agora.
Nos prximos passos no mais apresentaremos o algoritmo em Inter-S, pois a lgica do
programa ser mantida. Incluiremos apenas as funes para melhorar o visual da aplicao, e
isto no altera a lgica, considera-se apenas um trabalho de embelezamento ou "perfumaria".

2 passo: Colocao de uma moldura
A primeira coisa que iremos fazer uma moldura que envolva as informaes de tela. Para isto
teremos que usar a funo de limpeza (clrscr) e a funo de posicionamento do cursor (gotoxy).
Usaremos tambm a funo cprintf em substituio printf.


36

/* Programa SOMA.C
Autor: Vichinsky
Data.: 01/01/2000
*/
#include <stdio.h>
#include <conio.h>

main() {
int n1, n2, soma;
clrscr();
gotoxy(1,1);cprintf(" ");
gotoxy(1,2);cprintf(" PROGRAMA SOMA.C ");
gotoxy(1,4);cprintf(" Digite o 1 numero: ");
gotoxy(1,6);cprintf(" Soma..............: ");
gotoxy(23,4);scanf("%d",&n1);
soma = n1 + n2;
gotoxy(23,6);cprintf("%d",soma);
}

Note que inicialmente montada uma moldura envolvendo as informaes de tela: identificao
do programa e nome dos campos a serem preenchidos. Utilizamos a funo clrscr para a limpeza
de tela e em seguida um conjunto de instrues contendo 7 funes gotoxy que tm o objetivo de
posicionar o cursor na linha e coluna desejada para que a informao seja exibida atravs da
funo cprintf. Para a montagem da moldura deve-se empregar os caracteres semi-grficos
(aqueles que no existem no teclado) mantendo-se pressionada a tecla ALT e digitando-se o
cdigo correspondente :


Observe tambm que antes do recebimento dos dados com a funo scanf, devemos posicionar
o cursor na coluna e linha desejadas:


O contedo de n1 ser solicitado na linha 4 a partir da coluna 23. O contedo de n2 ser
solicitado na linha 5 a partir da coluna 23.
Para obter este caracter
pressione ALT + 218
ALT+196 ALT+191
ALT+180
ALT+195
ALT+179
ALT+192
ALT+217

37

3 passo: Colocao de cores
A colocao de cores muito simples: basta definirmos as cores do texto e segundo plano
atravs das funes textcolor e textbackground. Veja como ficar o programa:

/* Programa SOMA.C
Autor: Vichinsky
Data.: 01/01/2000
*/
#include <stdio.h>
#include <conio.h>

main() {
int n1, n2, soma;
clrscr();
textcolor(15);textbackground(1);
soma = n1 + n2;
gotoxy(23,6);cprintf("%d",soma);
}

Definimos o texto branco (cor n 15) e o fundo azul (cor n 1). As funes de cores foram
colocadas aps a funo de limpeza de tela (clrscr), mas voc poder coloc-las antes. Desta
forma toda a tela ficar azul, e no apenas a rea da moldura. Faa um teste!
Note que aps a definio todas a informaes escritas com a funo cprintf assumiro as cores
especificadas. Mesmo aps o programa ser encerrado estas cores sero mantidas.


38
CAPTULO III
Trabalhando com tela em modo grfico

Comandos para utilizao da tela em modo grfico / funes da biblioteca grfica.
Neste captulo estudaremos os comandos e funes necessrias para a elaborao de programas
que trabalhem com telas no modo grfico.

No captulo anterior estudamos as funes de tela em modo texto. Vimos que a tela composta por
uma matriz de 80 colunas por 25 linhas (em seu estado padro), e que podemos exibir apenas os
caracteres da tabela ASCII. Quando voc trabalhar com o MS-DOS (prompt do MS-DOS) observe
que os caracteres (letras, nmeros, sinais de pontuao, etc) so formados por um conjunto de
pontos. Por exemplo, a letra A, se ampliada, ter o seguinte aspecto:

..
. .
. .
......
. .
. .

Cada um dos pontos que compe um caracter chamado de pixel, e no modo texto ns no temos
controle sobre eles, pois so colocados automaticamente quando pedimos a exibio do caracter.
por este motivo que no conseguimos obter desenhos ou figuras diferentes no modo texto.

Como podemos, ento, manipular os pixels dentro de um programa para criar desenhos?
A resposta muito simples: trabalhando no modo grfico!

Existem vrias formas para se trabalhar com telas grficas na linguagem C, algumas delas requerem
conhecimentos tcnicos mais aprofundados para que o programador construa sua prpria biblioteca
de funes grficas, porm, para as nossas atividades, vamos trabalhar com os recursos oferecidos
pelas bibliotecas padres da linguagem (aquelas que j vm prontas).

A tela no modo grfico no trabalha com linhas e colunas como acontece em modo texto, mas sim
com pontos horizontais e verticais, constituindo uma matriz. Os pontos, ou pixels (termo tcnico
utilizado), so referenciados atravs de dois eixos: x e y, assim como no plano cartesiano:

Representao da tela grfica. Observe que o ponto origem (coordenada 0,0) encontra-se no canto
esquerdo superior do vdeo. O eixo y apresenta uma escala crescente de cima para baixo (no
existem negativos)

A quantidade de pontos suportados por uma tela grfica depende do tipo de adaptador instalado no
computador. Os adaptadores (placas de vdeo) mais comuns so: CGA (Adaptador Grfico
Colorido), EGA (Adaptador Grfico Estendido) e VGA (Matriz Grfica de Vdeo). Os computadores
atuais so equipados, em sua grande maioria, com adaptadores VGA.
No iremos nos aprofundar nestes detalhes tcnicos, mas importante que voc saiba qual o
adaptador grfico instalado no computador que executar os seus programas, para que reconhea a
quantidade de pontos (resoluo) suportada por ele.

y
x
Origem
(0,0)

39
Para que seus programas acessem a tela grfica, voc deve informar o tipo de adaptador utilizado e
o modo de resoluo, pois cada adaptador pode trabalhar basicamente com 3 modos de resoluo
(baixa, mdia ou alta). Quanto maior a resoluo maior o nmero de pontos suportados.
Voc deve estar ansioso para saber como colocar estas informaes no programa. Muito bem, o
primeiro passo incluir uma referncia ao arquivo graphics.h no cabealho de seu programa:
#include <graphics.h>

Em seguida, dentro da rotina principal (main), voc deve inserir uma seqncia de instrues para
fazer a iniciao do modo grfico. Estas instrues devem aparecer logo aps s declaraes das
variveis e constantes utilizadas:

int gdriver = VGA, gmode = VGAHI, errorcode;
initgraph(&gdriver, &gmode, "");
errorcode = graphresult();
if (errorcode != grOk) {
printf("Erro: %s\n", grapherrormsg(errorcode));
exit(1);
}

Parece coisa de louco, no acha? Mas no se assuste, as instrues acima so de uma
simplicidade muito grande, pois estamos utilizando algumas funes previamente preparadas pelo
fabricante do Turbo C. Vamos aos esclarecimentos:

Inicialmente estamos declarando duas constantes (gdriver e gmode) e uma varivel errorcode
:


A constante gdriver est recebendo o contedo de VGA, que na realidade tambm uma
constante definida dentro do arquivo graphics.h, que tem como contedo o cdigo interno
que representa o adaptador grfico VGA.
A constante gmode est recebendo o contedo de VGAHI (constante que contm o cdigo
que representa o modo de resoluo alta - VGA High)
A varivel errorcode est reservada para receber um cdigo de situao, que ser analisado
nas instrues subseqentes.

Aps as declaraes das constantes e variveis, temos a seguinte instruo:

Estamos aqui chamando a funo initgraph, que tem o objetivo de colocar a tela em modo
grfico de acordo com as definies entre parnteses. Neste caso estamos informando que o
adaptador grfico o VGA (definido em gdriver) e que a resoluo alta, ou seja, resoluo
VGA High (definida em gmode). Observe tambm que foram colocadas duas aspas seguidas
("") como ltimo parmetro da funo. Este parmetro determina o caminho para que o
compilador encontre os drivers do adaptador, mas no h necessidade de inform-lo, basta
apenas abrir e fechar aspas.

Aps o processo de iniciao do modo grfico, devemos verificar se a ao foi bem sucedida,
ou seja, se a funo initgraph conseguiu reconhecer o adaptador e o modo de resoluo
definidos. Para esta verificao devemos atribuir varivel errorcode o resultado gerado pela
funo graphresult :

A funo graphresult retorna o resultado da iniciao do modo grfico atravs de um cdigo
de situao, o qual ser avaliado pelas seguintes instrues:

40

exit(1);
}

Atravs de uma estrutura de deciso estamos perguntando se o contedo da varivel
errorcode diferente do contedo da constante grOk: if (errorcode != grOk)
A constante grOk est definida no arquivo graphics.h e contm o cdigo que indica o sucesso
da iniciao do modo grfico. Para perguntar se errorcode diferente utilizamos o operador
relacional != (exclamao e sinal de igualdade), que em linguagem C corresponde a
"diferente" ou "no igual".
Se o contedo de errorcode for diferente de grOk ento houve um erro na iniciao, neste
caso o programa deve ser encerrado. Observe que antes do encerramento ser colocada
uma informao atravs da funo printf :
Esta instruo escrever na tela a expresso "Erro" e a descrio do erro encontrado.
Para finalizar o programa estamos utilizando a funo exit(1). O nmero 1 entre parnteses
indica que o programa foi encerrado mediante uma ocorrncia de erro.

Voc percebeu que apesar da aparncia assustadora as instrues para se iniciar a tela grfica so
bastante simples: basta saber qual o adaptador grfico que estar utilizando e qual o modo de
resoluo desejado; coloca-se estas informaes nas constantes gdriver (adaptador) e gmode
(modo). A tabela a seguir mostra alguns dos adaptadores que voc poder usar e os modos de
resoluo suportados por eles:

Adaptador Resoluo Valor de
gdriver
Valor de
gmode
Quantidade de
pontos
EGA Baixa (Low) EGA EGALO 640 x 200
EGA Alta (High) EGA EGAHI 640 x 350
VGA Baixa (Low) VGA VGALO 640 x 200
VGA Media (Med) VGA VGAMED 640 x 350
VGA Alta (High) VGA VGAHI 640 x 480

Muito bem! Com o contedo terico visto at agora temos como iniciar a construo de um
programa grfico, mas do que adianta acessar a tela grfica se ainda no sabemos como enviar
informaes para ela?
Para comear vamos construir um programa que desenhe um crculo amarelo no centro da tela,
considerando o adaptador VGA no modo de alta resoluo (VGAHI):

/* Programa GRAF1.C - Desenha um crculo amarelo */
#include <stdio.h>
#include <conio.h>
main(){
exit(1);
}
setcolor(14); circle(320,240,100);
getch();
closegraph();
exit(0);
}

41

Explicaes
Na tabela abaixo estamos reproduzindo o programa GRAF1.C com as devidas explicaes para
cada uma das linhas de instrues:

Linhas de instrues Explicaes
/* Programa GRAF1.C -Desenha um crculo */
#include <stdio.h>
#include <conio.h>
main( ) {
exit(1);
}
getch();
closegraph();
exit(0);
}
Linha de identificao (comentrio)
Referncia ao arquivo graphics.h (biblioteca)
Referncia ao arquivo stdio.h (biblioteca)
Referncia ao arquivo conio.h (biblioteca)
Incio da rotina principal
Declarao das constantes e variveis
Iniciao do modo grfico
Obteno do resultado da iniciao
Verifica se houve erro na iniciao
Se houve erro escreve uma mensagem na tela e...
...encerra o programa
Finaliza a verificao
Ajusta a cor para amarelo (14) e desenha o crculo
Gera uma pausa at que uma tecla seja pressionada
Fecha o modo grfico
Encerra o programa normalmente
Fim da rotina principal

Este programa, simplesmente, desenha um crculo no centro da tela grfica. A instruo responsvel
pelo desenho :

Atravs da funo setcolor determinamos a cor do desenho, que neste caso amarelo (cor nmero
14). Em seguida, atravs da funo circle, desenhamos o crculo. Observe que entre os parnteses
da funo existem trs parmetros: 320, 240, 100. Os dois parmetros iniciais indicam a coordenada
da tela que ser o centro do crculo (x=320 e y=240) e o terceiro parmetro indica o tamanho do raio
medido em pontos grficos (pixels). Observe a representao abaixo:

Note que o centro do crculo encontra-se justamente no centro da tela, ou seja, na posio 320 do
eixo X e 240 do eixo Y (lembre-se que no padro VGA de alta resoluo temos 640 pontos no eixo X
e 480 pontos no eixo Y, a coordenada central do crculo utiliza justamente a metade desses valores).
Para aumentar ou diminuir o tamanho do crculo basta alterar o valor do raio, aumentando-o ou
diminuindo-o respectivamente.

0
320 640
240
480
Raio = 100 pixels
Y
X

42

Com este pequeno programa exemplo j temos uma noo de como utilizar o modo grfico em
nossas aplicaes. Porm, antes de prosseguirmos, vejamos um resumo das funes grficas que
iremos utilizar em nossos futuros programas.

Resumo das principais funes grficas

cleardevice() Limpa a tela grfica.

setcolor(c) Define a cor das imagens (c = cdigo da cor, de 0 a 15).

setfillstyle(p,c) Define a cor de preenchimento dos retngulos e elipses (p=padro de
preenchimento; c=cdigo da cor).

bar(x1,y1,x2,y2) Desenha um retngulo preenchido com a cor definida pela funo
setfillstyle, a partir do ponto x1-y1 at a ponto x2-y2.

fillellipse(x,y,r1,r2) Desenha uma elipse preenchida com a cor definida pela funo setfillstyle,
com centro na coordenada x-y, com tamanho do maior raio definido por r1 e
menor raio definido por r2.

circle(x,y,r) Desenha um crculo sem preenchimento, com centro na coordenada x-y e
raio igual a r.

rectangle(x1,y1,x2,y2) Desenha um retngulo sem preenchimento, a partir do ponto x1-y2 at o
ponto x2-y2.

line(x1,y1,x2,y2) Traa uma linha iniciando no ponto x1-y1 at o ponto x2-y2.

putpixel(x,y,c) Plota um ponto na coordenada x-y (c=cdigo da cor, de 0 a 15).

sprintf(s,f,v) Envia para a varivel string (s) um texto formatado (f) que pode conter
valores de variveis (v).

outtextxy(x,y,s) Escreve na tela grfica, a partir do ponto x-y, o contedo definido em s.

closegraph() Fecha o modo grfico e volta ao modo texto.

Nota: As referncias em azul indicam os valores dos parmetros requeridos pela funo. Estes
valores podem ser constantes ou variveis. Por exemplo, para desenhar um retngulo a partir da
coordenada 100,50 at a coordenada 500,430 podemos usar uma das seguintes instrues:
rectangle(100,50,500,430);
ou
x1=100; y1=50; x2=500; y2=430;
rectangle(x1,y1,x2,y2);

Em ambos os casos teremos o seguinte resultado:

X1=100
Y2=430
Y1=50
X2=500

43

Textos em tela grfica

Voc deve estar perguntando: possvel escrever textos em uma tela grfica?
Sim! Mas no com os mesmos mtodos utilizados em telas no modo texto. As funes printf e cprintf
(nossas velhas conhecidas) no funcionam adequadamente em modo grfico. Devemos substitui-las
pela funo sprintf em conjunto com a funo outtextxy. Estas funes esto relacionadas no
resumo apresentado na pgina anterior.
A funo sprintf no escreve nada na tela, simplesmente prepara uma varivel do tipo caracter que
posteriormente ser escrita atravs da funo outtextxy. Podemos tambm utilizar a funo outtextxy
isoladamente.Para ilustrar este processo imagine que voc queira escrever o texto "Ola amigos da
Linguagem C" a partir da coordenada 10,20 (x=10 e y=20), na cor azul, e em seguida exibir o
contedo de uma varivel. Observe o programa que realiza esta tarefa:

/* Programa GRAF2.C - Escrita em tela grfica */
#include <stdio.h>
#include <conio.h>
main(){
int var;
char mensagem[80];
exit(1);
}
setcolor(1);
outtextxy(10,20,"Ola amigos da Linguagem C");
var=35;
sprintf(mensagem, "Valor da varivel var: %d", var);
outtextxy(10,50,mensagem);
getch();
closegraph();
exit(0);
}

Observe que para escrever o texto "Ola amigos da Linguagem C" utilizamos a funo outtextxy:
outtextxy(10,20,"Ola amigos da Linguagem C");

Neste caso no houve necessidade de se utilizar a funo sprintf, pois a informao a ser escrita
no contm variveis. Por outro lado, para exibir o contedo da varivel var preciso que se prepare
a informao atravs da funo sprintf :

var=35;
sprintf(mensagem, "Valor da varivel var: %d", var);

Note que a funo sprintf coloca na varivel caracter mensagem o texto "Valor da varivel" ,
agregando o contedo da varivel var. Em seguida utilizamos a funo outtextxy para exibir o
contedo de mensagem a partir da coordenada 10,50. (Observe que a varivel mensagem
declarada no incio da rotina atravs da instruo char mensagem[80];).


44

Alguns programas exemplos
Para que voc assimile melhor os comandos grficos apresentados, vamos expor alguns programas
exemplos.

Programa exemplo 1: Desenho livre: desenha linhas na tela com o uso das setas
O programa abaixo, aps iniciar o modo grfico e preparar as variveis de trabalho, entra em uma
estrutura de repetio (bloco entre as instrues volta: e goto volta;) e fica aguardando o
pressionamento de uma tecla (instruo op=getch(); ). De acordo com a tecla pressionada
acionado um determinado bloco de instrues. A seleo do bloco feita por comandos if que
verificam o cdigo da tecla pressionada. As teclas programadas so:
Tecla Cdigo Ao
Seta p/ cima H Diminui 1 da varivel y e coloca um ponto na nova coordenada.
Seta p/ baixo P Soma 1 na varivel y e coloca um ponto na nova coordenada.
Seta p/ direita M Soma 1 da varivel x e coloca um ponto na nova coordenada.
Seta p/ esquerda K Diminui 1 da varivel x e coloca um ponto na nova coordenada.
Dgito 0 (zero) 0 Ajusta a cor para 0 (preto)
Dgito 1 (um) 1 Ajusta a cor para 1 (azul)
Dgito 2 (dois) 2 Ajusta a cor para 2 (verde)
Dgito 3 (trs) 3 Ajusta a cor para 3 (ciano)
Asterisco * Encerra o programa

/* Programa LIVRE.C - Desenho livre com uso das setas */
#include <stdio.h>
#include <conio.h>
main(){
int i,x,y,cor;
char op;
char mensagem[80];
exit(1);
}
cleardevice();
x=320; y=240; cor=1;
volta:
sprintf(mensagem, "X= %d Y= %d Cor= %d", x,y,cor);
op=getch();
setcolor(0); outtextxy(10,400,mensagem);
setcolor(15);
if (op=='H'){
if (y>0) y=y-1;
putpixel(x,y,cor);
}
if (op=='P'){
if (y<400) y=y+1;
putpixel(x,y,cor);
}
if (op=='M'){
if (x<639) x=x+1;
putpixel(x,y,cor);
}

45

if (op=='K'){
if (x>0) x=x-1;
putpixel(x,y,cor);
}
if (op=='0'){cor=0;}
if (op=='1'){cor=1;}
if (op=='2'){cor=2;}
if (op=='3'){cor=3;}
if (op=='*'){closegraph(); exit(0);}
goto volta;
}

Programa exemplo 2: Cores e figuras: Demonstra o uso de cores e desenho de figuras
O programa abaixo, aps iniciar o modo grfico e preparar as variveis de trabalho, faz uma
demonstrao de cores, exibindo todas as cores possveis neste modo. Em seguida apresenta um
menu que permite a seleo de 3 opes. Analise-o:

/* Programa: CORES.C - Demonstrao das cores */
#include <stdio.h>
#include <conio.h>
main(){
int i;
char op;
char mensagem[80];
exit(1);
}
cleardevice();
setcolor(1); outtextxy(10, 1, "Cor 1"); circle(70,5,4);
setcolor(10);outtextxy(10, 136, "Cor 10");circle(70,140,4);
outtextxy(10,250,"Tecle algo para continuar");
getch();
menu:
cleardevice();
setcolor(14);
outtextxy(250, 5, "Menu de opcoes");
setcolor(3);
outtextxy(220, 20, "[1] Desenho de circulos");

46

outtextxy(220, 30, "[2] Desenho de Linhas");
outtextxy(220, 40, "[3] Fim");
outtextxy(220, 60, "Digite sua opcao");
op=getch();
cleardevice();
sprintf(mensagem, "Opcao selecionada = %c", op);
if(op=='1'){
setcolor(14);circle(400,240,120);
getch();
cleardevice();
}
if (op=='2'){
setcolor(14);line(1,1,600,300) ; getch();
setcolor(1) ;line(100,1,560,300); getch();
setcolor(2) ;line(1,300,600,5) ; getch();
}
if (op=='3'){
closegraph(); exit(0);
}
goto menu;
}

Programa exemplo 3: Figuras: Demonstra o desenho de figuras
Este exemplo o mais simples de todos. Mostra algumas figuras desenhadas atravs das
funes grficas estudadas:

/* Programa FIGURAS.C - Desenho de figuras */
#include <stdio.h>
#include <conio.h>
main(){
exit(1);
}
setfillstyle(1,14); /* Padro e cor de preenchimento */
bar(10,10,50,50); /* Desenha uma barra preenchida */
fillellipse(200,200,50,30); /* Desenha uma elipse preenchida */
circle(300,300,50); /* Desenha um crculo */
rectangle(400,100,500,110); /* Desenha um retngulo */
line(100,1,300,400); /* Desenha uma linha */
putpixel(320,300,12); /* Desenha um ponto (pixel) */
getch(); /* Aguarda uma tecla qualquer */
closegraph(); /* Fecha o modo grfico */
exit(0); /* Encerra o programa */
}

47

Atividades complementares

Digite os programas apresentados neste captulo (GRAF1.C, GRAF2.C, LIVRE.C, CORES.C e
FIGURAS.C). Veja o funcionamento dos mesmos e faa alteraes a seu gosto, como por exemplo:
mudar as cores, alterar o tamanho das figuras, modificar os textos, etc. importante que voc
compreenda o funcionamento das funes estudadas, e a prtica o melhor caminho para isso.

Observao: Para que um programa grfico possa ser executado, preciso que o arquivo
EGAVGA.BGI esteja presente na mesma pasta (diretrio) onde se encontra o
programa. Este arquivo contm um conjunto de funes especficas para que o
programa reconhea o modo grfico (este arquivo faz parte do pacote Turbo C). No
nosso caso no teremos problema, pois o arquivo EGAVGA.BGI est presente na
pasta TC201, mas se voc quiser copiar um programa grfico para um computador
que no possua o Turbo C, no esquea de copiar tambm o arquivo EGAVGA.BGI.

48
CAPTULO IV
Arquivos de dados

Funes de biblioteca para a manipulao de arquivos em disco.
Neste captulo estudaremos as funes bsicas da linguagem C para a manipulao de dados em
arquivos gravados em disco.

Os programas vistos at agora trabalham com informaes que so armazenadas em variveis de
memria. As variveis conservam seus contedos somente enquanto o programa est sendo
executado, quando o programa finalizado, todos os dados manipulados por ele so perdidos.
Porm, existem situaes em que necessitamos armazenar as informaes de forma permanente,
para que no sejam perdidas quando o programa for encerrado. Vamos imaginar que voc queira
construir um programa para armazenar os dados de seus amigos - uma agenda telefnica de
amigos. Para este feito ser necessrio o armazenamento permanente das informaes, pois voc
no deseja perd-las quando o programa for encerrado. Como fazer isto?
Bem, podemos comear com uma rotina que recebe as informaes dos amigos:

/* Programa AGENDA.C */
#include<stdio.h>
#include<conio.h>
main(){
int codigo;
char nome[30];
char telefone[15];
char resp;
inicio:
clrscr();
printf("Digite o codigo do amigo..: ");scanf("%d",&codigo);
printf("Digite o nome do amigo....: ");scanf("%s",nome);
printf("Digite o telefone do amigo: ");scanf("%s",telefone);
printf("Continua (S/N)? ");scanf("%s",&resp);
if (resp=='N' resp=='n') {
exit(0);
}
goto inicio;
}

O programa acima (AGENDA.C) comea com a declarao de 4 variveis: codigo, nome, telefone e
resp. Em seguida existe um rtulo denominado inicio, que indica o ponto onde se inicia o processo
de recebimento dos dados. Os dados codigo, nome e telefone do amigo so recebidos pelo teclado
atravs das funes scanf. Em seguida a mensagem "Continua (S/N)?" mostrada na tela atravs
da funo printf e o dado resp recebido pelo teclado. Se o contedo de resp for N ou n o
programa ser encerrado, caso contrrio haver um desvio para o rtulo inicio (goto inicio;),
repetindo-se o processo de recebimento dos dados.
Se voc digitar e compilar esta rotina perceber que o funcionamento dela perfeito: ela receber
as informaes pelo teclado e as armazenar nas variveis declaradas. Mas existir um problema:
as variveis conservaro seus contedos at que outro contedo seja atribudo a elas, ou seja, esta
rotina no faz o armazenamento permanente dos dados recebidos, portanto, no serve para
absolutamente nada!

Qual a sada para que os dados digitados sejam armazenados permanentemente?
Armazenando-os em um arquivo de dados!

Um arquivo de dados um conjunto de informaes armazenado em um meio magntico ou ptico
(disquete, disco rgido, fita, Cd, etc.) onde permanecer gravado e disponvel para quaisquer futuras
utilizaes.

49

Para ilustrar este conceito, vamos imaginar que a nossa agenda de amigos tenha as seguintes
informaes:

Agenda de amigos
Cdigo Nome Telefone
1 Antonio Laurentino Miguel 1234-5678
2 Bianco Branco de Assis Moreira 8765-4321
3 Juarez Joo Columbiano Mattos 9999-7777
4 Pedro Pedreira Rocha 0001-1110
5 Z Man 1000-1234

Estas informaes, da forma que esto estruturadas, caracterizam um arquivo de dados. Podemos
atravs disto tirar algumas definies:

- Um arquivo de dados deve possuir um nome. No nosso caso o nome "Agenda de amigos",
mas em linguagem C o nome deve possuir no mximo 8 (oito) caracteres e um sufixo com no
mximo 3 (trs), vamos usar "AGENDA.DAT" (o sufixo deve aparecer aps um ponto final e
deve informar o tipo de arquivo; estamos utilizando a expresso DAT, que uma abreviao
de data - dado em ingls - mas poderamos utilizar qualquer sufixo desejado).
- Um arquivo de dados deve possuir uma estrutura bem definida, observe as linhas e colunas,
que nos do a idia de uma matriz ou tabela. Cada uma da linhas armazena os dados de um
amigo, e cada coluna indica um dado (cdigo, nome ou telefone).
- Tecnicamente chamamos as linhas de registros e as colunas de campos.
- Todos os registros possuem os mesmos campos e, portanto, o mesmo tamanho.

Com estas definies bsicas, podemos concluir que:

Um arquivo de dados um conjunto de informaes formado por registros e campos.
Um registro um conjunto de campos que armazena os dados de um item do arquivo.
Um campo um dado individual do registro.

5 Z Man 1000-1234

J temos uma noo do que um arquivo de dados, vamos ver agora como fazer com que os dados
dos nossos amigos sejam gravados em um arquivo.

Instrues necessrias para a gravao de dados em um arquivo

Primeiro passo: Preparao
Para utilizar um arquivo de dados em um programa, o primeiro passo definir um nome para o
ponteiro do arquivo. Este ponteiro servir para direcionar as futuras operaes de abertura,
gravao e leitura. Utilizaremos o nome arquivo para o ponteiro (sugestivo, no?), incluindo a
seguinte linha de comando no incio do programa:

FILE *arquivo;

Campo 1
(cdigo)
Campo 2 (nome) Campo 3 (telefone)
Registro

50

Em seguida devemos declarar a estrutura do arquivo, ou seja, devemos definir os campos que o
arquivo possuir. No nosso exemplo do arquivo AGENDA.DAT (agenda de amigos) temos os
campos: codigo, nome e telefone, portanto, devemos construir uma estrutura que os defina:

struct { Inicia a definio da estrutura
int codigo; Declara o campo codigo como numrico inteiro
char nome[30]; Declara o campo nome como caractere de 30 posies
char telefone[15]; Declara o campo telefone como caractere de 15 posies
} registro; Nomeia a estrutura como registro

Observe que devemos utilizar o comando struct e entre chaves indicar os tipos e os nomes de cada
um dos campos do arquivo. Aps o fechamento da chave devemos indicar o nome da estrutura, que
neste exemplo registro, tambm bastante sugestivo, pois na realidade a estrutura construda
corresponde ao registro do arquivo AGENDA.DAT.

Desta forma o nosso programa AGENDA.C dever possuir as seguintes linhas iniciais:

#include<stdio.h>
#include<conio.h>
FILE *arquivo;
struct {
int codigo;
char nome[30];
char telefone[15];
}registro;

main(){
...

Segundo passo: Abertura
Para ilustrar o processo de abertura de um arquivo de dados, imagine que este arquivo seja um
caderno. Muito bem, para que possamos utilizar este caderno (escrever ou ler) devemos
primeiramente abri-lo. justamente isto o que ocorre com um arquivo de dados gravado em um
disco: para utiliz-lo devemos antes processar sua abertura!
Porm, s vezes a abertura de um caderno no to simples. Imagine, por exemplo, que o caderno
no exista, ou que algum tenha derramado cola sobre ele. Nestes casos a abertura ser
impossvel. Se o caderno no existir, menos mal, compramos um novo e pronto! Mas se o caderno
estiver colado, os dados nele escritos estaro perdidos, o jeito ser jog-lo fora e comprar um novo.
Estas situaes tambm podem ocorrer com um arquivo de dados: podemos tentar abrir um arquivo
que no exista no disco ou, existindo, esteja danificado. Por este motivo, antes de abrirmos um
arquivo de dados devemos verificar se a abertura possvel. Podemos representar a rotina de
verificao atravs do seguinte algoritmo em pseudo-linguagem (observe-o com ateno):

Se o arquivo "AGENDA.DAT" no pode ser aberto para leitura e escrita ento
Se o arquivo "AGENDA.DAT" no pode ser criado ento
Escreva "Erro de abertura"
Interrompa
FimSe
FimSe

51

Este algoritmo, traduzido em linguagem C, ter o seguinte aspecto:

if((arquivo=fopen("AGENDA.DAT","r+b"))==NULL) {
if((arquivo=fopen("AGENDA.DAT","wb"))==NULL) {
printf("Erro de abertura");
exit(1);
}
}
fclose(arquivo);

Vamos tentar entender? Ento leia com bastante ateno:

- A primeira linha faz a tentativa de abertura do arquivo "AGENDA.DAT" e ao mesmo tempo
pergunta se houve sucesso na operao, comparando o ponteiro arquivo com o valor NULL
(nulo). Se o ponteiro for nulo ento o arquivo no pde ser aberto por algum problema (ou no
existe ou est danificado). A expresso "r+b" solicita a abertura do arquivo para a leitura e
escrita.

- A segunda linha s ser executada se o arquivo no pde ser aberto. Observe que esta linha
semelhante primeira, com a diferena na expresso que define o tipo de abertura: "wb".
Na realidade esta instruo faz a tentativa de criao do arquivo e ao mesmo tempo verifica
se a criao foi bem sucedida, comparando o ponteiro arquivo com o valor NULL (nulo). Se o
ponteiro for nulo significa que o arquivo tambm no pode ser criado, neste caso no h nada
mais a fazer, a no ser finalizar o programa.

- A terceira linha, assim como a quarta, s ser executada se o arquivo "AGENDA.DAT" no
puder ser aberto nem criado. Esta linha exibir na tela a mensagem "Erro de abertura". Em
seguida ser executada a quarta linha: exit(1), que processa o encerramento do programa
mediante ocorrncia de erro.

- A quinta linha apenas encerra a estrutura condicional iniciada na segunda linha.

- A sexta linha, assim como a quinta, apenas encerra a estrutura condicional iniciada na
primeira linha.

- A stima e ltima linha, que no possui correspondncia no algoritmo em pseudo-linguagem,
faz o fechamento do arquivo.

Em sntese, a rotina apresentada simplesmente verifica se o arquivo pode ser aberto, criando-o caso
ele no exista, ou finalizando o programa caso esteja danificado.

Agora podemos abrir o arquivo definitivamente, com a certeza de que haver sucesso na operao.
Usaremos o seguinte comando:

arquivo=fopen("AGENDA.DAT","r+b")

A funo fopen a responsvel pela abertura do arquivo. Devemos informar, entre parnteses, o
nome do arquivo e o modo de acesso: "AGENDA.DAT" o nome e "r+b" determina que o modo de
acesso leitura/escrita, isto , o arquivo poder ser lido e escrito (como um caderno).

Veja na pgina seguinte como ficar o incio do programa aps a incluso destas instrues:


52

#include<stdio.h>
#include<conio.h>
FILE *arquivo;
struct {
int codigo;
char nome[30];
char telefone[15];
}registro;
main() {
int wcodigo;
char wnome[30];
char wtelefone[15];
char resp;
exit(1);
}
}
fclose(arquivo);
arquivo=fopen("AGENDA.DAT","r+b");
...

Note que nas declaraes os nomes das variveis esto sublinhados. Fizemos este destaque para
indicar que os nomes foram alterados para no entrarem em conflito com os nomes dos campos
definidos na estrutura do arquivo (struct). Agora as variveis wcodigo, wnome e wtelefone sero as
variveis que recebero os dados pelo teclado, e codigo, nome e telefone sero os campos do
arquivo de dados.

Terceiro passo: Escrita dos dados
No primeiro passo realizamos a preparao do ponteiro e a definio da estrutura do arquivo de
dados, ou seja, definimos um nome para referenciar o arquivo (nome do ponteiro) e definimos os
nomes e tipos dos campos que sero gravados (codigo, nome e telefone).
No segundo passo realizamos a abertura do arquivo de dados.
Agora falta apenas saber como escrever os dados no arquivo. Para isto, devemos receber as
informaes pelo teclado e transferi-las para o arquivo. Vamos utilizar uma estrutura de repetio
que ser iniciada com o rtulo incio, veja como ficar o algoritmo em Inter-S deste trecho:

[inicio]
Limpa
Receba "Digite o codigo do amigo..: ", wcodigo
Receba "Digite o nome do amigo....: ", wnome
Receba "Digite o telefone do amigo: ", wtelefone
Codigo = wcodigo
Nome = wnome
Telefone = wtelefone
Grave item[codigo] AGENDA.DAT
Receba "Continua (S/N)? ", resp
Se resp = 'N' ou resp = 'n' entao
Interrompa
FimSe
Vapara inicio

53

Observe que no algoritmo, aps o recebimento dos dados pelo teclado, estamos atribuindo aos
campos do registro os contedos recebidos pelas variveis:
Codigo = wcodigo
Nome = wnome
Telefone = wtelefone

Em linguagem C, para referenciar um campo devemos informar o nome do registro (que no nosso
caso o prprio nome registro - definido na estrutura struct) seguido por um ponto final e o nome do
campo. Exemplo: registro.codigo.
Em seguida devemos gravar o registro no arquivo, usamos em Inter-S o seguinte comando:
Grave Item[codigo] AGENDA.DAT

A figura abaixo ilustra o processo de gravao, observe-a:

Implementando este processo de gravao no nosso programa AGENDA.C, teremos o seguinte
cdigo final:

#include<stdio.h>
#include<conio.h>
FILE *arquivo;
struct {
int codigo;
char nome[30];
char telefone[15];
}registro;
main() {
int wcodigo;
char wnome[30];
char wtelefone[15];
char resp;
exit(1);
}
}
fclose(arquivo);
registro

wcodigo codigo

wnome nome

wtelefone telefone
a) os dados so digitados
pelo teclado e armazenados
nas variveis wcodigo,
wnome e wtelefone b) os dados so repassados para os
campos do registro. Na realidade, a
varivel registro uma estrutura que
possui 3 outras variveis: codigo, nome
e telefone.
c) A varivel registro gravada no
arquivo em disco, levando consigo
as 3 variveis que a formam.

54
inicio:
clrscr();
printf("Digite o codigo do amigo..: ");scanf("%d",&wcodigo);
printf("Digite o nome do amigo....: ");scanf("%s",wnome);
printf("Digite o telefone do amigo: ");scanf("%s",wtelefone);
registro.codigo = wcodigo;
strcpy(registro.nome, wnome);
strcpy(registro.telefone, wtelefone);
fwrite(&registro, sizeof(registro), 1, arquivo);
printf("Continua (S/N)? ");scanf("%s",&resp);
if (resp=='N' resp=='n') {
fclose(arquivo);
exit(0);
}
goto inicio;
}

Observando o programa acima voc encontrar algumas funes que, a princpio, nos parecem
bastante estranhas (so as funes que destacamos em azul). Vamos analis-las:
strcpy(registro.nome, wnome);
A funo strcpy faz com que a varivel caracter indicada aps a abertura do parntese receba o
contedo da varivel que aparece depois da vrgula. Neste caso registro.nome receber o
contedo de wnome. A instruo equivalente em Inter-S : nome = wnome.
strcpy exigida apenas para atribuies de variveis do tipo string (caracter), para variveis
numricas utiliza-se apenas o sinal de igualdade (=), exemplo: registro.codigo=wcodigo.

fwrite(&registro, sizeof(registro), 1, arquivo);
A funo fwrite faz a gravao (escrita) dos dados no arquivo. Precisamos informar, entre os
parnteses, o nome da varivel que contm os dados (precedida do ponteiro &), o tamanho desta
varivel (sizeof), a quantidade de registros que sero gravados e o nome do ponteiro do arquivo:
&registro..........................Nome da varivel (estrutura) que contm os dados
sizeof(registro)...........Tamanho da varivel (estrutura) que contm os dados
1...........................................Quantidade de registros a gravar
arquivo..............................Nome do ponteiro que identifica o arquivo a ser gravado

fclose(arquivo);
A funo fclose realiza o fechamento do arquivo identificado pelo ponteiro entre parnteses.

Concluindo
A rotina de gravao do programa AGENDA.C est completa. Digite o programa e veja o seu
funcionamento. Mesmo que tenha digitado corretamente, voc notar um grande problema durante a
digitao dos dados, a saber:
Quando voc digita um espao no nome do amigo, o programa colocar o texto que vem aps o
espao como contedo da prxima varivel, gerando uma baguna na lgica do programa. Tente
fazer isso: digite Ze Mane como nome do amigo e perceba que o telefone no ser solicitado, pois o
programa colocar o Ze na varivel wnome e Mane na varivel wtelefone.
Como resolver este problema?
Perceba ento que o espao funciona como um "delimitador" da informao digitada. Para sanar
este problema, faa com que a funo scanf reconhea o espao como um caracter normal.

55

Para isto devemos alterar a rotina de recebimento, implementando alguns itens. Observe como ela
ficar:

printf("Digite o codigo do amigo..: ");scanf("%d",&wcodigo);
fflush(stdin);
printf("Digite o nome do amigo....: ");scanf("%30[A-z ]",wnome);
fflush(stdin);
printf("Digite o telefone do amigo: ");scanf("%15s",wtelefone);
fflush(stdin);

Devemos colocar a funo fflush(stdin) aps as instrues de recebimento
(scanf). Esta funo processa o "descarregamento" da memria do teclado, de
maneira que no reste nenhuma informao "perdida", que poderia ser agregada
indevidamente ao contedo da varivel do prximo scanf.

Para o recebimento dos dados caracteres estamos utilizando um controle um
pouquinho diferente. No programa original estvamos usando a seqncia "%s" para
indicar que a varivel wnome do tipo caractere: scanf("%s",wnome); , agora
estamos usando o controle "%30[A-z ]" : scanf("%30[A-z ]",wnome); . O nmero
30 informa que o tamanho da varivel de 30 caracteres; as letras A-z entre os
colchetes informam que s sero aceitos caracteres de A (maisculo) z
(minsculo), ou seja, durante a digitao do nome do amigo sero aceitas apenas
letras maisculas e/ou minsculas; existe ainda um espao aps o z (antes do
fechamento do colchete), este espao indica que tambm sero aceitos espaos em
branco no nome do amigo. Com estas alteraes o seu programa poder receber
qualquer nome e sobrenome, inclusive o Z Man!

IMPORTANTE: Espero que neste ponto voc j tenha digitado e compilado o programa
AGENDA.C, e observado o seu funcionamento com as implementaes citadas acima. Mas se voc
ainda no fez isso, sugiro que o faa antes de prosseguir, pois os conceitos que veremos a partir
daqui estaro nele baseados.

Instrues necessrias para a leitura de um arquivo de dados

Com certeza voc notou que o programa AGENDA.C no tem sentido nenhum se no tivermos um
programa que faa a leitura do arquivo de dados e que nos mostre os registros gravados. Temos at
dvidas se os registros esto sendo gravados ou no! Bem, esta dvida at que fcil sanar, basta
voc verificar que na pasta onde est o programa, existe agora um arquivo com o nome
AGENDA.DAT, este arquivo armazena os dados que voc digitou.

Como construir um programa para ler este arquivo?

Primeiramente vamos definir como ser esta leitura. Imagine que voc queira ver todos os dados
gravados, ou seja, que voc queira "listar" todos os seus amigos na tela, um a um. Podemos
construir um algoritmo em Inter-S para isto:


56

Rotina
Declare arquivo(AGENDA.DAT) chave(codigo)
Registro ( codigo Numerico [4]
nome caractere [30]
telefone caractere [15])
Abra AGENDA.DAT
Topo
[Inicio]
Leia Proximo registro Agenda.dat
Se nao FDA entao
Escreva "Codigo do amigo", codigo
Escreva "Nome do amigo", nome
Escreva "Telefone do amigo", telefone
Vapara Inicio
FimSe
Feche Agenda.dat
FimRotina

Note que foram introduzidos alguns elementos novos neste algoritmo, como por exemplo a
declarao da estrutura do registro, que estamos colocando logo aps o incio da rotina principal.
Esta declarao corresponde instruo struct (discutida na pgina 49).
A instruo Abra AGENDA.DAT corresponde ao conjunto de instrues para a abertura do arquivo
de dados.
Em seguida aparece o comando Topo, que faz com que o ponteiro de leitura seja posicionado no
primeiro registro do arquivo (topo).
O rtulo [Inicio] indica o ponto de retorno para a leitura do arquivo. Em seguida feita uma leitura no
arquivo (Leia Proximo registro Agenda.data). Esta instruo obtm os dados de um registro
apenas, que correspondem ao dados de um amigo.
Perguntamos em seguida se no final de arquivo: Se nao FDA entao, se a resposta for afirmativa
ento devemos escrever os dados do amigo na tela e voltar para ler o prximo registro (Vapara
Inicio), caso contrrio, devemos fechar o arquivo (Feche Agenda.dat) e encerrar a rotina, pois o final
do arquivo foi atingido.

Veja a seguir o algoritmo escrito em linguagem C :

/* Programa LEAGENDA.C */
#include<stdio.h>
#include<conio.h>
FILE *arquivo;
struct {
int codigo;
char nome[30];
char telefone[15];
}registro;
main() {
exit(1);
}
}
fclose(arquivo);
clrscr();
gotoxy(20,1);cprintf("Leitura do arquivo AGENDA.DAT");

57
rewind(arquivo);
inicio:
if (fread(&registro, sizeof(registro), 1, arquivo) == 1) {
gotoxy(10,3);cprintf("Codigo do amigo..: %d",registro.codigo);
gotoxy(10,4);cprintf("Nome do amigo....: %-30s",registro.nome);
gotoxy(10,5);cprintf("Telefone do amigo: %15s",registro.telefone);
gotoxy(10,7);cprintf("Tecle algo para continuar ");
getch();
goto inicio;
}
fclose(arquivo);
}

Voc no encontrar uma correspondncia direta entre o algoritmo em Inter-S e o programa em
linguagem C. Algumas instrues em Inter-S aparecem como vrias linhas dentro do programa C,
como o caso da instruo Abra AGENDA.DAT, que no programa C aparece como:

exit(1);
}
}
fclose(arquivo);

Vamos agora analisar as novas instrues utilizadas no programa LEAGENDA.C:

rewind(arquivo);
Esta instruo faz com que o ponteiro de leitura do arquivo seja posicionado no primeiro registro.
Corresponde Topo do Inter-S.

if (fread(&registro, sizeof(registro), 1, arquivo) == 1) {
Esta instruo l um registro e ao mesmo tempo pergunta se no final de arquivo. A funo
responsvel pela leitura a fread, que, entre parnteses, leva os seguintes argumentos:
&registro..........................Nome da varivel (estrutura) que receber os dados lidos
sizeof(registro)...........Tamanho do registro que ser lido
1...........................................Quantidade de registros a serem lidos
arquivo..............................Nome do ponteiro que identifica o arquivo a ser lido

Observe que a funo fread comparada com o valor 1 (==1). Se fread for igual a 1 significa que
no final de arquivo.

Esta linha de programa corresponde s seguintes linhas do algoritmo Inter-S:

Leia Proximo registro Agenda.dat
Se no FDA entao


58

gotoxy(10,4);cprintf("Nome do amigo....: %-30s",registro.nome);
claro que esta linha de comando no mais segredo para voc, com exceo do controle "%-30s"
colocado na funo cprintf.
Na realidade o que estamos fazendo posicionando o cursor na coluna 10 da linha 4 (gotoxy(10,4))
e escrevendo, a partir dessa posio, a expresso "Nome do amigo...:" e em seguida o contedo
do campo registro.nome, que corresponde ao nome do amigo que se encontra no registro lido. O
controle "%-30s" faz com que o nome, que possui 30 caracteres, seja escrito da esquerda para a
direita. Este alinhamento obtido graas ao sinal de menos (-) colocado na frente do tamanho do
campo.
Se voc omitir este sinal, ou seja, se o controle for "%30s", o alinhamento do nome ser feito da
direita para a esquerda.

IMPORTANTSSIMO: Digite o programa LEAGENDA.C, cujo cdigo encontra-se a partir da
pgina 55, e veja o seu funcionamento. Voc ter agora dois programas: AGENDA.C, que permite a
gravao dos dados de seus amigos, e LEAGENDA.C, que possibilita a leitura do arquivo.

Atividades complementares

Sofistique os programas AGENDA.C e LEAGENDA.C, colocando cores e molduras. Torne-os mais
agradveis quanto esttica.


59

Apndice A - Funes diversas

Neste apndice voc encontrar algumas funes de bibliotecas interessantes para deixar seus
programas mais sofisticados. Mostramos o nome da biblioteca (aquela que dever ser indicada na
diretiva #include), a sintaxe requerida pela funo e o seu propsito.

Entrada de caracter individual: getchar()

Biblioteca: stdio.h
Sintaxe....: getchar();
Propsito: A funo getchar() (get character) l um caracter individual da entrada padro (em
geral, o teclado).

Esta funo dita line buffered, isto , no retorna valores at que o caracter de controle line
feed (\n) seja lido. Este caracter, normalmente, enviado pelo teclado quando a tecla [enter]
pressionada. Se forem digitados vrios caracteres, estes ficaro armazenados no buffer de
entrada at que a tecla [enter] seja pressionada. Ento, cada chamada da funo getchar() ler
um caracter armazenado no buffer.

Sada de caracter individual: putchar()

Biblioteca: stdio.h
Sintaxe....: putchar(int c);
Propsito: Esta funo putchar() (put character) imprime um caracter individual c na sada
padro (em geral o monitor de vdeo).

Leitura de teclado: getch(), getche()

Biblioteca: conio.h
Sintaxe....: getch();
getche();

Propsito: Estas funes fazem a leitura dos cdigos de teclado. Estes cdigos podem
representar teclas de caracteres (A, y, *, 8, etc.), teclas de comandos ( [enter], [delete], [Page
Up], [F1], etc.) ou combinao de teclas ([Alt] + [A], [Shift] + [F1], [Ctrl] + [Page Down], etc.).

Ao ser executada, a funo getch() (get character) aguarda que uma tecla (ou combinao de
teclas) seja pressionada, recebe do teclado o cdigo correspondente e retorna este valor. A
funo getche() (get character and echoe) tambm escreve na tela, quando possvel, o caracter
correspondente.

Cdigo ASCII: ao ser pressionada uma tecla correspondente a um caracter ASCII, o teclado
envia um cdigo ao 'buffer' de entrada do computador e este cdigo lido. Por exemplo, se a
tecla A for pressionada o cdigo 65 ser armazenado no buffer e lido pela funo.

Cdigo Especial: ao serem pressionadas certas teclas (ou combinao de teclas) que no
correspondem a um caracter ASCII, o teclado envia ao 'buffer' do computador dois cdigos,
sendo o primeiro sempre 0. Por exemplo, se a tecla [F1] for pressionada os valores 0 e 59
sero armazenados e a funo deve ser chamada duas vezes para ler os dois cdigos.


60

Sada sonora: sound(), delay(), nosound()

Biblioteca: dos.h
Sintaxe....: sound(freq);
delay(tempo);
nosound();

Propsito: A funo sound() ativa o alto-falante do PC com uma freqncia freq (Hz). A funo
delay() realiza uma pausa (aguarda intervalo de tempo) de durao tempo (milisegundos). A
funo nosound() desativa o alto-falante.

Redimencionamento de janela: window()

Biblioteca: conio.h
Sintaxe....: window(esq, sup, dir, inf);

Propsito: Esta funo permite redefinir a janela de texto. As coordenadas esq e sup definem o
canto superior esquerdo da nova janela, enquanto as coordenadas inf e dir definem o canto
inferior direito da nova janela. Para reativar a janela padro escreve-se a instruo
window(1,1,80,25). Quando uma janela definida, o texto que ficar fora da janela fica
congelado at que se redefina a janela original.

Monitorao de teclado: kbhit()

Biblioteca: conio.h
Sintaxe....: kbhit();

Propsito: Esta funo (keyboard hitting) permite verificar se uma tecla foi pressionada ou no.
Esta funo verifica se existe algum cdigo no buffer de teclado. Se houver algum valor, ela
retorna um nmero no nulo e o valor armazenado no buffer pode ser lido com as funes
getch() ou getche(). Caso nenhuma tecla seja pressionada a funo retorna 0. Observe que, ao
contrrio de getch(), esta funo no aguarda que uma tecla seja pressionada.


61
APNDICE B - TABELA ASCII

As tabelas mostradas neste apndice representam os 256 cdigos usados nos computadores
da famlia IBM. Esta tabela refere-se ao American Standard Code for Information Interchange
(cdigo padro americano para troca de informaes), que um conjunto de nmeros
representando caracteres ou instrues de controle usados para troca de informaes entre
computadores entre si, entre perifricos (teclado, monitor, impressora) e outros dispositivos. Estes
cdigos tem tamanho de 1 byte com valores de 00h a FFh (0 a 255 decimal). Podemos dividir estes
cdigos em trs conjuntos: controle, padro e estendido.

Os primeiros 32 cdigos de 00h at 1Fh (0 a 31 decimal), formam o conjunto de controle
ASCII. Estes cdigos so usados para controlar dispositivos, por exemplo uma impressora ou o
monitor de vdeo. O cdigo 0Ch (form feed) recebido por ima impressora gera um avano de uma
pgina. O cdigo 0Dh (carriage return) enviado pelo teclado quando a tecla ENTER pressionada.
Embora exista um padro, alguns poucos dispositivos tratam diferentemente estes cdigos e
necessrio consultar o manual para saber exatamente como o equipamento lida com o cdigo. Em
alguns casos o cdigo tambm pode representar um caracter imprimvel. Por exemplo o cdigo 01h
representa o caracter # (happy face).

Os 96 cdigos seguintes de 20h a 7Fh (32 a 127 decimal) formam o conjunto padro
ASCII. Todos os computadores lidam da mesma forma com estes cdigos. Eles representam os
caracteres usados na manipulao de textos: cdigos-fonte, documentos, mensagens de correio
eletrnico, etc. So constitudos das letras do alfabeto latino (minsculo e maisculo) e alguns
smbolos usuais.

Os restantes 128 cdigos de 80h at FFh (128 a 255 decimal) formam o conjunto estendido
ASCII. Estes cdigos tambm representam caracteres imprimveis porem cada fabricante decide
como e quais smbolos usar. Nesta parte do cdigo esto definidas os caracteres especiais: , , ,
...

Dec. Hex. Controle
0 00h NUL (Null)
1 01h SOH (Start of Heading)
2 02h STX (Start of Text)
3 03h ETX (End of Text)
4 04h EOT (End of Transmision)
5 05h ENQ (Enquiry)
6 06h ACK (Acknowledge)
7 07h BEL (Bell)
8 08h BS (Backspace)
9 09h HT (Horizontal Tab)
10 0Ah LF (Line Feed)
11 0Bh VT (Vertical Tab)
12 0Ch FF (Form Feed)
13 0Dh CR (Carriage Return)
14 0Eh SO (Shift Out)
15 0Fh SI (Shift In)
16 10h DLE (Data Link Escape)
17 11h DC1 (Device control 1)

62
21 15h NAK (Negative Acknowledge)
22 16h SYN (Synchronous Idle)
23 17h ETB (End Transmission Block)
24 18h CAN (Cancel)
25 19h EM (End of Media)
26 1Ah SUB (Substitute)
27 1Bh ESC (Escape)
28 1Ch FS (File Separator)
29 1Dh GS (Group Separator)
30 1Eh RS (Record Separator)
31 1Fh US (Unit Separator)


63

Binrio dec. chr Binrio dec. chr Binrio dec. chr Binrio dec. chr
00000000 0 01000000 64 @ 10000000 128 11000000 192 +
00000001 1 01000001 65 A 10000001 129 11000001 193 -
00000010 2 01000010 66 B 10000010 130 11000010 194 -
00000011 3 01000011 67 C 10000011 131 11000011 195 +
00000100 4 01000100 68 D 10000100 132 11000100 196 -
00000101 5 01000101 69 E 10000101 133 11000101 197 +
00000110 6 01000110 70 F 10000110 134 11000110 198
00000111 7 01000111 71 G 10000111 135 11000111 199
00001000 8 01001000 72 H 10001000 136 11001000 200 +
00001001 9 01001001 73 I 10001001 137 11001001 201 +
00001010 10 01001010 74 J 10001010 138 11001010 202 -
00001011 11 01001011 75 K 10001011 139 11001011 203 -
00001100 12 01001100 76 L 10001100 140 11001100 204
00001101 13 01001101 77 M 10001101 141 11001101 205 -
00001110 14 01001110 78 N 10001110 142 11001110 206 +
00001111 15 01001111 79 O 10001111 143 11001111 207 -
00010000 16 01010000 80 P 10010000 144 11010000 208 -
00010001 17 01010001 81 Q 10010001 145 11010001 209 -
00010010 18 01010010 82 R 10010010 146 11010010 210 -
00010011 19 01010011 83 S 10010011 147 11010011 211 +
00010100 20 01010100 84 T 10010100 148 11010100 212 +
00010101 21 01010101 85 U 10010101 149 11010101 213 +
00010110 22 01010110 86 V 10010110 150 11010110 214 +
00010111 23 01010111 87 W 10010111 151 11010111 215 +
00011000 24 01011000 88 X 10011000 152 11011000 216 +
00011001 25 01011001 89 Y 10011001 153 11011001 217 +
00011010 26 01011010 90 Z 10011010 154 11011010 218 +
00011011 27 01011011 91 [ 10011011 155 11011011 219 _
00011100 28 01011100 92 \ 10011100 156 11011100 220 _
00011101 29 01011101 93 ] 10011101 157 11011101 221
00011110 30 01011110 94 ^ 10011110 158 P 11011110 222 _
00011111 31 01011111 95 _ 10011111 159 11011111 223 _
00100000 32 spc 01100000 96 ` 10100000 160 11100000 224 _
00100001 33 ! 01100001 97 a 10100001 161 11100001 225
00100010 34 01100010 98 b 10100010 162 11100010 226 _
00100011 35 # 01100011 99 c 10100011 163 11100011 227
00100100 36 $ 01100100 100 d 10100100 164 11100100 228 _
00100101 37 % 01100101 101 e 10100101 165 11100101 229 _
00100110 38 & 01100110 102 f 10100110 166 11100110 230
00100111 39 01100111 103 g 10100111 167 11100111 231 _
00101000 40 ( 01101000 104 h 10101000 168 11101000 232 _
00101001 41 ) 01101001 105 i 10101001 169 _ 11101001 233 _
00101010 42 * 01101010 105 j 10101010 170 11101010 234 _
00101011 43 + 01101011 107 k 10101011 171 11101011 235 _
00101100 44 , 01101100 108 l 10101100 172 11101100 236 _
00101101 45 - 01101101 109 m 10101101 173 11101101 237 _
00101110 46 . 01101110 110 n 10101110 174 11101110 238 _
00101111 47 / 01101111 111 o 10101111 175 11101111 239 _
00110000 48 0 01110000 112 p 10110000 176 _ 11110000 240 _
00110001 49 1 01110001 113 q 10110001 177 _ 11110001 241
00110010 50 2 01110010 114 r 10110010 178 _ 11110010 242 _
00110011 51 3 01110011 115 s 10110011 179 11110011 243 _
00110100 52 4 01110100 116 t 10110100 180 11110100 244 _
00110101 53 5 01110101 117 u 10110101 181 11110101 245 _
00110110 54 6 01110110 118 v 10110110 182 11110110 246
00110111 55 7 01110111 119 w 10110111 183 + 11110111 247 _
00111000 56 8 01111000 120 x 10111000 184 + 11111000 248
00111001 57 9 01111001 121 y 10111001 185 11111001 249
00111010 58 : 01111010 122 z 10111010 186 11111010 250
00111011 59 ; 01111011 123 { 10111011 187 + 11111011 251 _
00111100 60 < 01111100 124 | 10111100 188 + 11111100 252 n
00111101 61 = 01111101 125 } 10111101 189 + 11111101 253
00111110 62 > 01111110 126 ~ 10111110 190 11111110 254 _
00111111 63 ? 01111111 127 10111111 191 + 11111111 255 _


64

Apostila de Algoritmos

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Apostila de Algoritmos

Uploaded by

Copyright:

Available Formats

Conceitos Bsicos de

You might also like