Apostila de Linguagem C

Conceitos Bsicos de
Linguagem de Programao C
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
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:
Programa
Fonte
(em linguagem
simblica)
(a)
Compilador
(b)
Programa
executvel
(em linguagem
de mquina)
(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.
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
/* Programa Licao1
Autor: <nome-do-aluno>
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>
Rotina
Declare valor1, valor2, resultado Numerico
Receba valor1
Receba valor2
Resultado = valor1 + valor2
Escreva resultado
FimRotina
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).
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-evrgula (;)
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:
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:
// Programa: Lio 1
// Data : 99/99/9999
/* Programa Licao1
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>
Rotina
Declare valor1, valor2, resultado Numerico
Limpa
Escreva "Programa LICAO1"
Escreva "Digite o 1 valor:"
Receba valor1
Receba valor2
Escreva "Soma dos valores:"
Escreva resultado
FimRotina
main() {
clrscr();
printf("Programa LICAO1\n");
printf("Digite o 1 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!
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 InterS 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 (*).
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!).
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
/* Programa Licao2
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>
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
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:
Comentrios
/* Programa Licao2
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>
Documentao
Documentao
Documentao
Final da documentao
Diretiva de compilao
Diretiva de compilao
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;
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 "
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 "
Int
"
Float "
Double "
Declara a varivel como alfanumrica

Declara a varivel como numrica inteira
Declara a varivel como numrica real de 7 dgitos
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
int numero;
float numero;
double numero;
char letra;
char texto[20];
Formato do scanf
scanf("%d",&numero);
scanf("%f",&numero);
scanf("%f",&numero);
scanf("%c",&letra);
scanf("%20s",texto);
10
Formato do printf
printf("%d",numero);
printf("%f",numero);
printf("%f",numero);
printf("%c",letra);
printf(texto);
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.
11
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 (runtime 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:
Valor Ordem
Expresso
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.
12
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
/* Programa Licao3A
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>
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
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.
13
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:
floor(num) ;
// Exemplo:
Funes diversas:
log(num);
log10(num);
pow(base, exp);
sqrt(num);
//
//
//
//
ceil(3.2) == 3.0;
floor(3.2) == 4.0;
Logaritmo natural (base e)

Logaritmo decimal (base 10)
Potenciacao: pow(3.2,5.6)=3.25.6.
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
/* Programa Licao3B
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>
#include <math.h>
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
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.
14
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:
a1)
a2)
a3)
w+z
(w+100) x V z
V w2 + z2
Obs: Grave o programa fonte como EXERC3.
15
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
V
bloco
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
/* Programa Licao4A
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>
#include <math.h>
Rotina
Declare num, resultado Numerico
Limpa
Receba num
Se num > = 0 entao
resultado = raiz(num)
Escreva "Raiz quadrada: "
Escreva resultado
FimSe
FimRotina
main() {
float num, resultado;
clrscr();
scanf("%f",&num);
if(num >= 0) {
printf("Raiz Quadrada: ");
}
}
16
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
/* Programa Licao4B
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>
#include <math.h>
Rotina
Declare num, resto Numerico
Limpa
main() {
int num, resto;
clrscr();
17
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
15
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:
18
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
Se x = 0 e y = 0 entao ...
Linguagem C
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
Se x = 0 ou y = 0 entao ...
Linguagem C
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.
19
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.
expresso
rotulo 1
conjunto 1
rotulo 2
conjunto 2
...
rotulo N
conjunto N
default
conjunto D
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:
20
// Programa: Lio5A
// Data : 99/99/9999
/* Programa Licao5A
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>
Rotina
main() {
Declare selecao Numerico
int selecao;
clrscr();
Limpa
printf("Selecione o estgio: ");
Escreva "Selecione o estgio:"
scanf("%d",&selecao);
Receba selecao
switch(selecao) {
Caso selecao
case 1:printf("Obter ingredientes\n");
Seja =1 faca Escreva "Obter ingredientes"
case 2:printf("Juntar \n");
Seja =2 faca Escreva "Juntar"
case 3:printf("Bater a massa\n");
Seja =3 faca Escreva "Bater a massa"
case 4:printf("Colocar na forma\n");
Seja =4 faca Escreva "Colocar na forma"
case 5:printf("Levar ao forno\n");
Seja =5 faca Escreva "Levar ao forno"
default:printf("Fim\n");
CasoNao faca Escreva "Fim"
}
FimCaso
}
FimRotina
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 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;
21
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.
22
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?
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
/* Programa Licao6A
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>
Rotina
Declare num Numerico
main() {
float num;
23
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:
condio?
V
bloco
Figura 6.2: Fluxograma da estrutura while.
24
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
/* Programa Licao6B
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>
Rotina
Declare num Numerico
Num = 1
Limpa
Enquanto num > 0 Faca
Receba num
Escreva "Quadrado: "
Escreva num*num
FimEnquanto
FimRotina
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.
25
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
/* Programa Licao6C
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>
Rotina
Declare i Numerico
Limpa
Para i=1 Ate 10 Faca
Escreva i
FimPara
FimRotina
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;
do{
printf("%d",i);
i=i+1;
}while(i <= 10);
for(i = 1; i <= 10; i=i+1){

printf("%d",i);
}
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.
26
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
/* Programa Licao7A
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>
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
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.
27
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
/* Programa Licao7B
Data.: 99/99/9999
*/
#include <stdio.h>
#include <conio.h>
Rotina
Declare valor1, valor2, y Numerico
//
Declare media Numerico
Processe Preparar_tela
Receba valor1
Receba valor2
Processe media
Escreva "Media: "
Escreva y
FimRotina
main() {
float valor1, valor2, y;
void preparar_tela();
float media(float, float);
preparar_tela();
scanf("%f",&valor1);
scanf("%f",&valor2);
y = media(valor1, valor2);
printf("Mdia: ");
printf("%f",y);
}
SubRotina Preparar_tela
Limpa
Escreva "Programa LICAO7B"
FimSubRotina
void preparar_tela() {
clrscr();
printf("Programa LICAO7B\n");
}
SubRotina Media
//
y = (a + b) / 2
//
FimSubRotina
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:
28
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.
29
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
4
.
.
.
.
.
25
. (6,3)
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:
30
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
Escreva "Ola pessoal"
Escreva vl
Escreva "Valor=" , vl
Linguagem C
printf("Ola pessoal");
printf("%d",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:
Algoritmo Inter-S
Escreva "Ola pessoal"
Escreva vl
Escreva "Valor=" , vl
Linguagem C
cprintf("Ola pessoal");
cprintf("%d",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
Preto
Azul
Verde
Ciano
-
N
0
1
2
3
Cor
Vermelho
Magenta
Marrom
Cinza claro
N
4
5
6
7
Cor
Cinza escuro
Azul claro
Verde claro
Ciano claro
N
8
9
10
11
Cor
Vermelho claro
Magenta claro
Amarelo
Branco
N
12
13
14
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:
31
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).
32
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:
.-------------------.
| Exemplo de tela |
|
Linguagem C
|
'-------------------'
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:
218 196 194 191
179
195
192
180
193 217
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("
Exemplo de tela
Linguagem C
33
");
");
");
");
Note que, durante a

digitao, os caracteres
aparecero unidos, dando
um efeito de linhas
contnuas.
Neste caso, o efeito ser o seguinte:

Exemplo de tela
Linguagem C
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:
Algoritmo Inter-S
Receba vl
Receba "Digite o valor",vl
Linguagem C
scanf("%d",&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:
34
Funo
printf()
cprintf
textcolor()
textbackground()
gotoxy()
clrscr()
scanf()
Quadro sinptico de funes

Objetivo
Exemplo
Sada formatada
printf("Ola pessoal");
Sada formatada em cores
cprintf("Ola pessoal");
Definio da cor do texto
textcolor(9);
Definio da cor do segundo plano textbackground(4);
Posicionamento do cursor
gotoxy(10,5);
Apaga a tela
clrscr();
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

/* Programa SOMA.C
Autor: Vichinsky
Data.: 01/01/2000
*/
#include <stdio.h>
#include <conio.h>
Rotina
main() {
Declare N1, N2, Soma Numericos
int n1, n2, soma;
Receba "Digite o primeiro nmero", N1
printf("Digite o 1 nmero");scanf("%d",&n1);
Receba "Digite o segundo Nmero", N2
printf("Digite o 2 nmero");scanf("%d",&n2);
Soma = N1 + N2
soma = n1 + n2;
Escreva "Soma", Soma
printf("Soma %d",soma);
FimRotina
}
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.
35
/* 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 :
Para obter este caracter
pressione ALT + 218
ALT+195
ALT+196
ALT+191
ALT+180
");
");
");
");
");
");
");
PROGRAMA SOMA.C
Digite o 1 numero:
Digite o 2 numero:
Soma..............:
ALT+192
ALT+179
ALT+217
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.
36
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);
gotoxy(1,2);cprintf(" PROGRAMA SOMA.C
gotoxy(1,6);cprintf(" Soma..............:
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.
37
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:
Origem
(0,0)
y
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.
38
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:
39
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
EGA
EGA
VGA
VGA
VGA
Resoluo
Baixa (Low)
Alta (High)
Baixa (Low)
Media (Med)
Alta (High)
Valor de
gdriver
EGA
EGA
VGA
VGA
VGA
Valor de
gmode
EGALO
EGAHI
VGALO
VGAMED
VGAHI
Quantidade de
pontos
640 x 200
640 x 350
640 x 200
640 x 350
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);
}
40
Explicaes
Na tabela abaixo estamos reproduzindo o programa GRAF1.C com as devidas explicaes para
cada uma das linhas de instrues:
Linhas de instrues
/* Programa GRAF1.C -Desenha um crculo */
#include <stdio.h>
#include <conio.h>
main( ) {
exit(1);
}
getch();
closegraph();
exit(0);
}
Explicaes
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:
0
320
640
Raio = 100 pixels

240
480
Y
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.
41
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
Y1=50
Y2=430
X2=500
42
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];).
43
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
Seta p/ cima
H
Seta p/ baixo
P
Seta p/ direita
M
Seta p/ esquerda K
Dgito 0 (zero)
0
Dgito 1 (um)
1
Dgito 2 (dois)
2
Dgito 3 (trs)
3
Asterisco
*
Ao
Diminui 1 da varivel y e coloca um ponto na nova coordenada.
Soma 1 na varivel y e coloca um ponto na nova coordenada.
Soma 1 da varivel x e coloca um ponto na nova coordenada.
Diminui 1 da varivel x e coloca um ponto na nova coordenada.
Ajusta a cor para 0 (preto)
Ajusta a cor para 1 (azul)
Ajusta a cor para 2 (verde)
Ajusta a cor para 3 (ciano)
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);
}
44
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(2); outtextxy(10, 16, "Cor 2"); circle(70,20,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");
45
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
}
46
*/
*/
*/
*/
*/
*/
*/
*/
*/
*/
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.
47
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.
48
Para ilustrar este conceito, vamos imaginar que a nossa agenda de amigos tenha as seguintes
informaes:
Cdigo
1
2
3
4
5
Agenda de amigos
Nome
Antonio Laurentino Miguel
Bianco Branco de Assis Moreira
Juarez Joo Columbiano Mattos
Pedro Pedreira Rocha
Z Man
Telefone
1234-5678
8765-4321
9999-7777
0001-1110
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.
Z Man
Campo 1
(cdigo)
1000-1234
Campo 2 (nome)
Campo 3 (telefone)
Registro
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;
49
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 {
int codigo;
char nome[30];
char telefone[15];
} registro;
Inicia a definio da estrutura

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

Apostila de Linguagem C

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 Linguagem C

Uploaded by

Copyright:

Available Formats

Conceitos Bsicos de

Programao em linguagem simblica

Programa fonte em Linguagem C

Resultado = valor1 + valor2

Digitando o programa fonte e criando o cdigo executvel

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

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

Execute o programa atravs do comando RUN/RUN. No caso de existirem erros de digitao, o

Implementando novos comandos no programa LICAO1

Programa fonte em Linguagem C

Escreva "Programa LICAO1"

As outras instrues introduzidas so instrues tambm de escrita: Escreva (printf), que tm o

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

b) Elabore um programa para exibir o quadrado de um nmero digitado D-lhe o nome de

Lio 2 - Variveis e Constantes

Programa fonte em Linguagem C

Rtulo da rotina principal

Escreve na tela o contedo da varivel produto

Declara a varivel como alfanumrica

Lio 3 - Operadores e funes matemticas

Exemplo: Algumas expresses aritmticas:

Os operandos das expresses aritmticas devem ser constantes numricas ou identificadores de

Programa fonte em Linguagem C

Logaritmo natural (base e)

Programa fonte em Linguagem C

Obs: Grave o programa fonte como EXERC3.

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

Estrutura de deciso if...else (se...ento...seno)

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

O programa LICAO4A ilustra a utilizao de uma estrutura condicional simples. O programa

Programa fonte em Linguagem C

Condicional composta: Deciso de dois blocos (if...else)

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

O programa LICAO4B, apresentado a seguir, ilustra a utilizao de uma estrutura condicional

Programa fonte em Linguagem C

printf("Digite um nmero: ");

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.

Neste trecho do programa, primeiramente feita a pergunta: resto = 0 ?. Se a resposta for

So trs os operadores lgicos da linguagem C: &&, e !. Estes operadores tm a mesma

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

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

O programa LICAO5A, demonstrado a seguir, ilustra o uso da instruo switch em um menu de

Programa fonte em Linguagem C

Programa fonte em Linguagem C

Lio 6 - Estruturas de repetio

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

Programa fonte em Linguagem C

Figura 6.2: Fluxograma da estrutura while.

Programa fonte em Linguagem C

Programa fonte em Linguagem C

for(i = 1; i <= 10; i=i+1){

Desvio VaPara (goto).

Programa fonte em Linguagem C

Programa fonte em Linguagem C

float media(float a, float b) {

Observe agora a instruo de chamada da funo media:

Tela em modo texto

Em analogia ao par cartesiano, as colunas representam o eixo X e as linhas o eixo Y. Um ponto de

Antes da apresentao das funes, convm explicarmos as abreviaturas e convenes que

Funo printf() - (print formated) - escrita formatada

Funo gotoxy() - (go to position x, y) - posicionamento do cursor

Alguns recursos interessantes

Os caracteres apresentados acima no existem no teclado, para extra-los devemos manter