Você está na página 1de 144

Lgica e Linguagem de Programao

Introduo ao Desenvolvimento de Software

Humberto Martins Beneduzzi


professor do Instituto Federal do Paran IFPR. Graduado
em Sistemas de Informao pelo CEFET-PR e especialista em
Metodologia do Ensino Superior pelo IBPEX. desenvolvedor de
software desde 1995. J participou de projetos de desenvolvimento
de software em empresas de pequeno, mdio e grande portes,
utilizando diversas tecnologias e linguagens de programao.

Joo Ariberto Metz


Tcnico em Programao de Computadores pela SPEI e
graduado em Anlise de Sistemas, pela ESEEI. Trabalhou por
mais de 20 anos na funo de Programador de Computador
no antigo CEFET-PR, hoje Universidade Tecnolgica Federal do
Paran.
Direo Geral Jean Franco Sagrillo
Direo Editorial Jeanine Grivot
Edio Leonel Francisco Martins Filho
Gerncia de Produo e Arte Marcia Tomeleri
Reviso Jeferson Turbay Braga
Simone Venske
Reviso Comparativa Renee Cleyton Faletti
Projeto Grfico Adriana de Oliveira
Editorao eletrnica Fbio Roberto Hancke

2010

Todos os direitos reservados pela Editora do Livro Tcnico


Edifcio Comercial Sobral Pinto
Avenida Cndido de Abreu 469, 2 andar, conjs. ns 203-205
Centro Cvico CEP: 80530-000
Tel.: 41 3027-5952 / Fax: 41 3076-8783
www.editoralt.com.br
Curitiba PR
Em conformidade com o Catlogo Nacional de Cursos
Tcnicos, este livro indicado, entre outros, para os seguintes
cursos:
Eixo Tecnolgico: Informao e Comunicao
Tcnico em Informtica
Tcnico em Informtica para a Internet
Tcnico em Manuteno e Suporte em Informtica
Tcnico em Programao de Jogos Digitais
Tcnico em Redes de Computadores
Eixo Tecnolgico: Ambiente, Sade e Segurana
Tcnico em Meteorologia
Eixo Tecnolgico: Infraestrutura
Tcnico em Geoprocessamento
Eixo Tecnolgico: Controle e Processos Industriais
Tcnico em Automao Industrial
Tcnico em Mecatrnica
Apresentao

Este livro foi didaticamente pensado para o aluno de nvel tcnico.


Nele, foram privilegiadas as abordagens mais prticas, baseadas em
situaes do dia a dia, em detrimento das abordagens excessivamente
tericas e distantes da realidade dos alunos. Entendemos que a
abordagem to importante para o aprendizado quanto a definio
apropriada do contedo a ser ensinado.
A tentativa de realizar uma abordagem mais leve do assunto, no
nos fez esquecer do nvel de profundidade com que os contedos
devem ser abordados. O objetivo fornecer uma obra didtica, de fcil
acesso, mas, ao mesmo tempo, completa em termos de diversidade e
profundidade do contedo.
Por meio deste livro, procuramos contribuir para a formao dos
futuros profissionais da rea de desenvolvimento de software.
Sumrio
CAPTULO 1 Introduo Lgica de Programao 9
Algoritmos............................................................................................................... 10
Representao de Algoritmos................................................................................ 11
Atividades . ............................................................................................................. 15

CAPTULO 2 Variveis, Tipos de Dados e Constantes 16


Variveis.................................................................................................................. 16
Tipos de Dados....................................................................................................... 18
Declarao de Variveis......................................................................................... 19
Atribuio e Inicializao de Variveis.................................................................. 20
Constantes.............................................................................................................. 22
Atividades................................................................................................................ 23

CAPTULO 3 Operadores e Expresses 24


Operadores Aritmticos......................................................................................... 24
Operadores Relacionais......................................................................................... 27
Operadores Lgicos................................................................................................ 28
Operador Literal...................................................................................................... 32
Teste de Mesa......................................................................................................... 34
Atividades................................................................................................................ 36

CAPTULO 4 Estruturas de Controle 37


Seleo.................................................................................................................... 37
Repetio................................................................................................................ 44
Atividades................................................................................................................ 57

CAPTULO 5 Estruturas de Dados Homogneas 59


Vetores.................................................................................................................... 59
Matrizes................................................................................................................... 64
Atividades................................................................................................................ 69

CAPTULO 6 Estruturas de Dados Homogneas: Ordenao e Pesquisa 70


Ordenao de Vetores............................................................................................ 70
Pesquisa Sequencial.............................................................................................. 76
Pesquisa Binria..................................................................................................... 79
Atividades................................................................................................................ 83
CAPTULO 7 Estruturas de Dados Heterogneas 84
Registros................................................................................................................. 84
Atividades................................................................................................................ 91

CAPTULO 8 Sub-rotinas 92
Procedimentos........................................................................................................ 93
Funes................................................................................................................... 98
Escopo de Variveis................................................................................................ 101
Consideraes sobre o Uso de Sub-rotinas.......................................................... 105
O Uso de Parmetros............................................................................................. 106
Atividades................................................................................................................ 112

CAPTULO 9 Introduo Programao 115


Linguagem de Mquina......................................................................................... 115
Linguagem de Programao.................................................................................. 116
Atividades................................................................................................................ 117

CAPTULO 10 Linguagem Pascal 118


Fundamentos.......................................................................................................... 118
Estruturas de Dados............................................................................................... 127
Sub-rotinas.............................................................................................................. 130
Atividades................................................................................................................ 133

Apndice 1 134
Apndice 2 135

Referncias Bibliogrficas 144


10
1
Introduo Lgica de
Programao
Os softwares, que antigamente s podiam ser executados em computadores, esto cada
vez mais presentes nos dispositivos que utilizamos em nosso dia a dia. Celulares, videogames,
aparelhos de GPS e, at mesmo, fornos micro-ondas possuem software rodando internamente.
A demanda por software nunca foi to grande quanto hoje e tende a crescer cada vez mais.
Por isso, o desenvolvimento de software uma das reas que mais ganhou espao no mercado,
nos ltimos tempos.
A quantidade de mo de obra especializada consideravelmente menor do que a demanda,
e muitas empresas trabalham para formar seus prprios profissionais por causa da dificuldade
de encontr-los no mercado.
Estes so alguns dos motivos que tm levado milhares de pessoas a se interessarem pelo
campo de desenvolvimento de software. E a principal procura por aprender a programar.
Neste contexto, nota-se que muitas vezes a urgncia em se estar pronto para o mercado ou,
ento, em comear a produzir, leva o estudante a tentar partir diretamente para o aprendizado
de uma linguagem de programao. Obviamente, possvel aprender e se tornar um bom profis-
sional partindo deste caminho. Mas talvez esta no seja a forma mais indicada. 9

A falta de uma base conceitual acaba, por diversas vezes, dificultando o trabalho de muitos
desenvolvedores e, em alguns casos, at comprometendo a qualidade de seu trabalho.

Introduo Lgica de Programao


Por isso, o aprendizado da lgica de programao de extrema importncia para aqueles
que desejam se tornar profissionais da rea de desenvolvimento de software. A lgica de pro-
gramao serve como base para o aprendizado de qualquer linguagem de programao, pois os
conceitos estudados se aplicam grande maioria das linguagens.
No nosso dia a dia, nos deparamos com uma srie de situaes que nos levam a utilizar a
lgica. Estas situaes podem ser consideradas pequenos problemas, que sero solucionados com
maior ou menor eficincia e eficcia, dependendo do uso que fizermos da lgica quando elabo-
rarmos suas solues. Por exemplo, escolher o trajeto a ser feito para ir de um local A at um local
B, ou a maneira com que deveremos dispor os materiais para que caibam na mochila, so questes
que nos convidam a utilizar a lgica em sua resoluo.
Agora vamos transportar esta abordagem para os programas de computador. Os softwares
tambm se propem a resolver problemas e, para tal, dependem da lgica que o programador
elaborou quando os desenvolveu.
Possuindo conhecimentos de lgica de programao o profissional poder oferecer
solues melhores na resoluo de problemas computacionais. Deste modo, a lgica torna-se
indispensvel na formao de um bom programador, pois os conhecimentos adquiridos nesta
disciplina sero utilizados para realizar o trabalho, independentemente da tecnologia ou lingua-
gem de programao escolhida.
Algoritmos
Um algoritmo um conjunto de instrues, dispostas em uma sequncia lgica, que
levam resoluo de um problema. Em outras palavras, um algoritmo uma espcie de passo
a passo para se chegar soluo de um problema.
Por exemplo, este simples algoritmo descreve a sequncia de passos necessria para subs-
tituir as pilhas do controle remoto:
1. Pegar as pilhas novas.
2. Abrir o controle remoto.
3. Retirar as pilhas usadas.
4. Colocar as pilhas novas.
5. Fechar o controle remoto.
6. Testar o controle remoto.
7. Colocar as pilhas usadas no lixo apropriado.
importante entender que um algoritmo descreve uma possvel soluo para um pro-
blema. Isto significa que um algoritmo pode no resolver o problema de forma satisfatria,
mas tambm significa que mesmo que o algoritmo gere o resultado esperado, ele no a nica
forma de se resolver o problema.
extremamente comum, e at esperado, que duas pessoas escrevam algoritmos diferentes
para resolver um mesmo problema. Logo, o nvel de eficincia e eficcia de cada um dos algorit-
10
mos ser influenciado por vrios fatores, porm talvez os dois principais sejam o domnio que a
pessoa tem sobre o problema e o seu nvel de conhecimento sobre lgica de programao.
Introduo Lgica de Programao

Por isso, se dois algoritmos diferentes resolvem o mesmo problema, no h como dizer
que um est correto e o outro incorreto. O que possvel que um algoritmo seja mais efi-
ciente do que o outro.
Existem algumas caractersticas que definem os algoritmos, e que devem ser consideradas
quando da sua criao:
Finitude: um algoritmo deve ter um nmero finito de passos.
Exatido ou definio: todas as etapas que compem um algoritmo devem ser cla-
ramente definidas e ordenadas, sem margem para interpretaes ambguas.
Entradas e sadas determinadas: todos os dados de entrada e sada do algoritmo devem
estar explicitados. Um algoritmo pode ter zero ou mais entradas mas deve ter ao menos uma
sada.
Efetividade: o algoritmo deve solucionar o problema a que se prope.
Eficincia: o algoritmo deve ser o mais eficiente possvel, buscando sempre a melhor
combinao de trs fatores: tempo, esforo e recursos necessrios.
Algoritmo X Software
De uma maneira bastante simples, podemos dizer que um software composto por um
conjunto de instrues, escritas em uma sequncia lgica, que permitem ao computador resol-
ver um determinado problema. Ou seja, os softwares so baseados em algoritmos.
Mas, para que o computador consiga interpretar as instrues, estas devem ser descritas
em linguagens especficas, chamadas de linguagens de programao. Um algoritmo, quando
escrito em linguagem de programao, chamado de cdigo fonte.
No entanto, quando estamos pensando na melhor forma de resolver um problema
computacional, melhor utilizarmos uma linguagem mais prxima natural, principalmente pela
facilidade de compreenso. E para isso, existem diversas formas de representao de algoritmos.

Representao de Algoritmos
Um algoritmo pode ser representado de vrias formas, dependendo dos objetivos e das
preferncias de seu desenvolvedor. As principais formas de representao de algoritmos so:
Descrio Narrativa;
Pseudocdigo;
Fluxograma;
Diagrama de Chapin.
11

Descrio Narrativa

Introduo Lgica de Programao


a descrio dos passos a serem executados pelo algoritmo, feita diretamente em lin-
guagem natural. Os passos so listados um aps o outro, na sequncia em que devem ser
executados, cada um em uma nova linha de texto.
Exemplo de algoritmo para trocar uma lmpada:
1. Pegar a escada.
2. Posicionar a escada sob a lmpada.
3. Pegar a lmpada nova.
4. Subir na escada.
5. Remover a lmpada antiga.
6. Colocar a lmpada nova.
7. Descer da escada.
8. Colocar a lmpada antiga no lixo.
9. Guardar a escada.
A descrio narrativa, embora de fcil compreenso, totalmente informal e no padroni-
zada. E por ser desprovida de regras, tende a tornar a descrio do algoritmo bastante imprecisa.
O resultado acaba sendo a criao de algoritmos que no atendem as caractersticas esperadas.

Pseudocdigo
O pseudocdigo, que tambm conhecido como portugus estruturado ou portu-
gol, uma tcnica mais formal e estruturada uma vez que possui algumas regras definidas.
Normalmente, estas regras so prximas s adotadas pelas linguagens de programao, o que
bastante positivo para o estudante, pois quando ele tiver contato com as linguagens de pro-
gramao seu aprendizado ser mais fcil. Por isso, o pseudocdigo ser bastante utilizado ao
longo deste livro.
Talvez um dos maiores benefcios do pseudocdigo esteja no fato de ele nos oferecer a
estruturao bsica utilizada nas linguagens de programao, aliada facilidade de compreenso
da nossa linguagem natural, o que possibilita uma maior concentrao no entendimento do
problema e dos passos necessrios para sua resoluo. Este o principal motivo pelo qual o tra-
balho com pseudocdigo facilita o entendimento e a aprendizagem da lgica de programao.
As linguagens de programao so praticamente todas compostas por comandos represen-
tados por palavras da lngua inglesa. O pseudocdigo permite que descrevamos os comandos que
compe o algoritmo em uma linguagem mais amigvel para ns, programadores, analistas, etc.
Mais adiante, veremos que os comandos que utilizamos no pseudocdigo equivalem aos
comandos de linguagem de programao. Ou seja, o portugus estruturado nada mais do que
uma forma de utilizar o portugus para representar comandos que sero passados ao compu-
tador. Posteriormente, iremos traduzir alguns dos nossos programas feitos em pseudocdigo
12
para uma linguagem real de programao e, a sim, os programas podero ser executados no
computador.
Introduo Lgica de Programao

Como a lgica j estar pronta, teremos apenas que substituir os comandos do portugus
estruturado pelos comandos reais da linguagem de programao a ser utilizada, que, no nosso
caso, ser a linguagem Pascal.
Veja o mesmo algoritmo do exemplo anterior, representado em pseudocdigo:

{Algoritmo que descreve os passos para trocar uma lmpada}


Algoritmo TrocaLampada
Incio
Pegar a escada;
Posicionar a escada sob a lmpada;
Pegar a lmpada nova;
Subir na escada;
Remover a lmpada antiga;
Colocar a lmpada nova;
Descer da escada; {este outro comentrio}
Colocar a lmpada antiga no lixo;
Guardar a escada;
Fim
Padres para Representao de Algoritmos Por Meio de
Pseudocdigo
Na primeira linha, aps a palavra Algoritmo, informado o nome do algoritmo que est
sendo descrito.
O comeo dos passos de execuo do algoritmo demarcado pela palavra Incio.
O trmino dos passos de execuo do algoritmo demarcado pela palavra Fim.
O final de cada passo marcado por um ponto e vrgula ( ; ).
Todos os comandos entre Incio e Fim esto levemente deslocados para a direita. Este
deslocamento se chama Identao e, normalmente, ocupa o espao equivalente a trs
letras.
Existe tambm a possibilidade de acrescentarmos comentrios nos algoritmos, a fim de
facilitar seu entendimento para outras pessoas. Alm disso, bastante comum a prpria pessoa
que desenvolveu um algoritmo depois de um tempo no lembrar o porqu de uma determi-
nada sequncia de comandos ter sido definida. Isso acontece geralmente em algoritmos mais
complexos. Por isso, uma boa prtica sempre incluir comentrios nos seus algoritmos.
Para incluir um comentrio em um algoritmo basta utilizar chaves ( { } ), envolvendo o
texto do comentrio. Observe que no algoritmo anterior existem dois comentrios, um deles
utilizando uma linha inteira e o outro inserido depois de um passo do algoritmo. Um comen-
trio tambm pode ocupar vrias linhas de texto.
Neste primeiro exemplo de pseudocdigo, os passos a serem executados esto escritos de
forma bastante informal. Porm, quando estivermos construindo um algoritmo que represente 13
um software, os passos devero ser informados de forma mais concisa e estruturada, respeitando
algumas regras, pois representaro comandos que sero executados pelo computador.

Introduo Lgica de Programao


Regras para Nomenclatura de Algoritmos
Nomes de algoritmos devem conter apenas letras, nmeros e o caractere underscore ( _ ).
Embora seja possvel declarar todo o nome em letras maisculas, recomendado, por
conveno, utilizar letras maisculas apenas no incio de cada palavra que compe o nome
do algoritmo. Estas palavras podem ser escritas todas juntas, ou separadas pelo caractere
underscore.
Exemplos de nomes vlidos Exemplos de nomes invlidos
Calcular_IMC Calcular IMC
RealizarSaque 1saque
FECHAR_CONTA #Fechar_conta

Todos estes padres facilitam a criao de algoritmos consistentes e de boa legibilidade


e por isso iremos utiliz-los daqui para a frente, com outras regras que sero apresentadas ao
longo do livro.
Fluxograma
Os fluxogramas, que tambm so chama-
dos de diagramas de blocos, nos permitem dar uma
representao visual para o algoritmo, facilitando sua
compreenso. Incio

Para criar um fluxograma utilizam-se figuras


geomtricas, cada uma com um significado diferente,
e dentro das quais so colocadas as instrues refe- P egar a escada
rentes a cada passo do algoritmo.
A indicao do fluxo de execuo feita por
meio de setas, estando sempre o incio do algoritmo P osicionar a escada
na parte de cima da figura e seu trmino na parte de sob a lm pada
baixo.
direita, temos o algoritmo referente troca
da lmpada, representado em um fluxograma. P egar a lm pada nova

Por se tratar de um algoritmo bastante simples,


foram necessrios apenas dois tipos de figuras:
S ubir na escada

R em over a lm pada antiga


Terminal
Serve para demarcar o incio ou trmino de um algoritmo.
14
C olocar a lm pada nova
Introduo Lgica de Programao

Processamento
D escer da escada
Representa operaes de processamento.

Uma desvantagem dos fluxogramas que eles C olocar a lm pada


consomem bastante espao, o que limita sua utiliza- antiga no lixo
o a algoritmos de pequeno e mdio porte.
Existem vrias outras figuras utilizadas na cons-
truo de fluxogramas, as quais iremos conhecendo G uardar a escada
conforme avanarmos no contedo deste livro. Uma
listagem completa de todas as figuras utilizadas nos
fluxogramas ao longo do livro est disponvel no F im
Apndice 1, na pgina 134.
O fluxograma e o pseudocdigo so as duas for-
mas mais utilizadas na representao de algoritmos.
Diagrama de Chapin
O diagrama de Chapin, tambm conhecido como diagrama de Nassi-Schneiderman, uma
forma de representao hierrquica da lgica do programa. Este diagrama construdo em um grande
quadro, dividido em blocos medida em que as aes de processamento vo sendo inseridas.
Veja o algoritmo para troca de uma lmpada, agora representado no diagrama de Chapin:
Incio
Pegar a escada
Posicionar a escada sob a lmpada
Pegar a lmpada nova
Subir na escada
Remover a lmpada antiga
Colocar a lmpada nova
Descer da escada
Colocar a lmpada antiga no lixo
Guardar a escada
Fim

Novamente, por se tratar de um algoritmo bastante simples, o quadro que compe


o algoritmo est apenas dividido em blocos horizontais para abrigar cada um dos passos de
processamento.
Veremos exemplos e outros detalhes sobre este diagrama mais adiante.

15

Atividades

Introduo Lgica de Programao


1) Crie um algoritmo, utilizando a descrio narrativa, que des-
creva os passos necessrios para trocar o pneu de um carro.
2) Crie um algoritmo, utilizando a descrio narrativa, que des-
creva os passos necessrios para preparar caf, utilizando
uma cafeteira.
3) Crie um algoritmo, utilizando a descrio narrativa, que des-
creva os passos necessrios para escovar os dentes.
4) Escreva um algoritmo, utilizando a descrio narrativa, que
represente outra possvel soluo para o problema da troca
das pilhas do controle remoto.
5) No exerccio 1, voc criou um algoritmo que descrevia os pas-
sos necessrios para trocar o pneu de um carro, utilizando a
descrio narrativa. Agora, represente este algoritmo, utilizando
as trs formas de representao estudadas neste captulo:
a. pseudocdigo;
b. fluxograma;
c. diagrama de Chapin.
021

Variveis, Tipos
de Dados e
Constantes
Variveis
Ao longo dos passos executados pelos algoritmos, muitas vezes temos
a necessidade de armazenar temporariamente algumas informaes, que vo
ser utilizadas ao longo do processamento. Na programao, estes dados arma-
zenados temporariamente durante a execuo de um algoritmo so chamados
de variveis.
16
Imagine, por exemplo, que iremos criar um algoritmo para calcular o
ndice de massa corporal de uma pessoa, dizendo, no final, se ela est abaixo,
Variveis, Tipos de Dados e Constantes

acima do peso ou no peso ideal. Precisaramos saber o peso e a altura da


pessoa para fazer o clculo. Essas informaes, aps serem fornecidas pela
pessoa, teriam que ficar armazenadas temporariamente em algum lugar at a
realizao do clculo. , portanto, para isso que servem as variveis.
o mesmo que anotarmos um valor, um nome ou um telefone no
papel, de forma temporria, durante a execuo de alguma tarefa.
De forma simples, podemos dizer que uma varivel um local que
serve para armazenar valores e que identificado por meio de um nome
nico. Assim, sempre que quisermos atribuir (escrever) ou ler o valor arma-
zenado em uma varivel, precisaremos saber o seu nome.

Como o prprio nome diz, uma varivel pode


ter seu valor alterado ao longo da execuo do
programa.
Falando de forma um pouco mais tcnica, a memria do computador organizada em
pequenos compartimentos, cada um com um endereo. Pense nisso como uma rua, onde cada
casa tem um nmero que serve para identific-la. Pois bem, quando criamos uma varivel, esta-
mos dizendo ao computador que queremos utilizar um endereo de memria para armazenar
valores e informamos o nome que queremos utilizar para ter acesso a esse endereo. O nome
da varivel nada mais do que um identificador que serve para referenci-la.
Existem regras para as definies de variveis, as quais variam de uma linguagem de pro-
gramao para outra. Algumas destas regras, porm, so comuns maioria das linguagens e, por
isso, tambm so adotadas na representao da declarao de variveis em pseudocdigo.
Para declarar variveis no pseudocdigo, utilizaremos os seguintes padres:
Nomes de variveis podem conter apenas caracteres alfanumricos (alfabticos e
numricos) e o caractere underscore ( _ ). No se pode utilizar acentos, espaos, sinais
de pontuao ou outros smbolos.
Um nome de varivel no pode iniciar com nmeros.
Para nomear variveis, podem-se utilizar letras minsculas ou maisculas. O reco-
mendado, porm, utilizar letras minsculas, por ser a conveno mais utilizada na
maioria das linguagens de programao.
Quando a varivel for receber um nome composto (possuir mais de uma palavra),
utiliza-se o caractere underscore para separar as palavras. Outra opo, considerando a
utilizao de letras minsculas no nome da varivel, unir as palavras digitando em
maiscula a letra que far a ligao com a palavra anterior (ateno, a primeira letra da
primeira palavra continua minscula). Quando o nome da varivel possui mais de uma 17
palavra, dizemos que a varivel possui um identificador composto.
As variveis devem ser declaradas em bloco prprio, no incio do algoritmo ou na

Variveis, Tipos de Dados e Constantes


sub-rotina a que pertencem.
Exemplos de nomes vlidos Exemplos de nomes invlidos
nome_candidato nome candidato
endereco endereo
RG R.G.
mes_ferias ms_frias
dataNasc data-Nasc
fone1 1fone

Alm de respeitar as regras acima, quando for declarar variveis em um algoritmo procure
sempre utilizar nomes curtos e significativos. Exemplos:
Ao invs de utilizar temp1 e temp2, seria mais intuitivo altura e peso.
Ao invs de altura_maxima_permitida_veiculo, utilizar altura_max ou
alturaMaxima, que seriam boas opes.
Tipos de Dados
Quando declaramos uma varivel, precisamos indicar o tipo de informa-
o que desejamos armazenar nela. Existem diversos tipos de dados e muitos
deles so comuns na grande maioria das linguagens de programao. No
nosso estudo de lgica de programao, porm, utilizaremos apenas alguns
dos principais.
Os tipos de dados bsicos com os quais iremos trabalhar so:
Inteiro: permite armazenar nmeros inteiros, positivos ou
negativos.
Exemplos de informaes vlidas em uma varivel do tipo Inteiro
5
0
-2
1430

Real: permite armazenar nmeros inteiros ou fracionrios, positivos


ou negativos.
Exemplos de informaes vlidas em uma varivel do tipo Real
5
0
-2

18 1,5
-3,72
Variveis, Tipos de Dados e Constantes

Caractere: permite armazenar caracteres alfanumricos (ou seja:


letras, nmeros, espaos, sinais de pontuao e outros smbolos).
Este tipo tambm chamado de tipo Literal ou tipo String. Valores
do tipo caractere so sempre representados entre aspas ().
Exemplos de informaes vlidas em uma varivel do tipo
Caractere
Av. Brasil, 1500
5
%
O tipo Caractere aceita tudo! @#$%.

Lgico: permite armazenar valores lgicos, do tipo Verdadeiro ou


Falso, os quais representaremos respectivamente por V e F.
Exemplos de informaes vlidas em uma varivel do tipo Lgico
V
F
Declarao de Variveis
Para que uma varivel passe a existir e possa ser utilizada no contexto de um algoritmo,
necessrio que ela seja declarada. A declarao nada mais do que a definio de uma varivel,
aonde informamos o seu nome e o tipo de informao que ela dever ser capaz de armazenar.
Para declarar variveis no pseudocdigo, adotaremos o seguinte padro:
<nome da varivel> : <tipo de dado>;

A declarao dever ser feita no comeo do algoritmo, em um bloco nomeado Variveis,


antes do demarcador Incio.
Veja um exemplo:
{Exemplo de declarao de variveis I}
Algoritmo ExemploVariaveis
Variveis
nome : Caractere;
endereco : Caractere;
altura : Real;
peso : Real;
telefone : Caractere; {Declaramos como caractere para permitir que
o telefone seja digitado com formatao. Ex: (00)1234-1234,
e tambm que seja possvel informar ramal}
Incio
... 19
Fim

Variveis, Tipos de Dados e Constantes


Veja que, no exemplo acima, cada varivel foi declarada em uma nova linha. Tambm
possvel agrupar variveis do mesmo tipo em uma mesma linha, declarando-as todas juntas.
Veja o exemplo a seguir:
{Exemplo de declarao de variveis II}
Algoritmo ExemploVariaveisAgrupadas
Variveis
nome, endereco, telefone : Caractere;
altura, peso : Real;
Incio
...
Fim

Lembre-se de que uma vez que uma varivel tenha sido declarada, no possvel alterar
seu nome nem seu tipo, mas apenas o valor que ela guarda.
Nos fluxogramas e diagramas de Chapin, a declarao de variveis no costuma ser
representada.
Atribuio e Inicializao de
Variveis
Atribuio o ato de definir o valor de uma varivel. Tecnicamente, isto significa escre-
ver uma nova informao no espao de memria identificado pelo nome que demos varivel
no momento de sua declarao.
Para atribuir um novo valor a uma varivel, adotaremos o seguinte padro:
<nome da varivel> := <valor>;

Veja os exemplos:
Algoritmo ExemploAtribuicao
Variveis
ano : Inteiro;
nomeAluno : Caractere;
altura : Real;
Incio
ano := 2010; {atribui o valor inteiro 2010 varivel ano}
nomeAluno := Pedro da Silva; {atribui a sequncia de
caracteres Pedro da Silva varivel nomeAluno}
altura := 172,5; {atribui o valor real 172,5 varivel altura}
Fim
20
Variveis, Tipos de Dados e Constantes

Tambm fique atento ao fato de que a operao de atribuio apaga qualquer informao
existente na varivel, sobrepondo-a com o novo valor.
Por exemplo:
Algoritmo ExemploAtribuicao2
Variveis
x : Inteiro;
Incio
x := 1; {neste momento x vale 1}
x := 5; {neste momento x passou a valer 5}
Fim

Inicializar uma varivel significa atribuir-lhe um valor inicial, o que deve ser feito no
comeo do algoritmo, logo aps o demarcador Incio.
O ideal sempre inicializarmos todas as variveis, mesmo aquelas cujos valores ainda no
sabemos quais sero. Neste caso, inicializamos variveis dos tipos Inteiro e Real com zero (0),
variveis do tipo Caractere com (vazio) e variveis do tipo Lgico com F (falso).
Embora seja fortemente recomendada, a inicializao de variveis uma conveno,
considerada uma boa prtica, e no uma regra. Por isso, caso no realizemos a inicializao
de algumas variveis, elas sero inicializadas automaticamente com o valor default (padro), de
acordo com o tipo de dado a que pertencem. Estes valores so:

Tipo da Varivel Valor Default


Inteiro 0
Real 0
Caractere (vazio)
Lgico F (falso)

Vejamos um novo exemplo de algoritmo, representado em pseudocdigo, agora contem-


plando o uso de variveis:

{Calcula a quantidade de gasolina dado um valor em R$}


Algoritmo QuantidadeGasolina
Variveis
precoGasolina, valorDesejado, qtdeLitros : Real; {declarao}
Incio
precoGasolina := 2,48; {inicializao}
valorDesejado := 0; {inicializao}
qtdeLitros := 0; {inicializao}
21
Escreva (Informe o valor desejado pelo cliente:);{sada em
tela}
Leia(valorDesejado); {entrada via teclado}

Variveis, Tipos de Dados e Constantes


qtdeLitros := valorDesejado / precoGasolina; {realiza o clculo e
atribui o resultado na varivel qtdeLitros}
Escreva(A quantidade de litros para este valor :);
Escreva(quantidadeLitros);
Fim

O exemplo anterior ainda apresenta duas outras novidades, os comandos de leitura e


escrita que simulam a interao com o usurio:
Para simular entradas de teclado, utilizamos o comando Leia;
Para simular sadas na tela, utilizamos o comando Escreva.
Observe que os dois comandos utilizam parnteses para delimitar o contedo a que se
referem.
O algoritmo anterior, embora bastante simples, j poderia ser transformado em um pro-
grama de computador, pois simula todos os itens necessrios para cumprir o seu propsito, que
calcular quanto deve ser colocado de gasolina para atingir um determinado valor em Reais.
Veja como ficaria o Fluxograma do algoritmo QuantidadeGasolina:

Incio

precoGasolina := 2,48
valorDesejado := 0
qtdeLitros := 0
A quantidade de
litros para este
valor :
Informe o valor
desejado pelo
cliente:

<quantidadeLitros>

valorDesejado

Fim

qtdeLitros := valorDesejado / precoGasolina

Perceba que foram utilizadas duas novas figuras, representando a interao do sistema
com o usurio:
22
Variveis, Tipos de Dados e Constantes

Vdeo Entrada
Representa a sada de dados Representa a entrada de dados,
em vdeo via teclado

Alm disso, utilizamos um conector para representar a continuao do algoritmo em


outro ponto da pgina.

Constantes
As constantes tm basicamente a mesma funo das variveis, isto , armazenar valores
temporariamente, enquanto um algoritmo est sendo executado. Existe, porm, uma diferena
crucial entre elas: as constantes, uma vez declaradas, no podem ter seu valor modificado (e este
o motivo pelo qual elas se chamam constantes). Ou seja, as constantes s podem ser usadas
para armazenar valores que no se alteraro ao longo do algoritmo.
Assim como as variveis, as constantes tambm devem ser declaradas em bloco prprio,
no incio do algoritmo.
Com relao nomenclatura, valem as mesmas regras listadas anteriormente para a decla-
rao de variveis, porm com uma recomendao:
Procurar sempre declarar as constantes, utilizando letras maisculas, como forma de
diferenci-las das variveis de maneira mais fcil ao longo do algoritmo. Neste caso, a
separao de palavras dos nomes compostos feita por meio do caractere underscore. Esta no
uma regra e, sim, uma conveno utilizada por grande parte dos programadores.
Exemplos de nomes recomendados Exemplos de nomes no recomendados
FORCA_ACELERACAO forca_aceleracao
PI pi
OPERACAO_PADRAO operacaoPadrao

Exemplo de pseudocdigo, contendo declarao de constantes:

Algoritmo ExemploConstantes
Constantes
PI := 3,14; {constante do tipo Real}
MAX_GRAUS := 90; {constante do tipo Inteiro}
INSTITUICAO := Escola X; {constante do tipo Caractere}
RELATORIO_ATIVADO := F; {constante do tipo Lgico}
Variveis
...
Incio
...
Fim 23

Variveis, Tipos de Dados e Constantes


Do mesmo modo que as variveis, a declarao de constantes tambm no costuma ser
representada nos fluxogramas nem nos diagramas de Chapin.

Atividades
1) Crie um algoritmo para calcular a mdia de consumo de com-
bustvel de um veculo qualquer. O usurio dever informar:
quilometragem inicial, quilometragem final e a quantidade de
litros abastecida. Represente seu algoritmo utilizando pseudo-
cdigo e fluxograma.

2) Crie um algoritmo para calcular a velocidade mdia atingida


por um veculo durante uma viagem. Reflita sobre os dados
que sero necessrios solicitar ao usurio. Represente seu
algoritmo utilizando pseudocdigo e fluxograma.
031

Operadores e Expresses
Operador um elemento que indica a realizao de uma operao sobre componentes
de uma expresso, gerando consequentemente um resultado.
Os operadores esto presentes em qualquer tipo de expresso e so utilizados para realizar
clculos, comparaes ou definir critrios. Qualquer expresso, por menor que seja, sempre
possuir ao menos um operador.
Conforme formos avanando nos exemplos, veremos que possvel utilizar mais de um
tipo de operador em uma mesma expresso, e que isso bastante comum em expresses um
pouco mais complexas.
Existem quatro tipos de operadores, que sero detalhados a seguir.

24
Operadores Aritmticos
Os operadores aritmticos so aqueles utilizados nos clculos matemticos. Desde os
anos iniciais na escola, ns j aprendemos a utilizar estes operadores.
Operadores e Expresses

Na lgica de programao, estes operadores so utilizados apenas com variveis numri-


cas (dos tipos Inteiro e Real), gerando tambm uma sada numrica.
A tabela abaixo lista os operadores aritmticos por ordem de precedncia.
Precedncia Operador Descrio
1 ^ Potenciao
2 * Multiplicao
2 / Diviso
3 + Adio
3 - Subtrao

A ordem de precedncia nada mais do que uma preferncia de execuo. Por exemplo,
na expresso existente na figura abaixo, a multiplicao realizada antes da subtrao, devido
ordem de precedncia dos operadores:

7 2 * 3
1-

2-
Vamos aproveitar para relembrar um item estudado por voc anteriormente, nas discipli-
nas de matemtica: o uso dos parnteses.
Os parnteses servem para definir a ordem em que uma expresso deve ser resolvida,
sendo que a resoluo dela se d sempre do parntese mais interno para o mais externo, inde-
pendente de sua posio na expresso. Por exemplo:

3 + ((1 - 4) * 5)
1-

2-

3-

A ordem de precedncia dos operadores passa a valer no momento em que existem dois
ou mais operadores em um mesmo nvel de parnteses (ou fora deles). Exemplo:

7 + 1 5 * 3
2- 1-

3-

No exemplo anterior, todos os operadores esto no mesmo nvel, pois no h parnteses.


O que ocorre, ento, a resoluo da expresso na sequncia definida pela ordem de prece-
dncia dos operadores. Contudo, mesmo que desejemos que a expresso seja resolvida nessa
sequncia, o melhor empregar o uso dos parnteses para enfatizar a sequncia de resoluo 25
para quem for ler a expresso, conforme o exemplo a seguir:

Operadores e Expresses
7 + 1 (5 * 3)
2- 1-

3-

Para melhorar a clareza das expresses, torna-se interessante adotarmos a seguinte regra:
empregar parnteses quando for utilizar operadores de prioridades diferentes. Contudo, cabe a
quem est construindo a expresso utilizar o bom senso para manter a legibilidade da mesma.
Vejamos um exemplo mais prtico:

qtdeCarne = ((consumoMedioM * qtdeM) + (consumoMedioH * qtdeH)) * 1,2


1- 2-

3-

4-
Os clculos realizados na expresso anterior poderiam ser decompostos em vrias linhas,
como no algoritmo abaixo:

{Calcula a quantidade de carne necessria para um churrasco}


Algoritmo CalculaCarneChurrasco
Constantes
MARGEM_SEGURANCA := 1,2; {para garantir que no faltar carne!}
Variveis
consumoMedioM, consumoMedioH : Real;
qtdeM, qtdeH : Inteiro;
consumoTotalM, consumoTotalH, total : Real;
Incio
Escreva(CLCULO DE CARNE PARA CHURRASCO);
Escreva(Digite o consumo mdio feminino:);
Leia(consumoMedioM);
Escreva(Digite a quantidade de mulheres:);
Leia(qtdeM);
Escreva(Digite o consumo mdio masculino:);
Leia(consumoMedioH)
Escreva(Digite a quantidade de homens:);
Leia(qtdeH);

consumoTotalM := consumoMedioM * qtdeM;
consumoTotalH := consumoMedioH * qtdeH;
total := (consumoTotalM + consumoTotalH) * MARGEM_SEGURANCA;
26
Escreva(A quantidade total de carne para o churrasco :);
Escreva(total);
Operadores e Expresses

Fim

Em muitos casos, porm, iremos preferir realizar todos os clculos em uma nica expresso,
para deixar o algoritmo mais compacto. Veja:

{Calcula a quantidade de carne necessria para um churrasco}


Algoritmo CalculaCarneChurrasco
Constantes
MARGEM_SEGURANCA := 1,2; {para garantir que no faltar carne!}
Variveis
consumoMedioM, consumoMedioH, qtdeCarne : Real;
qtdeM, qtdeH : Inteiro;
Incio
Escreva(CLCULO DE CARNE PARA CHURRASCO);
Escreva(Digite o consumo mdio feminino:);
Leia(consumoMedioM);
Escreva(Digite a quantidade de mulheres:);
Leia(qtdeM);
Escreva(Digite o consumo mdio masculino:);
Leia(consumoMedioH)
Escreva(Digite a quantidade de homens:);
Leia(qtdeH);

qtdeCarne := ((consumoMedioM * qtdeM) + (consumoMedioH * qtdeH))
* MARGEM_SEGURANCA;

Escreva(A quantidade total de carne para o churrasco :);


Escreva(qtdeCarne);
Fim

Operadores Relacionais
Os operadores relacionais permitem realizar comparaes entre valores, gerando
como resultado um valor lgico (Verdadeiro ou Falso). Voc deve se lembrar desses operadores
das suas aulas de matemtica, porm, no contexto da lgica de programao, estes operadores
permitem comparar quaisquer tipos de dados, desde que os valores a serem comparados sejam
do mesmo tipo.
A tabela abaixo lista os operadores relacionais:
27
Operador Descrio
= Igual
<>

Operadores e Expresses
Diferente
< Menor
<= Menor ou Igual
> Maior
>= Maior ou Igual

Veja alguns exemplos:


A >= B

(3 + 7) < (2 * 4)

4 >= ((3 - 1) * 2)

(consumoMedio * qtdePessoas) > qtdeDisponivel


Perceba que a maioria dos exemplos anteriores utiliza os operadores relacionais em con-
junto com operadores aritmticos.
Exemplo de uso em algoritmo:

Algoritmo ExemploOperadoresRelacionais
Variveis
pedidoMinimo, qtdePedido, qtdeEstoque : Inteiro;
respeitaMinimo, podeAtender : Lgico;
Incio
pedidoMinimo := 10;
qtdePedido := 20;
qtdeEstoque := 18;

respeitaMinimo := qtdePedido >= pedidoMinimo;


{aps a linha acima, a varivel respeitaMinimo ter o valor lgico
VERDADEIRO (V), indicando que o pedido
respeita a quantidade mnima exigida}

podeAtender = qtdePedido < qtdeEstoque;


{aps a linha acima, a varivel podeAtender ter o
valor lgico FALSO (F), indicando que no possvel
atender o pedido, pois no h estoque suficiente}
Fim

28

Como o objetivo desta categoria de operadores estabelecer comparaes, no existe uma


Operadores e Expresses

ordem de precedncia estabelecida, pois estas comparaes so realizadas sempre entre dois
valores.

Operadores Lgicos
Assim como os relacionais, estes operadores tambm geram valores lgicos. Porm, ao
contrrio dos operadores relacionais que podem comparar qualquer tipo de dado, os operado-
res lgicos trabalham apenas com valores lgicos.
Os operadores lgicos so:
Precedncia Operador Operao
1 .NO. Negao
2 .E. Conjuno
3 .OU. Disjuno

O uso destes operadores geram as chamadas operaes lgicas, nomeadas na tabela


acima.
Negao
Negao uma operao lgica que gera como sada um valor inverso ao valor lgico de
entrada. O operador NO tambm usualmente representado por ! ou NOT.
Exemplos:

.NO. varA

.NO. (5 > 3)

O operador NO sempre deve ser inserido esquerda da varivel ou expresso cujo valor
deve modificar.
Exemplo em algoritmo:

Algoritmo ExemploNao
Variveis
X, Y : Inteiro;
L, M : Lgico;
Incio
X := 1;
Y := 2;
29
L := (X > Y); {A varivel L receber o valor F (falso)}
M := .NO.(X > Y); {A varivel M receber o valor V(verdadeiro)}

Operadores e Expresses
Fim

Existe uma tcnica chamada de tabela verdade ou tabela de verificao, que serve
para ilustrar o resultado de associaes lgicas. A tabela verdade, do operador NO, bastante
simples:
A .NO. A
V F
F V

Conjuno
A conjuno uma operao lgica que relaciona dois valores lgicos por meio do ope-
rador E. Este operador tambm representado por && e AND.
A operao de conjuno relaciona dois valores lgicos, gerando um valor lgico de sada,
que ser verdadeiro somente se os dois valores de entrada forem verdadeiros.
Por exemplo:
varA .E. varB

(altura <= alturaMax) .E. (largura <= larguraMax)

Repare que o segundo exemplo utiliza tambm operadores relacionais.


Agora em um algoritmo:
Algoritmo ExemploE
Variveis
X, Y, Z : Inteiro;
L, M, N, O, P : Lgico;
Incio
X := 1;
Y := 2;
Z := 3;

L := (X > Y); {A varivel L receber o valor F (falso)}


M := (Z > Y); {A varivel M receber o valor V (verdadeiro)}
N := V; {A varivel N receber o valor V (verdadeiro)}

O := L .E. M {A varivel O receber o valor F (falso)


porque L falso}
30 P := M .E. N {A varivel O receber o valor V (verdadeiro)
porque M e N so verdadeiros}
Fim
Operadores e Expresses

Para aprofundar o entendimento destas associaes, analise a tabela verdade do operador E:


A B A .E. B
F F F
V F F
F V F
V V V

Disjuno
A disjuno uma operao lgica que relaciona dois valores lgicos por meio do ope-
rador OU, tambm representado por || e OR.
Esta operao relaciona dois valores lgicos, gerando um valor lgico de sada que ser
verdadeiro se pelo menos um dos valores de entrada for verdadeiro.
Exemplos:
varA .OU. varB

(altura > alturaMax) .OU. (largura > larguraMax)

Vejamos o uso em um algoritmo:


Algoritmo ExemploOU
Variveis
X, Y, Z : Inteiro;
L, M, N, O, P : Lgico;
Incio
X := 1;
Y := 2;
Z := 3;

L := (X > Y); {A varivel L receber o valor F (falso)}


M := (Z > Y); {A varivel M receber o valor V (verdadeiro)}
N := F; {A varivel N receber o valor F (falso)}

O := L .OU. M {A varivel O receber o valor V (verdadeiro)


porque M verdadeiro}
P := L .OU. N {A varivel O receber o valor F (falso)
porque L e N so falsos} 31
Fim

Operadores e Expresses
Confira a tabela verdade do operador OU:
A B A .OU. B
F F F
V F V
F V V
V V V

Disjuno Exclusiva
Existe um outro operador lgico, representado por XOU ou XOR, que d origem a
uma operao chamada disjuno exclusiva. Este operador menos importante para nossos
estudos sobre lgica de programao e no ser abordado neste momento.
Operador Literal
O operador literal tem o objetivo de unir duas informaes do tipo texto. Este processo
chamado de concatenao.
Operador Descrio
+ Concatenao

Exemplos:
Conca + tenao

Prezado(a) + nomeCliente

Algoritmo de exemplo:
Algoritmo ExemploConcat
Variveis
nome, sobrenome, nomeCompleto : Caractere;
Incio
Escreva(Digite seu nome:);
Leia(nome);
32 Escreva(Digite seu sobrenome:);
Leia(sobrenome);
Operadores e Expresses

nomeCompleto := nome + + sobrenome; {concatena o nome,


um espao e o sobrenome, atribuindo o resultado
varivel nomeCompleto }

Escreva(O primeiro nome : );


Escreva(nome);

Escreva(O nome completo : + nomeCompleto); {aqui estamos


concatenando diretamente no comando de sada}
Fim

Voc j deve ter percebido que o smbolo que representa o operador de concatenao o
mesmo que representa o operador aritmtico de soma. O que ir definir se ser realizada uma
soma ou uma concatenao o tipo de informao que estiver sendo empregada em conjunto
com o operador. Veja:
{Exemplos de concatenao e diferenas com relao adio}
Algoritmo TestaConcatenar
Variveis
a, b : Caractere;
c, d : Inteiro;
Incio
a := 1;
b := 2;
c := 3;
d := 4;

Escreva(a + b); {o resultado ser o valor caractere 12}


Escreva(c + d); {o resultado ser o valor inteiro 7}
Escreva(a + c); {o resultado ser o valor caractere 13}
Escreva(c + a); {est incorreto, geraria um erro}
Fim

Na grande maioria das linguagens de programao, a concatenao converte o valor


direita do operador + para o tipo Caractere. Por isso, se tentarmos concatenar um texto com
um valor numrico e colocarmos o valor numrico direita, estamos indicando que o valor
deve ser convertido para o tipo Caractere e deve ser realizada uma concatenao com o valor
esquerda. Porm, se o valor numrico estiver esquerda do operador e o texto direita, ocor-
rer um erro, pois estaremos indicando que queremos fazer uma soma, o que no pode ser feito
33
com uma informao do tipo Caractere. Ou seja:

{Ilustra a tentativa de concatenar Caractere com Inteiro}

Operadores e Expresses
Algoritmo DetalheConcat
Variveis
idadeAluno : Inteiro;
Incio
idadeAluno := 18;
Imprima(A idade do aluno + idadeAluno); {est correto}
Imprima(idadeAluno + a idade do aluno.); {est incorreto}
Fim

No exemplo acima, existe um novo comando: Imprima. Em pseudocdigo, este


comando serve para representar o envio de informaes para uma impressora.
A representao de impresso nos fluxogramas tambm feita por uma figura especfica,
que est representada na tabela a seguir. Alm disso, tambm possvel inserir comentrios
nos fluxogramas, mas h um detalhe importante: sempre procurar apontar o comentrio para o
passo do algoritmo a que ele se refere.
Veja as duas novas figuras:

Comentrio
Impressora
Permite a insero de comentrios
Representa a sada de dados em
uma impressora

Confira um exemplo de uso no fluxograma abaixo:

Incio

idadeAluno := 18

A idade do aluno
<idadeAluno>

Isto est incorreto.


Geraria um erro se
<idadeAluno> a estivesse sendo
idade do aluno. executado por um
computador.

Fim
34
Operadores e Expresses

Teste de Mesa
O teste de mesa, tambm conhecido como teste do chins ou chinesinho, um pro-
cesso de teste manual que permite verificar a eficincia dos algoritmos.
Os testes so realizados por meio de simulaes. Nelas, so atribudos valores de entrada
fictcios, sendo possvel acompanhar o valor das variveis do sistema ao longo da execuo do
algoritmo, o que permite encontrar erros e identificar suas causas.

Funcionamento
Veja um passo a passo de como este processo funciona:
1. Numere cada uma das linhas do algoritmo que deseja testar (somente entre os demar-
cadores Incio e Fim);
2. Crie uma tabela contendo:
a. Uma linha para cada passo do algoritmo;
b. Uma coluna para cada varivel declarada;
c. Uma coluna para representar sadas em tela;
d. Uma coluna para representar sadas em impressora;
3. Percorra o algoritmo, linha a linha, anotando todas as mudanas. A cada linha do algo-
ritmo percorrida, deve-se preencher uma nova linha no teste de mesa, com os valores
de todas as variveis e as sadas realizadas.
Vamos a um exemplo prtico. O algoritmo com linhas numeradas:

Algoritmo IlustraTesteDeMesa
Variveis
idade, idadeMin : Inteiro;
idadeOK, autorizadoPais, liberado : Lgico;
Incio
01 idadeMin := 18;
02 Leia(idade); {para teste vamos simular que foi informado 16}
03 Leia(autorizadoPais); {para teste, V}
04 idadeOK := idade >= idadeMin;
05 liberado := idadeOK .OU. autorizadoPais;
06 Escreva(Resultado: + liberado);
Fim

A tabela com os dados da execuo:

N 35
idade idadeMin autorizadoPais idadeOK liberado Tela Impressora
Linha
1 18

Operadores e Expresses
2 16 18
3 16 18 V
4 16 18 V F
5 16 18 V F V
Resultado:
6 16 18 V F V
V

As constantes declaradas no algoritmo no precisam ser representadas na tabela, j que


seus valores no se alteram ao longo do tempo.
Por meio do teste de mesa, possvel realizar as mais variadas simulaes, porm, quando
o algoritmo grande, o processo acaba tornando-se um pouco trabalhoso. Nesses casos, pode-se
optar por testar apenas a parte do algoritmo mais propensa a erros.
Atividades
1) Crie um algoritmo que solicite o nome e a idade do usurio e,
em seguida, imprima estas informaes de forma concatenada
em uma frase de boas vindas. Represente seu algoritmo em
pseudocdigo e fluxograma.

2) Considerando os operadores relacionais, crie um algoritmo em


pseudocdigo que leia dois nmeros e escreva na tela se o
primeiro maior do que o segundo. A sada dever ser do tipo
V ou F.

3) Crie um algoritmo em pseudocdigo que leia o valor de X e


escreva na tela o valor de X2.

4) Crie um algoritmo em pseudocdigo para calcular a taxa de


servio do garom, a partir da entrada do valor da conta. A taxa
de servio fixa em 10%. O sistema dever escrever na tela o
valor da taxa de servio e depois o valor total a ser pago.
Em seguida, voc dever fazer um teste de mesa para o
algoritmo.

5) Faa o teste de mesa para o seguinte algoritmo:


36
Algoritmo IlustraTesteDeMesa
Variveis
Operadores e Expresses

valA, valB, valC : Inteiro;


X, Y, Z : Lgico;
Incio
01 valA := 5;
02 Leia(valB); {simular o valor 7}
03 valC := valA + (valB - valA);
04 Escreva(valC);
05 X := valC > valA;
06 Y := valA >= valB;
07 Escreva(valB <> valC);
08 Imprima(X .OU. Y);
09 Z := X .E. .NO.Y;
10 Escreva(Z);
Fim
10
4

Estruturas de Controle
Seleo
At agora, nossos algoritmos eram totalmente sequenciais, ou seja, todos os passos eram
executados em sequncia, sem nenhum tipo de modificao no fluxo do programa. Na prtica,
este tipo de algoritmo no muito til, porque mesmo os problemas minimamente complexos
j exigem algum tipo de controle sobre os passos que sero executados.
A partir deste ponto, veremos que possvel adicionar estruturas de modificao de fluxo
nos algoritmos, as quais so denominadas estruturas de controle.
A primeira estrutura de controle que iremos conhecer a estrutura de seleo, que per-
mite selecionar os passos que devem ser executados pelo algoritmo em um determinado ponto.
37
Esta estrutura tambm chamada de estrutura de deciso ou estrutura condicional.
A seleo dos passos, que devem ou no ser executados, feita a partir do resultado de uma

Estruturas de Controle
expresso lgica ou relacional. Na prtica, isto representa dotar o algoritmo de um mecanismo
que lhe permita tomar decises em tempo real, buscando atender a critrios preestabelecidos.
Ento, sempre que precisarmos tomar uma deciso em algum ponto do algoritmo, iremos
utilizar uma estrutura de seleo.

Estrutura de Seleo Simples


A estrutura de seleo simples permite definir um bloco de instrues que sero exe-
cutadas apenas se forem atendidos os critrios definidos. Esta estrutura tambm conhecida
como desvio condicional simples.
No pseudocdigo, a estrutura de seleo simples representada pelo comando Se, que
utiliza a seguinte estrutura:
Se(<condio>) Ento
...
Fim_Se
Todos os comandos existentes entre Ento e Fim_Se s sero executados se a condio
for atendida. Por exemplo:

{Exemplo de uso do comando Se}


Algoritmo ExemploSe
Variveis
idadeAluno : Inteiro;
Incio
01 Escreva(Digite a idade do aluno:);
02 Leia(idadeAluno);

03 Se(idadeAluno < 18) Ento


04 Escreva(O aluno menor de idade.);
05 Fim_Se

06 Escreva(A idade do aluno : + idadeAluno);


Fim

No algoritmo acima, a frase O aluno menor de idade. s ser impressa na tela se o


resultado da expresso (idadeAluno < 18) for verdadeiro.
Para verificar o funcionamento do algoritmo, vamos realizar dois testes de mesa, simu-
lando diferentes valores de entrada.
Primeiro teste: simulando que a idade digitada seja 19:
38

N Linha idadeAluno Tela


1 Digite a idade do aluno:
Estruturas de Controle

2 19
3 19
5 19
6 A idade do aluno : 19

Segundo teste: simulando que a idade digitada seja 15:

N Linha idadeAluno Tela


1 Digite a idade do aluno:
2 15
3 15
4 15 O aluno menor de idade.
5 15
6 A idade do aluno : 15
Nos fluxogramas, a representao de estruturas de seleo feita por meio das seguintes
figuras:

Deciso Conector
Representa uma tomada de Simboliza a unio de fluxos de
deciso execuo

O losango utilizado para representar decises. Possui um ou mais fluxos de entrada e


sempre dois fluxos de sada (uma vez que a expresso analisada resultar sempre em verdadeiro
ou falso).
O conector, j visto anteriormente com a funo de representar a continuao do algo-
ritmo em outro ponto da pgina, tambm utilizado nas estruturas de seleo para unir as setas
indicativas de fluxo aps a passagem pelo bloco condicional.
Veja ambas as figuras em uso, no exemplo abaixo:

Incio

D igite a idade
do aluno:

39
idadeA luno

Estruturas de Controle
N
idadeA luno < 18

O aluno
m enor de idade.

A idade do
aluno :
<idadeA luno>

F im
O diagrama de Chapin tambm possui uma representao especfica
para a estrutura de seleo. Veja:
Incio
Escreva Digite a idade do aluno:
Leia idadeAluno
idadeAluno < 18

N S
- Escreva O aluno menor de
idade.
Escreva A idade do aluno : idadeAluno
Fim

Observe que o bloco referente ao teste condicional est dividido em


trs partes: uma contm o teste a ser realizado e as outras duas representam
os possveis fluxos.
Logo aps o teste, h uma diviso em duas colunas, cada uma repre-
sentando um fluxo de execuo. Quando o trecho do algoritmo relacionado
estrutura de seleo acaba, o fluxo volta a ser representado em apenas uma
coluna.

Estrutura de Seleo Composta


40
A estrutura de seleo composta permite definir dois blocos de ins-
trues, sendo que um deles ser executado e o outro no, de acordo com o
Estruturas de Controle

atendimento ou no dos critrios definidos. Esta estrutura tambm conhe-


cida como desvio condicional composto.
No pseudocdigo, a estrutura de seleo composta representada
pelo comando Se...Seno, que utiliza a seguinte estrutura:

Se(<condio>) Ento
...
Seno
...
Fim_Se

Todos os comandos existentes entre Ento e Seno s sero executa-


dos se a condio for atendida. E todos os comandos existentes entre Seno e
Fim_Se s sero executados se a condio no for atendida.
Exemplo de uso:
{Exemplo de uso do comando Se...Seno}
Algoritmo ExemploSeSenao
Variveis
nota1, nota2, media : Real;
resultado : Caractere;
Incio
01 Escreva(Digite a primeira nota:);
02 Leia(nota1);
03 Escreva(Digite a segunda nota:);
04 Leia(nota2);
05 media := (nota1 + nota2) / 2;

06 Se(media >= 7) Ento


07 resultado := aprovado ;
08 Seno
09 resultado := no aprovado;
10 Fim_Se

11 Escreva(Situao do aluno: + resultado);


Fim

Nos fluxogramas, a representao da estrutura de seleo composta feita com as mesmas


figuras que conhecemos anteriormente. Veja o exemplo:

Incio

41
Digite a primeira
nota:

Estruturas de Controle
nota1

Digite a
segunda nota:

nota2

media := (nota1 + nota2) / 2

N S
media >= 7

resultado := no aprovado resultado := aprovado

Situao do
aluno:
<resultado>

Fim
No diagrama de Chapin, a estrutura tambm a mesma que j conhecemos, porm com
as colunas dos dois fluxos contendo comandos. Veja:
Incio
Escreva Digite a primeira nota:
Leia nota1
Escreva Digite a segunda nota:
Leia nota2
media := (nota1 + nota2) / 2
media >= 7

N S
resultado := reprovado resultado := aprovado
Escreva Situao do aluno: resultado
Fim

Estruturas de Seleo Aninhadas


Muitas vezes, dentro de um fluxo condicional, ser necessrio tomar uma nova deciso.
Ou pode ser que tenhamos mais de duas opes de fluxo de execuo. Em ambos os casos,
podemos utilizar estruturas de seleo aninhadas, que nada mais so do que uma estrutura
de seleo dentro de outra. Veja um exemplo:
{Exemplo de uso de Se aninhado}
Algoritmo ExemploSeAninhado
Variveis
42 nota1, nota2, media : Real;
nome, resultado : Caractere;
Incio
Estruturas de Controle

01 Escreva(Digite o nome do aluno:);


02 Leia(nome);
03 Escreva(Digite a primeira nota:);
04 Leia(nota1);
05 Escreva(Digite a segunda nota:);
06 Leia(nota2);
07 media := (nota1 + nota2) / 2;

08 Se(media >= 7) Ento


09 resultado := aprovado ;
10 Seno
11 Se(media >= 4)Ento
12 resultado := em exame;
13 Seno
14 resultado := reprovado;
15 Fim_Se
16 Fim_Se
17 Escreva(O aluno + nome + est + resultado);
Fim
Perceba que, no exemplo anterior, cada novo nvel de instrues recebe um avano na
identao, a fim de facilitar a leitura e o entendimento do algoritmo.
Veja, a seguir, um exemplo de estrutura de seleo aninhada em um fluxograma:

Incio

Digite o nome
do aluno:

nome

Digite a primeira
nota:

nota1

Digite a
segunda nota:

nota2

43
media := (nota1 + nota2) / 2

Estruturas de Controle
N S
media >= 7

S resultado := aprovado
media >= 4

resultado := em exame
N

resultado := reprovado

Situao do
aluno:
<resultado>

Fim
No diagrama de Chapin, a representao de estruturas aninhadas ocupa bastante espao,
o que dificulta sua adoo para algoritmos maiores. Confira:
Incio
Escreva Digite o nome do aluno.
Leia nome
Escreva Digite a primeira nota:
Leia nota1
Escreva Digite a segunda nota:
Leia nota2
media := (nota1 + nota2) / 2
media >= 7

N S
media >= 4 resultado := aprovado
N S
resultado:= resultado:= em
reprovado exame
Escreva Situao do aluno: resultado
Fim

No h um limite para o nmero de estruturas que podem ser aninhadas em um algoritmo,


mas deve-se utilizar o bom senso a fim de se evitar algoritmos excessivamente longos e complexos.
Pode-se dizer que, geralmente, quando as estruturas de seleo de um algoritmo atingem
muitos nveis de aninhamento, o algoritmo no est utilizando a melhor opo possvel de imple-
mentao. Em outras palavras, existe uma maneira mais eficiente de realizar a mesma tarefa.
44

Repetio
Estruturas de Controle

O segundo tipo de estrutura de controle que iremos aprender a estrutura de repe-


tio, que permite executar um ou mais passos do algoritmo repetidas vezes. Esta estrutura
tambm chamada de estrutura de iterao ou estrutura de looping.
Em alguns casos, ns sabemos com antecedncia quantas vezes ser preciso executar um bloco
de comandos, mas em outros no. As trs estruturas de repetio que iremos conhecer podem ser
utilizadas nas mais variadas situaes, sendo algumas mais propcias para determinados casos.

Repetio com Pr-Teste


A repetio com Pr-Teste uma estrutura de looping que repete um bloco de coman-
dos enquanto a expresso avaliada for verdadeira.
No pseudocdigo, este tipo de repetio representado pelo comando Enquanto, que
utiliza a seguinte estrutura:

Enquanto(<condio>) Faa
...
Fim_Enquanto
Todos os comandos existentes entre Faa e Fim_Enquanto sero executados repetida-
mente, at que a condio deixe de ser atendida. Por exemplo:

{Exemplo de Repetio com Pr-Teste}


Algoritmo ExemploEnquanto
Variveis
contador : Inteiro;
Incio
01 contador := 1;
02 Enquanto(contador <= 5) Faa
03 Escreva(Ol. Neste momento o contador vale + contador);
04 contador := contador + 1;
05 Fim_Enquanto
Fim

No exemplo acima, adicionamos na linha 2 o comando Enquanto, associado expresso


(contador <= 5), o que significa que enquanto o contador no for maior do que 5, o bloco
de comandos ser repetido. Na linha 4, modificamos o valor da varivel contador em uma
operao chamada de incremento, que consiste em atribuir varivel um novo valor baseado
no atual, porm acrescido de 1.
Veja como ficaria o teste de mesa para este algoritmo:
N Linha contador Tela
1 1
45
2 1
3 1 Ol. Neste momento o contador vale 1

Estruturas de Controle
4 2
2 2
3 2 Ol. Neste momento o contador vale 2
4 3
2 3
3 3 Ol. Neste momento o contador vale 3
4 4
2 4
3 4 Ol. Neste momento o contador vale 4
4 5
2 5
3 5 Ol. Neste momento o contador vale 5
4 6
2 6
5 6
A representao de repeties do tipo Pr-Teste, em fluxogramas, realizada por meio de
figuras j conhecidas por ns. Vejamos:

Incio

contador := 1

contador <= 5

Ol . Neste
momento o N
contador vale
<contador>

contador := contador + 1

Fim

Na repetio com Pr-Teste, muitas vezes no temos como saber quantas vezes o loop ser
executado. O nmero de iteraes pode ser zero ou inmeras. O motivo que a expresso que
determina a sada do loop pode depender de uma ao do usurio ou, ento, de algum outro
fator que s ser definido ao longo do processamento.
A partir deste ponto, no iremos mais utilizar diagramas de Chapin nos exerccios e exem-
plos. Vamos nos concentrar no pseudocdigo e no fluxograma que so, nesta ordem, as formas
de representao mais utilizadas.
46
Vamos analisar outro exemplo, agora utilizando repetio com Pr-Teste e Seleo em um
mesmo algoritmo:
Estruturas de Controle

{Exemplo de Repetio Pr-Teste e Seleo}


Algoritmo ExemploEnquanto2
Variveis
contador : Inteiro;
nome : caractere;
Incio
01 Escreva(Digite seu nome:);
02 Leia(nome);
03 contador := 1;
04 Enquanto(contador <= 10) Faa

05 SE(contador <= 5) Ento


06 Escreva(nome);
07 Seno
08 Escreva([ + nome + ]);
09 Fim_se

10 contador := contador + 1;
11 Fim_Enquanto
Fim
No exemplo anterior, o algoritmo pergunta um nome e o escreve 10 vezes na tela, porm,
nas ltimas 5 vezes, o nome escrito entre colchetes.
O fluxograma deste algoritmo ficaria da seguinte forma:

Incio

Digite seu
nome:

nome

contador := 1

contador < 10

contador > 5
N S
N

[ <nome> ] <nome>
47

Estruturas de Controle
contador := contador + 1

Fim

Repetio com Ps-Teste


A repetio com Ps-Teste similar repetio com Pr-Teste, porm com duas dife-
renas cruciais:
1. Na repetio com Ps-Teste, o teste que define a execuo ou no do bloco de coman-
dos realizado ao final do bloco. A consequncia disso que o bloco de instrues
executado ao menos uma vez.
2. Ao contrrio da repetio com Pr-Teste, que executa o bloco de comandos enquanto
o resultado do teste for verdadeiro, a repetio com Ps-Teste executa o bloco de
comandos enquanto o resultado do teste for falso. Ou seja, a repetio com Ps-Teste
executa at que o resultado do teste se torne verdadeiro.
No pseudocdigo, a repetio com Ps-Teste representada pelo comando
Repita...At_Que, utilizando a seguinte estrutura:

Repita
...
At_Que(<condio>)

Todos os comandos existentes entre Repita e At_Que sero executados repetidamente,


at que a condio seja atendida. Por exemplo:

{Exemplo de Repetio com Ps-Teste}


Algoritmo ExemploRepita
Variveis
contador : Inteiro;
Incio
01 contador := 1;
02 Repita
03 Escreva(Ol. Neste momento o contador vale + contador);
04 contador := contador + 1;
48
05 At_Que(contador > 5)
Fim
Estruturas de Controle

O algoritmo acima possui a mesma funcionalidade do exemplo apresentado para a repe-


tio com Pr-Teste. Aqui, ele foi reescrito para passar a utilizar a repetio do tipo Ps-Teste.
Observe que as nicas mudanas aconteceram na estrutura de repetio. Para conseguirmos o
mesmo resultado, foi necessrio modificar o teste que determina a sada do fluxo. O teste era
contador <= 5, passou a ser contador > 5.
Na repetio com Ps-Teste, em muitos casos, tambm no possvel saber quantas vezes
o loop ser executado, mas sabemos que ser ao menos uma vez. O nmero de iteraes pode ser
de uma ou de inmeras, porque, assim como na repetio com Pr-Teste, a expresso que deter-
mina a sada do loop pode depender de fatores definidos somente durante o processamento.
Para representar uma repetio do tipo Ps-Teste em um fluxograma, utilizam-se as mes-
mas figuras usadas no Pr-Teste, porm com o teste que define a sada do loop sendo realizado
ao final do bloco de instrues.
A representao do algoritmo anterior em fluxograma feita da seguinte forma:

Incio

contador := 1

Ol. Neste
momento o
contador vale
<contador>

contador := contador + 1

contador > 5

Fim

Vejamos um exemplo de repetio com Ps-Teste e seleo no mesmo algoritmo:


{Exemplo de Repetio Ps-Teste e Seleo}
Algoritmo ExemploRepita2
Variveis
nota1, nota2, media : Real;
resultado, continuar : Caractere; 49
Incio
01 Repita

Estruturas de Controle
02 Escreva(Digite a primeira nota:);
03 Leia(nota1);
04 Escreva(Digite a segunda nota:);
05 Leia(nota2);
06 media := (nota1 + nota2) / 2;
07 Se(media >= 7) Ento
08 resultado := aprovado;
09 Seno
10 Se(media >= 4)Ento
11 resultado := em exame;
12 Seno
13 resultado := reprovado;
14 Fim_Se
15 Fim_Se
16 Escreva(A mdia + media + [ + resultado + ]);
17 Escreva(Calcular outra mdia? (S/N));
18 Leia(continuar);
19 At_Que(continuar = N)
Fim
O fluxograma deste algoritmo ficaria da seguinte forma:

Incio

Digite a primeira
nota:

nota1

Digite a
segunda nota:

nota2

media := (nota1 + nota2) / 2

N S
media >= 7

S
media >= 4 resultado := aprovado

resultado := em exame
N

resultado := reprovado
50

A mdia
<media>
Estruturas de Controle

[ <resultado> ]

Calcular outra
mdia? (S/N)

continuar

N
Continuar = N

Fim
Repetio com Varivel de Controle
A repetio com varivel de controle baseada em uma varivel numrica, cujo valor
controlado dentro da prpria estrutura de repetio, com base nos critrios definidos na sua
criao.
Este tipo de repetio ideal quando sabemos com antecedncia quantas vezes o bloco de
instrues dever ser executado.
No pseudocdigo, a repetio com varivel de controle representada pelo comando
Para, utilizando a seguinte estrutura:
Para <varivel_controle> De <val_inicial> At <val_final> Passo
<incremento> Faa
...
Fim_Para

Todos os comandos existentes entre Para e Fim_Para sero executados repetidamente,


at que a varivel de controle atinja seu valor final. Por exemplo:
{Exemplo de Repetio com Varivel de Controle}
Algoritmo ExemploPara
Variveis
contador : Inteiro;
Incio
01 Para contador De 1 At 5 Passo 1 Faa
02 Escreva(Ol. Neste momento o contador vale + contador);
03 Fim_Para 51
Fim

Estruturas de Controle
No algoritmo acima, o comando da linha 2 ser executado 5 vezes, uma vez que foi defi-
nido na linha 1 que a varivel contador ter seu valor incrementado com 1 unidade de cada vez
(passo), iniciando em 1 e indo at 5.
Como se pode perceber, o gerenciamento deste tipo de repetio torna-se mais simples e
menos propenso a erros, uma vez que o controle do loop realizado em uma nica linha.
Para representar nos fluxogramas as repeties do tipo varivel de controle, utiliza-se a
seguinte figura:

Preparao
Representa a preparao de instrues para processamento em
estruturas de repetio do tipo Varivel de Controle.
Veja o algoritmo de exemplo, representado em fluxograma:

Incio

contador,
1, 5, 1

Ol. Neste
momento o
contador vale
<contador>

Fim

Vejamos um exemplo de repetio com varivel de controle e estrutura de seleo no


mesmo algoritmo:
{Exemplo de Repetio com Varivel de Controle e Seleo}
Algoritmo ExemploPara2
Variveis
contador : Inteiro;
52 tempMes, tempAnual : Real;
Incio
01 Escreva(Clculo de temperatura mdia anual.);
Estruturas de Controle

02 tempAnual := 0;
03 Para contador De 1 At 12 Passo 1 Faa
04 Escreva(Digite a temperatura mdia do ms + contador);
05 Leia(tempMes);

06 Se(tempMes > 35) Ento


07 Escreva(Que calor!);
08 Seno
09 Se(tempMes < 5)Ento
10 Escreva(Que frio!);
11 Fim_Se
12 Fim_Se

13 tempAnual := tempAnual + tempMes;


14 Fim_Para
15 tempAnual := tempAnual / 12;
16 Escreva(A temperatura mdia anual foi + tempAnual);
Fim
O fluxograma do exemplo ficaria assim:

Incio

Clculo da
temperatura
mdia anual.

tempAnual := 0

contador,
1, 12, 1

Digite a
temperatura
mdia do ms
<contador>

tempMes

N S
tempMes > 35

S
tempMes < 5 Que calor!

Que frio!

53

tempAnual := tempAnual + tempMes

Estruturas de Controle
tempAnual := tempAnual / 12

A temperatura
mdia anual foi
<tempAnual>

Fim

Consideraes Sobre os Tipos de Repetio


Pode-se dizer que possvel construir a maioria dos algoritmos utilizando qualquer um
dos trs tipos de repetio, sendo possvel substituir um tipo de repetio por outro, mantendo
a mesma funcionalidade, com poucas mudanas no algoritmo. A nica exceo que no se
pode utilizar uma repetio do tipo varivel de controle para os casos em que o nmero de
iteraes desconhecido.
Ateno: Quando se diz que o nmero de iteraes desconhe-
cido no se est fazendo referncia a um valor inserido pelo usurio,
pois quando o usurio informa um valor, ento o algoritmo sabe quan-
tas vezes ter que executar o bloco de comandos. No saber quantas
vezes o loop ser executado significa que o nmero de iteraes s
ser descoberto aps o incio da execuo do loop. Por exemplo, ima-
gine que estamos criando um algoritmo que leia arquivos gravados
no disco e escreva na tela o contedo lido. A cada linha lida de um
arquivo, o programa escreve uma linha na tela isso exige uma estru-
tura de looping. No sabemos, porm, quantas linhas de informao
existiro em cada arquivo a ser processado, pode ser 1 linha ou 500,
e esta informao s ser conhecida quando chegarmos ao fim do
arquivo. Este um caso tpico em que a repetio com varivel de
controle no pode ser utilizada.

Para os casos em que no sabemos quantas vezes iremos executar o bloco de comandos,
devem-se escrever loops com Pr e Ps-Teste. Porm, h um alerta: o algoritmo deve ser bem
testado para garantir que no ocorrer um erro de repetio infinita, o chamado loop infinito
(tambm conhecido como loop eterno), que uma condio em que a expresso responsvel
pela sada do loop nunca atendida.

Veja um exemplo de loop infinito em uma repetio do tipo Pr-Teste:

{Exemplo de loop infinito}


54 Algoritmo ExemploLoopInfinito
Variveis
contador : Inteiro;
Estruturas de Controle

Incio
01 contador := 1;
02 Enquanto(contador <= 5) Faa
03 Escreva(Ol. Neste momento o contador vale + contador);
04 Fim_Enquanto
Fim

Perceba que no exemplo acima o contador no incrementado, o que faz com que
seu valor seja sempre 1 e, consequentemente, que o bloco de comandos seja executado
infinitamente.
Pela sua estrutura, a repetio baseada em varivel de controle menos propensa a este
tipo de erro, pois as regras de execuo so definidas em uma nica linha e o controle das repe-
ties feito pela prpria estrutura.
Na prtica, a deciso sobre qual tipo de repetio utilizar vai depender em muito das pre-
ferncias pessoais de quem est criando o algoritmo. Conforme vamos avanando no contedo,
vai ficando evidente que extremamente difcil duas pessoas escreverem um algoritmo exa-
tamente igual, pois alm da lgica de resoluo de problemas ser diferente, existem mltiplas
opes de comandos para realizar uma mesma implementao.
Assim como acontece com as estruturas de seleo, as estruturas de repetio tambm
podem trabalhar de forma aninhada, ou seja, possvel inserir uma estrutura de repetio den-
tro de outra em um mesmo algoritmo.
Veja um exemplo:

{Exemplo de loop aninhado}


Algoritmo ExemploLoopAninhado
Variveis
numLido, resultado, contador : Inteiro;
Incio
01 Escreva(Digite um nmero para ver sua tabuada
ou 0 para sair:);
02 Leia(numLido);
03 Enquanto(numLido > 0) Faa

04 Para contador De 1 At 10 Passo 1 Faa


05 resultado := contador * numLido;
06 Escreva(contador + x + numLido + = + resultado);
07 Fim_Para

08 Escreva(Digite um nmero para ver sua tabuada


ou 0 para sair:);
09 Leia(numLido);
10 Fim_Enquanto
11 Escreva(Fim do programa.);
Fim
55

Estruturas de Controle
No exemplo acima, temos uma repetio com varivel de controle inserida dentro de
uma repetio com Pr-Teste. Note que quando uma estrutura inserida dentro de outra, ela
deve iniciar e encerrar dentro desta. No nosso exemplo, seria incorreto colocar o Fim_Para
depois do Fim_Enquanto, uma vez que o Para foi declarado dentro do Enquanto.
O correto que uma estrutura de repetio ou seleo sempre encerre no mesmo nvel
em que foi declarada. Veja:

Incorreto Correto

Estrutura 1 Estrutura 1

Estrutura 2 Estrutura 2
Representado em fluxograma, o algoritmo anterior ficaria da seguinte forma:

Incio

Digite um nmero
para ver sua tabuada
ou 0 para sair:

numLido

numLido > 0

contador,
1, 10, 1

resultado := contador * numLido

<contador> x <numLido>
= <resultado>

56
Estruturas de Controle

Digite um nmero
para ver sua tabuada
ou 0 para sair:

numLido

Fim

Na resoluo de problemas mais complexos, comum termos o


aninhamento (ou encadeamento) de estruturas de repetio e estrutu-
ras de seleo em um mesmo algoritmo.
Atividades
1) Crie um algoritmo que leia dois nmeros informados pelo usu-
rio e, em seguida, exiba na tela uma mensagem dizendo se o
maior deles o primeiro, o segundo, ou se so iguais.
Represente seu algoritmo em pseudocdigo, fluxograma e dia-
grama de Chapin. Tambm aplique o teste de mesa.

2) Crie um algoritmo que realize as seguintes atividades:


a. Solicite ao usurio trs valores inteiros.
b. Multiplique o menor valor lido pelo maior e some o resultado
com o valor do meio.
c. Imprima na tela o resultado.
Seu algoritmo dever ser representado em pseudocdigo e
fluxograma. necessrio realizar o teste de mesa para garantir
o funcionamento do algoritmo.

3) Desenvolva um algoritmo em pseudocdigo para aplicar um


percentual de desconto sobre o valor de uma compra infor-
mado pelo usurio. Os percentuais de desconto so:
57
15% para compras acima de R$ 500,00;
10% para compras entre R$ 200,00 e R$ 499,99;

Estruturas de Controle
5% para compras abaixo de R$ 200,00.
O algoritmo dever mandar para a impressora as seguintes
informaes:
Valor antes do desconto;
Valor do desconto;
Valor a ser pago.

4) Crie um algoritmo (pseudocdigo e fluxograma) que leia um


valor inteiro para X e escreva na tela X3. O algoritmo deve con-
tinuar pedindo o valor de X at que o usurio informe 0 (zero),
ento o programa encerra.
O algoritmo deve ser criado utilizando a estrutura de repetio
com Pr-Teste.
5) Desenvolva um algoritmo (pseudocdigo e fluxograma) capaz
de apresentar na tela o fatorial de um nmero inteiro informado
pelo usurio.
O algoritmo deve ser criado utilizando a estrutura de repetio
com Pr-Teste.

6) Crie um algoritmo (pseudocdigo e fluxograma) que solicite


ao usurio um nome e um nmero inteiro, que representar a
quantidade de vezes que o nome informado dever ser escrito
na tela.
O algoritmo deve ser criado utilizando a estrutura de repetio
com Ps-Teste.

7) Construa um algoritmo (pseudocdigo e fluxograma) que seja


capaz de calcular o valor total de uma compra, somando o
preo de cada um dos produtos.
O algoritmo dever solicitar o preo de cada produto e ir
somando ao montante total, e deve entender que os produ-
tos acabaram quando o preo informado for 0 (zero), ento
mostrar o nmero de itens comprados e o total da compra,
encerrando a execuo.
Caso seja informado algum valor menor do que zero, o pro-
grama deve desconsider-lo e exibir uma mensagem de erro
58 solicitando que o valor correto do produto seja digitado.
O algoritmo deve ser criado utilizando a estrutura de repetio
Estruturas de Controle

com Ps-Teste.

8) Crie um algoritmo (pseudocdigo e fluxograma) que realize as


seguintes atividades:
a. Pergunte a quantidade de alunos da turma.
b. Solicite ao usurio o nome de cada um dos X alunos.
c. Envie cada nome lido para a impressora.
O algoritmo deve ser criado utilizando a estrutura de repetio
varivel de controle.

9) Desenvolva um algoritmo (pseudocdigo e fluxograma) que


solicite ao usurio a entrada de 5 valores inteiros e, a cada
valor lido, aplique a seguinte regra: se o nmero lido for maior
que 10, subtrai 5 e escreve o resultado na tela, se no soma 2
e manda o resultado para a impressora.
O algoritmo deve ser criado utilizando-se a estrutura de repeti-
o varivel de controle.
10
5

Estruturas de Dados
Homogneas
Vetores
Os vetores, tambm chamados de matrizes unidimensionais, so estruturas de dados
que permitem armazenar vrias informaes de um mesmo tipo de dado sob o mesmo rtulo.
Em outras palavras, um vetor composto por um conjunto de elementos do mesmo tipo, que
compartilham um nome comum. Cada elemento como uma varivel: pode receber atribuio
de valores, ser utilizado em clculos, etc.
Imagine que temos que armazenar as mdias de uma turma com 35 alunos. Com o que 59
vimos at agora, seria necessrio criarmos 35 variveis, uma para a mdia de cada aluno. Ao
invs disso, podemos criar um vetor e armazenar todas as notas nele.

Estruturas de Dados Homogneas


Do ponto de vista dos dados armazenados, um vetor como uma tabela com uma nica
linha e vrias colunas, assim:
Brasil Paraguai Argentina Uruguai Chile

Para entendermos melhor a estrutura de um vetor, vamos represent-lo da seguinte


forma:
ndice 1 2 3 4 5
Elemento Brasil Paraguai Argentina Uruguai Chile

O ndice nada mais do que uma forma de fazer referncia a cada um dos elementos do
vetor, ou seja, uma maneira de indicar a posio do elemento que estamos querendo utilizar
naquele momento. No vetor acima, o elemento da posio 1 guarda o valor Brasil, o da posio 2
guarda o valor Paraguai, e assim por diante.
O trabalho com vetores facilita a declarao e o gerenciamento dos dados, pois ao invs
de precisar declarar uma varivel para cada valor a ser armazenado, declara-se apenas o vetor
informando a quantidade de valores que ele ser capaz de armazenar.
Outra vantagem dos vetores que os algoritmos criados para atribuir e ler dados de veto-
res geralmente so mais compactos do que os que trabalham com variveis. Alm disso, tarefas
como ordenao e pesquisa de valores so atividades realizadas de forma mais eficiente por
meio de vetores.

Mas ateno! O vetor til quando precisamos manipular uma


lista de dados de mesmo significado. Vetores no devem ser usados
para armazenar informaes de significados diferentes, ainda que
estas informaes sejam do mesmo tipo de dado. Ex.: nota, idade e
n do aluno na turma, mesmo sendo todos do tipo Inteiro, no devem
ser armazenados juntos em um vetor, pois so informaes de signifi-
cados totalmente diferentes. Esta uma prtica que ajuda a manter a
organizao e a consistncia dos dados manipulados pelo algoritmo.

Declarao
Conforme j foi citado, todos os elementos de um vetor pertencem necessariamente ao
mesmo tipo de dado. Esta a essncia das estruturas de dados homogneas.
A declarao de vetores em pseudocdigo realizada utilizando-se a seguinte sintaxe:

<nomeVetor> : Vetor[1..<tamanho>] De <tipo_de_dado>

60 Exemplo:

{Declarao de vetor}
Estruturas de Dados Homogneas

Variveis
valores : Vetor[1..10] De Inteiro;
locais : Vetor[1..5] de Caractere;

Tenha em mente que uma vez que um vetor seja declarado no possvel modificar seu
tamanho. Contudo, em termos de aproveitamento de memria no uma boa prtica criar um
vetor com posies que voc no pretende utilizar, pois quando declaramos um vetor, o com-
putador aloca (reserva) a quantidade de memria necessria para armazenar todos os elementos
do vetor.
O ideal s declarar um vetor quando souber a quantidade de itens que se deseja arma-
zenar nele, porm, em alguns casos, inevitvel declararmos um vetor com um tamanho que
no ser totalmente utilizado. Por exemplo, a quantidade de alunos em uma turma pode variar
bastante, ento a soluo declarar o vetor com o tamanho mximo que uma turma pode ter,
mesmo sabendo que para a maioria das turmas haver desperdcio de espao.
A nomenclatura utilizada para os vetores segue os mesmos padres utilizados para
as variveis.
Atribuio e Leitura
Para acessar (atribuir ou ler) um determinado elemento dentro do vetor, necessrio
informar sua posio, tambm chamada de ndice, por meio da seguinte sintaxe:

{para atribuir}
<nomeVetor>[<ndice>] := <valor>;

{para ler}
<nomeVariavel> := <nomeVetor>[<ndice>];

As operaes de atribuio e leitura podem ser realizadas diretamente em cada posio do


vetor, mas isto se torna desnecessariamente trabalhoso. Veja:

{Exemplo de vetor}
Algoritmo ExemploVetor
Variveis
valores : Vetor[1..10] De Inteiro;
Incio
Escreva(Digite um valor para a posio 1:);
Leia(valores[1]);
Escreva(Digite um valor para a posio 2:);
Leia(valores[2]);
61
{...at o ltimo elemento}

Escreva(O elemento da posio 1 vale + valores[1]);

Estruturas de Dados Homogneas


Escreva(O elemento da posio 2 vale + valores[2]);
{...at o ltimo elemento}
Fim

Se formos acessar todos os itens de um vetor da forma como est no exemplo acima, no
h vantagem alguma em relao ao uso de variveis. O acesso direto uma alternativa apenas
para quando desejamos acessar poucos elementos do vetor.
Para percorrer um vetor, o melhor utilizarmos uma estrutura de repetio, e a opo
mais interessante a estrutura de repetio com varivel de controle (o Para), pois, neste caso,
a quantidade de iteraes conhecida com antecedncia.
Vejamos um exemplo em pseudocdigo, ilustrando o uso de vetores:
{Exemplo de vetor}
Algoritmo ExemploVetor
Variveis
valores : Vetor[1..10] De Inteiro;
contador : Inteiro;
Incio
01 Para contador De 1 At 10 Passo 1 Faa
02 Escreva(Digite um valor para a posio + contador + :);
03 Leia(valores[contador]);
04 Fim_Para

05 Para contador De 1 At 10 Passo 1 Faa


06 Escreva(O elemento da posio + contador +
vale + valores[contador])
07 Fim_Para
Fim

Veja o fluxograma do exemplo:

Incio

62 Percorrendo o
A
vetor, realizando Percorrendo o
atribuio vetor realizando
contador, leitura
Estruturas de Dados Homogneas

1, 10, 1
contador,
1, 10, 1

Digite um valor
para a posio
<contador>: O elemento da posio
<contador> vale
<valores>[<contador>]

valores[contador]

Fim

A
Vejamos um exemplo um pouco mais detalhado, somente em pseudocdigo:

{Exemplo de vetor 2}
Algoritmo ExemploVetor2
Variveis
vetA, vetB : Vetor[1..5] De Inteiro;
vetC : Vetor[1..10] De Inteiro;
contador, complemento : Inteiro;
Incio
01 Escreva(Populando o primeiro vetor);
02 Para contador De 1 At 5 Passo 1 Faa
03 Escreva(Digite um valor para a posio + contador + :);
04 Leia(vetA[contador]);
05 Fim_Para

06 Escreva(Populando o segundo vetor automaticamente);


07 Para contador De 1 At 5 Passo 1 Faa
08 vetB[contador] := vetA[contador] * 2;
09 Fim_Para

10 complemento := 0;
11 Para contador De 1 At 5 Passo 1 Faa
12 vetC[contador + complemento] := vetA[contador];
13 complemento := complemento + 1;
14 vetC[contador + complemento] := vetB[contador];
15 Fim_Para 63
Fim

Estruturas de Dados Homogneas


O exemplo acima popula (preenche) um vetor com dados informados pelo usurio (linhas
01 a 05), popula um segundo vetor com base nos dados do primeiro (linhas 06 a 09) e, por fim,
popula um terceiro vetor com base nos dois anteriores, pegando os valores alternadamente
(linhas 10 a 15).
Perceba que a varivel contador foi utilizada para as trs estruturas de repetio, ao invs
de declararmos uma varivel para cada repetio. Isto s foi possvel porque as estruturas no
esto aninhadas, caso contrrio, uma estrutura interferiria no contador que est sendo utilizado
pela outra.
Exemplo:
{O compartilhamento de contador incorreto}
Algoritmo ExemploCompartilharContador
Variveis
vetA, vetB : Vetor[1..5] De Inteiro;
contador : Inteiro;
Incio
01 Para contador De 1 At 10 Passo 1 Faa
02 Escreva(Digite um valor para a posio + contador + :);
03 Leia(vetA[contador]);

04 Para contador De 1 At 3 Passo 1 Faa


05 Escreva(Compartilhar contador no d certo.);
06 Fim_Para
07 Fim_Para
Fim

No exemplo anterior, sempre que a estrutura de repetio mais interna encerrar seu loop, o
contador estar valendo 3; o que far com que a estrutura externa entre em loop infinito, pois o con-
tador nunca chegar ao valor 10, que o critrio de sada desta estrutura. Dependendo dos critrios
estabelecidos em cada estrutura, o compartilhamento de variveis de controle tambm pode causar
outros tipos de problemas.
Para evitar o problema do exemplo, deveriam ter sido declaradas duas variveis de
controle, uma para cada estrutura de repetio. Esta regra vale independentemente do tipo de
64 repetio que estivermos utilizando: pode ser uma repetio com Ps-Teste, dentro de uma
com varivel de controle; uma com Pr-Teste, dentro de uma com Ps-Teste, etc. Lembre-se de
nunca compartilhar variveis de controle entre estruturas de repetio aninhadas.
Estruturas de Dados Homogneas

Matrizes
Matrizes so estruturas de dados que seguem o mesmo princpio dos vetores, porm as matri-
zes possuem duas ou mais dimenses, ao contrrio dos vetores que possuem apenas uma dimenso.

Matrizes Bi e Tridimensionais
Matrizes Bidimensionais
As matrizes bidimensionais possuem duas ou mais linhas e duas ou mais colunas, e costumam
ser representadas por meio de tabelas:
11 23 36
7 31 54
13 66 91
44 80 32
Para entendermos melhor a estrutura das matrizes bidimensionais, vamos represent-las
da seguinte forma:
ndices de coluna
1 2 3
1 11 23 36
2 37 31 54
ndices
3 13 16 91
de linha
4 44 80 32
5 61 14 29

A matriz acima possui 15 elementos, distribudos em 5 linhas e 3 colunas. O elemento


da posio linha 1 coluna 1 possui o valor 11; enquanto que o elemento da linha 3, coluna 2,
vale 16.

Matrizes Tridimensionais
Uma matriz tridimensional possui largura, altura e profundidade. A estrutura de linhas e
colunas repetida diversas vezes, como se fossem fatias ou camadas. Exemplo:

65

Estruturas de Dados Homogneas

Cada elemento de uma matriz tridimensional referenciado por meio da sua posio
dada por linha, coluna e profundidade.
Torna-se difcil a representao e, at mesmo, a concepo visual de matrizes com mais
de trs dimenses, mas, teoricamente, elas tambm podem ser utilizadas, apesar de tornarem os
algoritmos demasiadamente complexos.
Na prtica, as matrizes bidimensionais so as mais utilizadas e, em poucos casos, as tridi-
mensionais. Por isso, priorizaremos as matrizes bidimensionais para exemplos e exerccios ao
longo do livro.
Declarao
Assim como os vetores, as matrizes tambm s podem armazenar elementos do mesmo tipo de
dado. Alm disso, tambm no possvel modificar o tamanho de uma matriz aps a sua declarao.
A declarao de matrizes em pseudocdigo realizada utilizando-se a seguinte sintaxe:

<nomeMatriz> : Matriz[1..<qtdeLinhas>, 1..<qtdeColunas>] De <tipo_de_dado>

Exemplo:
{Declarao de matriz}
Variveis
gradeValores := Matriz[1..10, 1..5] De Real;
itens : Matriz[1..5, 1..3] De Caractere;

Atribuio e Leitura
Para realizar as operaes de atribuio e leitura de valor em elementos de uma matriz,
necessrio informar a posio do elemento por meio da seguinte sintaxe:
{para atribuir}
<nomeMatriz>[<linha>, <coluna>] := <valor>;

66 {para ler}
<nomeVariavel> := <nomeMatriz>[<linha>, <coluna>];
Estruturas de Dados Homogneas

Lembre-se de que para fazer referncia a um elemento de uma matriz, necessrio infor-
mar sempre o nmero da linha antes do nmero da coluna.
Vejamos um exemplo em pseudocdigo, ilustrando o uso de matrizes:
{Exemplo de matriz}
Algoritmo ExemploMatriz
Variveis
gradeValores : Matriz[1..10, 1..5] De Inteiro;
i, j : Inteiro;
Incio
01 Para i De 1 At 10 Passo 1 Faa
02 Escreva(Populando a linha + i);
03 Para j De 1 At 5 Passo 1 Faa
04 Escreva(Digite um valor para a coluna + j + :);
05 Leia(gradeValores[i, j]);
06 Fim_Para
07 Fim_Para
08 Para i De 1 At 10 Passo 1 Faa
09 Para j De 1 At 5 Passo 1 Faa
10 Escreva(O elemento da linha + i + coluna + j +
vale + gradeValores[i, j])
11 Fim_Para
12 Fim_Para
Fim

Os comandos entre as linhas 1 e 7 tm a funo de popular a matriz. Repare que, para isso,
foi necessrio utilizar duas estruturas de repetio, uma para percorrer as linhas e outra para
percorrer as colunas da matriz. Assim, quando o loop externo estiver na linha 1, o loop interno
far referncia s colunas de 1 a 5, da linha 1; quando o loop externo estiver na linha 2, o loop
interno far referncia s colunas de 1 a 5, da linha 2; e assim sucessivamente, at que toda a
matriz seja preenchida.
Entre as linhas 8 e 12, a matriz percorrida a fim de escrever na tela o valor armazenado
em cada uma de suas posies.
Veja o algoritmo representado em um fluxograma:

Incio

A
Percorrendo
cada linha da
matriz
i, 1, 10, 1

i, 1, 10, 1
67

Populando a linha Percorrendo

Estruturas de Dados Homogneas


<i> cada coluna
da linha atual

j, 1, 5, 1
j, 1, 5, 1

O elemento da linha <i>


Digite um valor coluna <j> vale
para a coluna <j> <gradeValores>[<i>, <j>]

gradeValores[i, j]

Fim

O exemplo acima bastante simples. Ele apenas popula uma matriz com informaes
solicitadas ao usurio e, em seguida, escreve na tela os valores armazenados na matriz.
Vejamos agora um exemplo um pouco mais complexo:
{Exemplo de matriz 2}
Algoritmo ExemploMatriz2
Variveis
nomeDespesas : Vetor[1..4] de Caractere;
valorDespesas : Matriz[1..12, 1..4] De Real;
i, j, ano : Inteiro;
somatorio, totalAnual : Real;
Incio
01 nomeDespesas[1] := Aluguel;
02 nomeDespesas[2] := Condomnio;
03 nomeDespesas[3] := Energia Eltrica;
04 nomeDespesas[4] := Telefone e Internet;

05 Escreva(Clculo de despesas anuais.);


06 Escreva(Informe o ano:);
07 Leia(ano);
08 Para i De 1 At 12 Passo 1 Faa
09 Para j De 1 At 4 Passo 1 Faa
10 Escreva(Informe o gasto com + nomeDespesas[j] +
no ms + i);
11 Leia(valorDespesas[i, j]);
12 Fim_Para
13 Fim_Para

14 Imprima(Relatrio de gastos com moradia no ano de + ano);


15 totalAnual := 0;
16 Para i De 1 At 4 Passo 1 Faa
68
17 somatorio := 0;
18 Para j De 1 At 12 Passo 1 Faa
19 somatorio := somatorio + valorDespesas[j, i];
Estruturas de Dados Homogneas

20 Fim_Para
21 Imprima(O total gasto com + nomeDespesas[i] +
ao longo do ano foi + somatorio);
22 totalAnual := totalAnual + somatorio;
23 Fim_Para
24 Imprima(O total gasto no ano foi + totalAnual);
25 Imprima(A mdia mensal de gastos foi + (totalAnual / 12));
Fim

O algoritmo acima tem o objetivo de calcular os gastos com moradia em um determinado


ano. Primeiro ele popula um vetor com o nome dos 4 tipos de despesas que ir calcular (linhas
1 a 4). Isto necessrio para identificar cada uma das despesas que sero solicitadas ao usurio.
Entre as linhas 8 e 13, percorre-se a matriz linha a linha; e para cada linha, coluna a coluna. Deste
modo, possvel solicitar ao usurio os valores gastos em cada ms com cada tipo de despesa.
Entre as linhas 16 e 23, percorre-se a matriz coluna a coluna; e para cada coluna, linha a
linha. Assim possvel somar todos os valores de cada despesa ao longo do ano.
Lembre que esta apenas uma das vrias implementaes possveis para resolver este
problema.
Atividades
1) Crie um algoritmo em pseudocdigo que solicite ao usurio
10 valores inteiros, armazenando os dados em um vetor. Em
seguida, o algoritmo dever percorrer o vetor escrevendo
na tela os valores armazenados nas posies mpares e
mandando para a impressora os valores armazenados nas
posies pares. Aplique o teste de mesa.

2) Escreva um algoritmo em pseudocdigo que solicite ao usurio


5 valores inteiros e em seguida escreva na tela os valores lidos
em ordem inversa (o ltimo valor lido o primeiro a ser escrito na
tela, e assim por diante). Utilize vetor na sua implementao.
Voc dever criar 3 verses do algoritmo, cada uma delas uti-
lizando uma das estruturas de repetio estudadas. Aplique o
teste de mesa.

3) Crie um algoritmo (pseudocdigo) que solicite ao usurio


valores reais a fim de popular uma matriz de 3 linhas e 7 colu-
nas. Em seguida os valores lidos devem ser enviados para a
impressora, juntamente com a indicao da posio em que
ocupavam na matriz.
69
4) Considerando uma turma com 30 alunos, crie um algoritmo
em pseudocdigo para calcular a mdia de todos os alunos,

Estruturas de Dados Homogneas


sabendo que cada aluno possui duas notas. Ao final, envie
para a impressora os nomes dos alunos com suas respectivas
mdias.

5) Desenvolva um algoritmo capaz de realizar as seguintes


atividades:
a. Armazenar o nome de 100 produtos informados pelo usurio
em um vetor;
b. Considerando que existem 3 lojas, solicitar ao usurio o estoque
atual de cada produto em cada uma das lojas, armazenando
estes dados em uma matriz;
c. Gerar o estoque consolidado de cada produto na rede de lojas,
armazenando em outra coluna da matriz;
d. Considerando que o estoque mnimo de cada produto na rede
de lojas deve ser de 30 unidades, enviar para a impressora um
relatrio com o nome dos produtos que necessitam ser com-
prados e o estoque atual destes produtos.
Pense na forma mais eficiente de resolver o problema.
061

Estruturas de Dados
Homogneas: Ordenao
e Pesquisa
Com base no que j estudamos, pode-se dizer que a utilizao de vetores e matrizes faci-
lita a criao de programas capazes de manipular maiores volumes de dados.
Em muitos casos, porm, os dados precisam ser ordenados antes de serem exibidos ao
usurio ou, ento, utilizados em algum outro processamento. Em outros casos, ser necessrio
procurar um determinado elemento dentro de um vetor, pois no sabemos sua posio e nem
mesmo se ele se encontra armazenado l. So justamente estas duas demandas que buscamos
atender neste captulo.
70
Se fosse preciso armazenar uma lista de nomes, voc iria utilizar um vetor ou uma matriz?
Faz muito mais sentido armazenar em um vetor, certo? por este motivo que muito mais fre-
Estruturas de Dados Homogneas: Ordenao e Pesquisa

quente termos a necessidade de ordenar e pesquisar os vetores em vez das matrizes. E, partindo
dessa premissa, iremos abordar a ordenao e pesquisa do ponto de vista dos vetores. Contudo,
tambm possvel ordenar e pesquisar matrizes, utilizando as tcnicas que iremos conhecer,
com algumas mudanas nos algoritmos.

Ordenao de Vetores
A ordenao dos elementos de um vetor pode ser realizada independentemente do tipo
de dado que o vetor esteja armazenando. Geralmente, a ordenao feita em ordem crescente,
ou seja, com o menor elemento ocupando a primeira posio do vetor e o maior elemento
ocupando a ltima. Depois, caso seja necessrio acessar a lista de dados em ordem decrescente,
basta percorrer o vetor de trs para frente.
Existem vrias tcnicas de ordenao de vetores, porm iremos utilizar uma tcnica bsica,
pois a ideia termos um primeiro contato com este tipo de algoritmo e praticarmos a mudana
de posio de elementos em um vetor. Oportunamente voc ter contato com tcnicas de orde-
nao mais avanadas, a maioria utilizando recursos que no estudamos at o momento.
Bubble Sort
O mtodo de ordenao Bubble Sort, tambm conhecido como mtodo bolha, um dos
mais simples de todos. Ele realiza a chamada ordenao por flutuao.
Seu funcionamento bastante simples, consiste em percorrer o vetor vrias vezes tra-
zendo para a posio de referncia o menor elemento encontrado. Na primeira execuo, a
posio de referncia a primeira posio do vetor. A cada vez que o vetor percorrido, a
posio de referncia avana uma casa. Quando a posio de referncia chegar ao final do vetor,
este estar ordenado.
Imagine que desejamos ordenar o seguinte vetor:

Brasil Paraguai Argentina Uruguai Chile

A seguir, veremos um passo a passo para orden-lo, utilizando o mtodo Bubble Sort.
Vamos represent-lo com ndice para facilitar a compreenso.
O primeiro passo entendermos a funo de duas peas importantes:
ndice de Referncia (IR): Como necessrio percorrer todo o vetor, realizando
comparaes, o ndice de referncia um marco que indica que todos os itens sua
esquerda j esto ordenados. Ele tambm indica o local onde deve ser armazenado o
menor valor encontrado durante a iterao atual. Na primeira iterao, o ndice de
referncia a primeira posio do vetor.
ndice Atual (IA): Indica a posio atual que deve ser utilizada na comparao com o
elemento do ndice de referncia. Todos os itens sua esquerda j foram comparados 71
na iterao atual, e os da direita ainda no. A cada nova iterao, o ndice atual inicia-
lizado com o valor do ndice de referncia mais um.

Estruturas de Dados Homogneas: Ordenao e Pesquisa


De acordo com a explicao acima, iniciamos o processo sempre com o IR apontando
para o primeiro elemento do vetor, e o IA apontando para IR + 1:

ndice 1 2 3 4 5
Elemento Brasil Paraguai Argentina Uruguai Chile

IR IA

O primeiro passo compar-los. Se o elemento IR for maior do que o elemento IA,


eles devem trocar de lugar. Como a resposta para este teste foi negativa, avanamos o IA para a
posio 3:

ndice 1 2 3 4 5
Elemento Brasil Paraguai Argentina Uruguai Chile

IR IA
Agora, ao realizarmos uma nova comparao, percebemos que os elementos devem ser
trocados de lugar, pois na ordem alfabtica, Argentina vem antes de Brasil:

ndice 1 2 3 4 5
Elemento Argentina Paraguai Brasil Uruguai Chile

IR IA

Avanamos novamente o IA (posio 4) e realizamos nova comparao entre eles:

ndice 1 2 3 4 5
Elemento Argentina Paraguai Brasil Uruguai Chile

IR IA

Como o resultado da comparao acima indicou que no deve haver troca na posio dos
elementos, apenas avanamos o IA novamente (posio 5):

ndice 1 2 3 4 5
Elemento Argentina Paraguai Brasil Uruguai Chile

IR IA

72
Comparando IA e IR verificamos que no necessria a troca. IA chegou ao final do
vetor, indicando que o elemento que agora se encontra no IR j est ordenado, por isso o IR
Estruturas de Dados Homogneas: Ordenao e Pesquisa

deve avanar para a prxima posio (2). Alm disso, como est iniciando uma nova iterao, o
IA inicializado com o valor IR + 1 (posio 3):

ndice 1 2 3 4 5
Elemento Argentina Paraguai Brasil Uruguai Chile

IR IA

Seguindo o mesmo processo, percebemos que necessrio trocar Paraguai e Brasil de


lugar:

ndice 1 2 3 4 5
Elemento Argentina Brasil Paraguai Uruguai Chile

IR IA
Avanamos IA para o ndice 4. A troca entre os ndices 2 e 4 no necessria:

ndice 1 2 3 4 5
Elemento Argentina Brasil Paraguai Uruguai Chile

IR IA

Avanamos IA mais uma vez, e constatamos que a troca tambm no necessria:

ndice 1 2 3 4 5
Elemento Argentina Brasil Paraguai Uruguai Chile

IR IA

Como IA est novamente no final do vetor, a iterao chegou ao fim, por isso avanamos
IR novamente e inicializamos IA com IR + 1:

ndice 1 2 3 4 5
Elemento Argentina Brasil Paraguai Uruguai Chile

IR IA

Comparamos IR a IA e percebemos que a troca no necessria. Ento, avanamos IA


para a posio 5:
73

ndice 1 2 3 4 5
Argentina Brasil Paraguai Uruguai Chile

Estruturas de Dados Homogneas: Ordenao e Pesquisa


Elemento

IR IA

Desta vez, a troca se faz necessria:

ndice 1 2 3 4 5
Elemento Argentina Brasil Chile Uruguai Paraguai

IR IA

Como IA chegou novamente ao final do vetor, avanamos IR para a posio 4 e iniciali-


zamos IA com IR + 1:

ndice 1 2 3 4 5
Elemento Argentina Brasil Chile Uruguai Paraguai

IR IA
A posio mxima de IR sempre ser <tamanho_vetor> - 1, o que indica que esta a
ltima iterao. Como a inicializao de IA j o coloca no ltimo elemento do vetor (5), esta
iterao ter apenas uma comparao. Comparando os dois elementos, percebemos a necessi-
dade de troc-los de lugar:

ndice 1 2 3 4 5
Elemento Argentina Brasil Chile Paraguai Uruguai

IR IA

Como IR no pode avanar alm do penltimo elemento (neste caso a posio 4) e IA j


est no fim do vetor, a ordenao est encerrada.
Voc percebeu que o tamanho das iteraes foi se reduzindo ao longo do processo de
ordenao? Isso ocorre porque a cada nova iterao um elemento ordenado, tomando sua
posio definitiva no vetor, o que faz com que a nova iterao tenha um item a menos para
percorrer.
Agora veja o algoritmo Bubble Sort implementado em pseudocdigo:

{Ordenao com o mtodo bolha}


Algoritmo ExemploBubbleSort
Variveis
paises : Vetor[1..5] de Caractere;
aux : Caractere;
ir, ia : Inteiro;
Incio
74
01 paises[1] := Brasil;
02 paises[2] := Paraguai;
Estruturas de Dados Homogneas: Ordenao e Pesquisa

03 paises[3] := Argentina;
04 paises[4] := Uruguai;
05 paises[5] := Chile;

06 Para ir De 1 At 4 Passo 1 Faa


07 Para ia De ir+1 At 5 Passo 1 Faa
08 Se(paises[ir] > paises[ia]) Ento
09 aux := paises[ir];
10 paises[ir] := paises[ia];
11 paises[ia] := aux;
12 Fim_Se
13 Fim_Para
14 Fim_Para
Fim

Perceba que necessrio o uso de uma varivel auxiliar na hora de inverter a posio dos
elementos no vetor, pois sem o seu uso o valor original de IR seria perdido quando este rece-
besse o valor de IA.
O teste de mesa para o algoritmo acima ficaria assim:
Linha ir ia aux paises[1] paises[2] paises[3] paises[4] paises[5]
1 Brasil
2 Brasil Paraguai
3 Brasil Paraguai Argentina
4 Brasil Paraguai Argentina Uruguai
5 Brasil Paraguai Argentina Uruguai Chile
6 1 Brasil Paraguai Argentina Uruguai Chile
7 1 2 Brasil Paraguai Argentina Uruguai Chile
8 1 2 Brasil Paraguai Argentina Uruguai Chile
7 1 3 Brasil Paraguai Argentina Uruguai Chile
8 1 3 Brasil Paraguai Argentina Uruguai Chile
9 1 3 Brasil Brasil Paraguai Argentina Uruguai Chile
10 1 3 Brasil Argentina Paraguai Argentina Uruguai Chile
11 1 3 Brasil Argentina Paraguai Brasil Uruguai Chile
7 1 4 Brasil Argentina Paraguai Brasil Uruguai Chile
8 1 4 Brasil Argentina Paraguai Brasil Uruguai Chile
7 1 5 Brasil Argentina Paraguai Brasil Uruguai Chile
8 1 5 Brasil Argentina Paraguai Brasil Uruguai Chile
6 2 5 Brasil Argentina Paraguai Brasil Uruguai Chile
7 2 3 Brasil Argentina Paraguai Brasil Uruguai Chile
8 2 3 Brasil Argentina Paraguai Brasil Uruguai Chile
9 2 3 Paraguai Argentina Paraguai Brasil Uruguai Chile
10 2 3 Paraguai Argentina Brasil Brasil Uruguai Chile
11 2 3 Paraguai Argentina Brasil Paraguai Uruguai Chile
7 2 4 Paraguai Argentina Brasil Paraguai Uruguai Chile
8 2 4 Paraguai Argentina Brasil Paraguai Uruguai Chile
7 2 5 Paraguai Argentina Brasil Paraguai Uruguai Chile 75
8 2 5 Paraguai Argentina Brasil Paraguai Uruguai Chile
6 3 5 Paraguai Argentina Brasil Paraguai Uruguai Chile

Estruturas de Dados Homogneas: Ordenao e Pesquisa


7 3 4 Paraguai Argentina Brasil Paraguai Uruguai Chile
8 3 4 Paraguai Argentina Brasil Paraguai Uruguai Chile
7 3 5 Paraguai Argentina Brasil Paraguai Uruguai Chile
8 3 5 Paraguai Argentina Brasil Paraguai Uruguai Chile
9 3 5 Paraguai Argentina Brasil Paraguai Uruguai Chile
10 3 5 Paraguai Argentina Brasil Chile Uruguai Chile
11 3 5 Paraguai Argentina Brasil Chile Uruguai Paraguai
6 4 5 Paraguai Argentina Brasil Chile Uruguai Paraguai
7 4 5 Paraguai Argentina Brasil Chile Uruguai Paraguai
8 4 5 Paraguai Argentina Brasil Chile Uruguai Paraguai
9 4 5 Uruguai Argentina Brasil Chile Uruguai Paraguai
10 4 5 Uruguai Argentina Brasil Chile Paraguai Paraguai
11 4 5 Uruguai Argentina Brasil Chile Paraguai Uruguai

Obs.: Para facilitar a leitura do teste de mesa, em cada passo foi colocado em azul o valor
da varivel que sofreu alterao.
Apesar de atingir satisfatoriamente seu objetivo na ordenao de vetores, o mtodo Bubble
Sort no aconselhado para grandes volumes de dados, pois o fato de percorrer o vetor diversas
vezes para realizar a ordenao compromete sua performance.
Pesquisa Sequencial
A pesquisa sequencial o tipo de pesquisa mais simples que existe. A ideia percorrer
o vetor item a item at encontrar o elemento desejado ou descobrir que ele no se encontra
no vetor. Existem duas variantes da busca sequencial, uma aplicvel a vetores no ordenados e
outra a vetores ordenados.

Vetores No Ordenados
A pesquisa sequencial em vetores no ordenados tambm conhecida como pesquisa
exaustiva, pois consiste em comparar o valor pesquisado com cada um dos elementos do vetor,
at que haja uma correspondncia ou que se chegue ao final do vetor (o que indica que o ele-
mento pesquisado no existe no conjunto).
Quando um vetor no est ordenado, a nica forma de pesquisa efetiva a pesquisa exaustiva.
Vejamos o algoritmo de pesquisa exaustiva implementado em pseudocdigo:
{Pesquisa exaustiva}
Algoritmo ExemploPesqExaustiva
Variveis
paises : Vetor[1..5] de Caractere;
posAtual : Inteiro;
itemPesquisa : Caractere;
achou : Lgico;
Incio
01 Para posAtual De 1 At 5 Passo 1 Faa
02 Escreva(Digite o nome do pas para a posio + posAtual);
76 03 Leia(paises[posAtual]);
04 Fim_Para

05 Escreva(Digite o nome do pas que deseja pesquisar:);


Estruturas de Dados Homogneas: Ordenao e Pesquisa

06 Leia(itemPesquisa);

07 posAtual := 1;
08 achou := F;
09 Enquanto((posAtual <= 5) .E. (achou = F)) Faa
10 Se(paises[posAtual] = itemPesquisa) Ento
11 achou := V;
12 Seno
13 posAtual := posAtual + 1;
14 Fim_Se
15 Fim_Enquanto

16 Se(achou = V) Ento
17 Escreva(O item + itemPesquisa +
foi encontrado na posio + posAtual);
18 Seno
19 Escreva(O item + itemPesquisa +
no foi encontrado no vetor);
20 Fim_Se
Fim
O algoritmo anterior realiza a leitura de 5 elementos, armazenando-os em um vetor
(linhas 1 a 4). Em seguida, solicita a entrada de um valor a ser pesquisado no vetor (linhas 5 e 6).
O que mais nos interessa no momento o trecho que vai da linha 7 at a linha 20, onde so
realizadas as pesquisas no vetor e a apresentao do resultado ao usurio.
Vejamos um teste de mesa a fim de comprovar o funcionamento do algoritmo. Para fins
de exemplo, iremos simular que o usurio digitou os seguintes valores:

Brasil Paraguai Argentina Uruguai Chile

Vamos ainda considerar que o valor a ser pesquisado Chile.


Com isso, iremos executar o teste de mesa apenas do trecho que nos interessa, que a
parte de pesquisa e de retorno ao usurio (linhas 7 a 20):

itemPes- paises paises paises paises paises


Linha posAtual Achou
quisa [1] [2] [3] [4] [5]
7 1 Chile Brasil Paraguai Argentina Uruguai Chile
8 1 F Chile Brasil Paraguai Argentina Uruguai Chile
9 1 F Chile Brasil Paraguai Argentina Uruguai Chile
10 1 F Chile Brasil Paraguai Argentina Uruguai Chile
12 1 F Chile Brasil Paraguai Argentina Uruguai Chile
13 2 F Chile Brasil Paraguai Argentina Uruguai Chile
9 2 F Chile Brasil Paraguai Argentina Uruguai Chile
10 2 F Chile Brasil Paraguai Argentina Uruguai Chile
12 2 F Chile Brasil Paraguai Argentina Uruguai Chile
13 3 F Chile Brasil Paraguai Argentina Uruguai Chile
9 3 F Chile Brasil Paraguai Argentina Uruguai Chile 77
10 3 F Chile Brasil Paraguai Argentina Uruguai Chile
12 3 F Chile Brasil Paraguai Argentina Uruguai Chile

Estruturas de Dados Homogneas: Ordenao e Pesquisa


13 4 F Chile Brasil Paraguai Argentina Uruguai Chile
9 4 F Chile Brasil Paraguai Argentina Uruguai Chile
10 4 F Chile Brasil Paraguai Argentina Uruguai Chile
12 4 F Chile Brasil Paraguai Argentina Uruguai Chile
13 5 F Chile Brasil Paraguai Argentina Uruguai Chile
9 5 F Chile Brasil Paraguai Argentina Uruguai Chile
10 5 F Chile Brasil Paraguai Argentina Uruguai Chile
11 5 V Chile Brasil Paraguai Argentina Uruguai Chile
16 5 F Chile Brasil Paraguai Argentina Uruguai Chile
17 Sada em tela: O item Chile foi encontrado na posio 5

Vetores Ordenados
A pesquisa sequencial em vetores ordenados segue o mesmo princpio da verso anterior,
porm como o vetor est ordenado, no necessrio percorr-lo at o fim para saber que o ele-
mento pesquisado no se encontra no vetor. Basta percorrer o vetor at encontrar um elemento
maior do que o pesquisado (isto se o vetor estiver em ordem crescente).
Vejamos um exemplo em pseudocdigo:

{Pesquisa sequencial em vetor ordenado}


Algoritmo ExemploPesqSequencial
Variveis
paises : Vetor[1..5] de Caractere;
posAtual, ir, ia : Inteiro;
itemPesq, aux : Caractere;
Incio
01 Para posAtual De 1 At 5 Passo 1 Faa
02 Escreva(Digite o nome do pas para a posio + posAtual);
03 Leia(paises[posAtual]);
04 Fim_Para

05 Escreva(Digite o nome do pas que deseja pesquisar:);


06 Leia(itemPesq);

07 Para ir De 1 At 4 Passo 1 Faa


08 Para ia De ir+1 At 5 Passo 1 Faa
09 Se(paises[ir] > paises[ia]) Ento
10 aux := paises[ir];
11 paises[ir] := paises[ia];
12 paises[ia] := aux;
13 Fim_Se
14 Fim_Para
15 Fim_Para

16 posAtual := 1;
17 Enquanto((posAtual <= 5) .E. (paises[posAtual] < itemPesq)) Faa
78
18 posAtual := posAtual + 1;
19 Fim_Enquanto
Estruturas de Dados Homogneas: Ordenao e Pesquisa

20 Se(paises[posAtual] = itemPesq) Ento


21 Escreva(O item + itemPesq +
foi encontrado na posio + posAtual);
22 Seno
23 Escreva(O item + itemPesq +
no foi encontrado no vetor);
24 Fim_Se
Fim

O algoritmo acima realiza a leitura de 5 elementos, armazenando-os em um vetor


(linhas 1 a 4) e solicita a entrada de um valor a ser pesquisado (linhas 5 e 6). Entre as linhas 7
e 15 realizada a ordenao do vetor. Novamente, o que mais nos interessa o trecho onde
realizada a pesquisa, que vai da linha 16 at a linha 24, onde tambm dado um retorno ao
usurio sobre o resultado da pesquisa.
Vejamos um teste de mesa, a fim de comprovar o funcionamento do algoritmo. Para fins
de exemplo, iremos simular que o usurio digitou os mesmos valores utilizados no exemplo da
pesquisa exaustiva:
Brasil Paraguai Argentina Uruguai Chile
Vamos considerar que o valor a ser pesquisado tambm Chile.
Novamente iremos executar o teste de mesa apenas no trecho que nos interessa, que a
parte da pesquisa e do retorno ao usurio (linhas 16 a 24). Note que, neste ponto do algoritmo,
o vetor j est ordenado:
Linha posAtual itemPesquisa paises[1] paises[2] paises[3] paises[4] paises[5]
16 1 Chile Argentina Brasil Chile Paraguai Uruguai
17 1 Chile Argentina Brasil Chile Paraguai Uruguai
18 2 Chile Argentina Brasil Chile Paraguai Uruguai
17 2 Chile Argentina Brasil Chile Paraguai Uruguai
18 3 Chile Argentina Brasil Chile Paraguai Uruguai
17 3 Chile Argentina Brasil Chile Paraguai Uruguai
20 3 Chile Argentina Brasil Chile Paraguai Uruguai
21 Sada em tela: O item Chile foi encontrado na posio 3

A grande diferena desta verso em relao pesquisa em vetores no ordenados ocorre


quando o item pesquisado no existe no vetor. Se estivssemos procurando por Bolvia, seria
possvel concluir que o elemento no existe no vetor assim que chegssemos no item Brasil.
No mtodo exaustivo, teramos que ir at o final do vetor para ter esta certeza. Veja:
Linha posAtual itemPesquisa paises[1] paises[2] paises[3] paises[4] paises[5]
16 1 Bolvia Argentina Brasil Chile Paraguai Uruguai
17 1 Bolvia Argentina Brasil Chile Paraguai Uruguai
18 2 Bolvia Argentina Brasil Chile Paraguai Uruguai
17 2 Bolvia Argentina Brasil Chile Paraguai Uruguai
79
20 2 Bolvia Argentina Brasil Chile Paraguai Uruguai
22 2 Bolvia Argentina Brasil Chile Paraguai Uruguai

Estruturas de Dados Homogneas: Ordenao e Pesquisa


23 Sada em tela: O item Bolvia no foi encontrado no vetor

Pesquisa Binria
Quando um vetor est ordenado, podem-se utilizar outros mtodos de pesquisa mais
eficientes do que a pesquisa sequencial. Um mtodo bastante eficiente a pesquisa binria, que,
a cada comparao, elimina uma srie de elementos do universo de pesquisa, o que a torna bem
mais rpida do que a pesquisa sequencial, especialmente em vetores grandes.
O principal motivo da eficincia deste mtodo que so necessrias poucas comparaes
at encontrarmos o elemento desejado ou descobrir que ele no existe no vetor.
A pesquisa binria funciona basicamente da seguinte forma:
Compara-se o valor pesquisado com o elemento da posio central do vetor.
Se o item da posio central igual ao item pesquisado, a busca acabou.
Se o item da posio central maior do que o pesquisado, ento o item pesquisado
pode estar na primeira metade do conjunto e, com certeza, no estar na segunda
metade, o que faz com que esta seja descartada do universo de pesquisa.
Se o item da posio central menor do que o pesquisado, ento o item pesquisado
pode estar na segunda metade do conjunto e, com certeza, no estar na primeira
metade, o que faz com que esta seja descartada do universo de pesquisa.
Repete-se o processo, considerando apenas o novo universo de pesquisa, agora redu-
zido pela metade com relao ltima comparao.
Para que seja possvel realizarmos as operaes citadas acima, necessrio que tenhamos
trs ndices definidos:
1. ndice Inicial (II): Indica o primeiro elemento do universo de pesquisa. No comeo
da pesquisa, o II est posicionado no primeiro elemento do vetor.
2. ndice Final (IF): Indica o ltimo elemento do universo de pesquisa. No comeo da
pesquisa, o IF est posicionado no ltimo elemento do vetor.
3. ndice de Teste (IT): Indica a prxima posio a ser comparada. No comeo da
pesquisa, o IT est posicionado no elemento mais prximo ao centro do vetor, o que
feito por meio da seguinte frmula: IT := (II + IF) / 2. Quando o resultado da
diviso for um nmero fracionrio, considera-se apenas a parte inteira do valor.
Vamos a um exemplo prtico. Imagine que devemos pesquisar o valor 89 no vetor
abaixo:
11 18 31 50 72 89 91 99

O primeiro passo posicionarmos os ndices. Como o vetor possui 8 elementos, o ndice


de teste fica na posio 4.
ndice 1 2 3 4 5 6 7 8
80 Elemento 11 18 31 50 72 89 91 99

II IT IF
Estruturas de Dados Homogneas: Ordenao e Pesquisa

Comparamos, ento, o elemento da posio 4 com o valor pesquisado. Como 89 maior


que 50, constatamos que se o valor pesquisado estiver no vetor, estar entre IT+1 e IF, o que
nos leva a descartar os elementos menores que IT (e o prprio IT) do universo de pesquisa.
Reiniciamos, ento, os ndices considerando o novo conjunto a ser pesquisado:
ndice 1 2 3 4 5 6 7 8
Elemento 11 18 31 50 72 89 91 99

II IT IF

Ento, II passou para o primeiro elemento do novo conjunto e IT passou para o segundo,
pois agora existem quatro elementos apenas. Comparamos novamente o elemento referenciado
por IT com o valor pesquisado e constatamos que o elemento pesquisado est armazenado na
posio 6 do vetor.
Perceba que, neste caso, foram necessrias apenas duas comparaes para encontrar o
valor pesquisado, sendo que com o mtodo sequencial seriam necessrias seis. A performance
do mtodo binrio tende a variar pouco, independente da posio que o elemento pesquisado
ocupe no vetor. A performance do mtodo sequencial, por outro lado, cai drasticamente quando
o elemento pesquisado ocupa uma posio mais avanada no vetor. Alm disso, a diferena de
performance entre os mtodos binrio e sequencial aumenta conforme utilizam-se vetores cada
vez maiores.
Veja o algoritmo de pesquisa binria representado em pseudocdigo:

{Pesquisa binria}
Algoritmo ExemploPesqBinaria
Variveis
valores : Vetor[1..8] de Inteiro;
ir, ia, aux : Inteiro; {usados na ordenao}
ii, if, it, itemPesq : Inteiro; {usados na pesquisa}
achou : Lgico;
Incio
01 Para posAtual De 1 At 8 Passo 1 Faa
02 Escreva(Digite um valor inteiro para a posio + posAtual);
03 Leia(valores[posAtual]);
04 Fim_Para

05 Escreva(Digite o valor que deseja pesquisar:);


06 Leia(itemPesq);

07 Para ir De 1 At 7 Passo 1 Faa


08 Para ia De ir+1 At 8 Passo 1 Faa
09 Se(valores[ir] > valores[ia]) Ento
10 aux := valores[ir];
11 valores[ir] := valores[ia];
12 valores[ia] := aux; 81
13 Fim_Se
14 Fim_Para

Estruturas de Dados Homogneas: Ordenao e Pesquisa


15 Fim_Para

16 achou := F;
17 ii := 1; {ndice inicial}
18 if := 8; {ndice final}
19 Enquanto((ii <= if) .E. (achou = F)) Faa
20 it := (ii + if) / 2; {ndice de teste}
21 Se(valores[it] = itemPesq) Ento
22 achou := V;
23 Seno
24 Se(valores[it] > itemPesq) Ento
{descarta da pesquisa os elementos da direita, at it}
25 if := it 1;
26 Seno
{descarta da pesquisa os elementos da esquerda, at it}
27 ii := it + 1;
28 Fim_Se
29 Fim_Se
30 Fim_Enquanto
31 Se(achou = V) Ento
32 Escreva(O valor + itemPesquisa +
foi encontrado na posio + it);
33 Seno
34 Escreva(O valor + itemPesquisa +
no foi encontrado no vetor);
35 Fim_Se
Fim

O algoritmo acima realiza a leitura de 8 valores inteiros, armazenando-os em um vetor


(linhas 1 a 4) e solicita a entrada de um valor a ser pesquisado (linhas 5 e 6). Entre as linhas 7 e
15, realizada a ordenao do vetor. A pesquisa binria realizada entre as linhas 16 e 30, e entre
as linhas 31 e 35 apresentado o resultado da pesquisa ao usurio.
Veja um teste de mesa realizado com os dados do exemplo anterior:

11 18 31 50 72 89 91 99

O valor a ser pesquisado 89.


Vamos executar o teste de mesa apenas no trecho onde ocorre a pesquisa binria e apre-
sentao do resultado (linhas 16 a 35). Como os elementos do vetor no sofrem alterao de
valor ao longo da execuo do algoritmo, podemos represent-los em uma tabela parte:

Valores
valores valores valores valores valores valores valores valores
82 [1] [2] [3] [4] [5] [6] [7] [8]
11 18 31 50 72 89 91 99

A execuo do teste de mesa do algoritmo com estes valores ficaria da seguinte forma:
Estruturas de Dados Homogneas: Ordenao e Pesquisa

Linha ii if it itemPesquisa Achou


16 89 F
17 1 89 F
18 1 8 89 F
19 1 8 89 F
20 1 8 4 89 F
21 1 8 4 89 F
23 1 8 4 89 F
24 1 8 4 89 F
26 1 8 4 89 F
27 5 8 4 89 F
19 5 8 4 89 F
20 5 8 6 89 F
21 5 8 6 89 F
22 5 8 6 89 V
19 5 8 6 89 V
31 5 8 6 89 V
32 Sada em tela: O valor 89 foi encontrado na posio 6
Atividades
Os algoritmos criados nos exerccios a seguir devem ser todos
representados em pseudocdigo.

1) Crie um algoritmo que solicite ao usurio 10 valores inteiros,


armazenando-os em um vetor. Em seguida, o vetor deve ser
ordenado e os valores exibidos na tela em ordem crescente.

2) Construa um algoritmo que leia o nome de 20 pessoas e depois


os imprima em ordem decrescente.

3) Crie um algoritmo que leia 15 valores reais, guardando-os em


um vetor e, em seguida, realize uma pesquisa exaustiva no
vetor com um novo valor informado pelo usurio.

4) Crie um algoritmo que solicite o nome de 10 alunos, armaze-


nando-os em um vetor. Em seguida deve ser realizada uma
pesquisa sequencial com um nome informado pelo usurio.

5) Crie um algoritmo que solicite o nome de 20 produtos. Em


seguida, o algoritmo deve solicitar o nome do produto a ser
pesquisado e escrever na tela a posio em que ele se encon-
tra no vetor. A pesquisa deve ser feita utilizando o mtodo 83
binrio.

Estruturas de Dados Homogneas: Ordenao e Pesquisa


6) Considerando a necessidade de comparar o consumo de
combustvel de 10 veculos, crie um algoritmo que realize as
seguintes atividades:
a. Solicite o modelo do veculo e a quantidade de quilmetros
que ele capaz de rodar com um litro de gasolina;
b. Gere uma mdia de consumo entre todos os carros e exiba
na tela;
c. Contabilize quantos veculos consomem menos do que a
mdia geral e exiba esta informao na tela;
d. Gere um ranking de consumo, comeando pelo veculo mais
econmico at o que mais consome combustvel;
e. Envie para a impressora o ranking gerado;
f. Permita que o usurio informe o nome de um veculo para saber
que posio ele ocupa no ranking, e qual sua diferena de con-
sumo para o carro mais econmico. Em seguida pergunte se o
usurio deseja consultar outro veculo (considerar 0 para sair e
1 para nova consulta).
071

Estruturas de Dados
Heterogneas
Ao contrrio das estruturas homogneas, que permitem armazenar apenas elementos de
um mesmo tipo de dado, as estruturas de dados heterogneas so capazes de guardar dife-
rentes tipos de dados em uma mesma estrutura.
Imagine que tenhamos de ler e manipular os seguintes dados:
Nome Produto Preo Custo Preo Venda Estoque
(tipo Caractere) (tipo Real) (tipo Real) (tipo Inteiro)
Mouse ptico 27,00 36,25 8
Teclado ABNT 22,79 29,00 14
Modem ADSL 53,50 71,00 6
Speaker 14,90 19,90 4
84 Estabilizador 37,20 52,50 15

Com os recursos que vimos at agora, a melhor opo seria armazenar estas informa-
Estruturas de Dados Heterogneas

es em quatro vetores ou dois vetores e uma matriz, porque tanto vetores quanto matrizes s
podem armazenar elementos que sejam do mesmo tipo de dado.
Para atender a este tipo de demanda, foram criadas as estruturas de dados heterogneas,
que so representadas por um tipo de estrutura chamada Registro.

Registros
Os registros permitem agrupar as informaes referentes a uma mesma entidade (um
aluno, um produto, etc.) em uma mesma estrutura. Com os registros, ao invs de termos as
informaes referentes a um determinado elemento espalhadas em vrios vetores/matrizes,
podemos ter todas elas agrupadas em um s lugar. Seria como se cada produto acima fosse
representado assim:
Nome Mouse ptico
Preo Custo 27,00
Preo Venda 36,25
Estoque 8
Podemos entender um registro como sendo um conjunto de variveis que armazenam
informaes relacionadas. importante voc lembrar que um registro deve ser utilizado para
representar uma entidade ou parte dela. Embora seja possvel a criao de registros para arma-
zenar dados no relacionados, isso totalmente desaconselhvel, pois vai contra o seu propsito
e, ao invs de melhorar, ir piorar a organizao dos dados.
As variveis que compem os registros so chamadas de campos. Deste modo, correto
afirmar que o registro representado acima possui quatro campos.
Em termos conceituais, os registros so tipos de dados compostos definidos pelo progra-
mador. Isto significa que, antes que possamos utilizar um registro, este precisa ser definido.
Pense no registro como um novo tipo de dado que voc est criando. A primeira coisa a
fazer definir o tipo, para que, posteriormente, seja possvel declarar elementos deste novo tipo.

Definio
A definio de um registro a etapa em que iremos montar sua estrutura, indicando quais
informaes o registro dever ser capaz de armazenar. Pense na definio do registro como um
molde para criar registros daquele tipo. Esta definio realizada em um bloco prprio, cha-
mado Tipos, que deve estar antes do bloco de declarao de variveis.
No pseudocdigo, a definio de registros segue a seguinte sintaxe:

<identificadorRegistro> : Registro
<declarao dos campos do registro> 85
Fim_Registro

Estruturas de Dados Heterogneas


Exemplo:

{Definio de registro}
Tipos
RegAluno : Registro
nome : Caractere;
nota1 : Real;
nota2 : Real;
Fim_Registro

Para facilitar a identificao dos registros, iremos adotar como padro definir todos os
registros com o prefixo Reg.
Declarao
Declarar um registro reservar uma rea de memria capaz de armazenar um conjunto
de dados, cujos nomes e tipos esto especificados na definio do registro.
A declarao de registros ocorre basicamente pelo mesmo processo que usamos para as
declarao das variveis. Por exemplo, quando declaramos uma varivel do tipo Real, estamos
criando uma rea de armazenamento de informaes com base em um tipo de dado definido
anteriormente. A diferena que, at o momento, ns utilizvamos apenas os tipos de dados
primitivos, ou seja, aqueles j existentes. Agora, com a definio de registros, ns comeamos a
criar nossos prprios tipos de dados, tomando como base os tipos primitivos.
Para declarar um registro, utilizamos o mesmo padro de declarao das variveis:

<nome do registro> : <tipo do registro>;

Exemplo:

{Declarao de registro}
Variveis
aluno1 : RegAluno;

86
Atribuio e Leitura
Para realizar as operaes de atribuio e de leitura de valor nos campos de um registro,
necessrio informar o campo ao qual desejamos acessar, por meio da seguinte sintaxe:
Estruturas de Dados Heterogneas

{para atribuir}
<nomeRegistro>.<nomeCampo> := <valor>;

{para ler}
<nomeVariavel> := <nomeRegistro>.<nomeCampo>;

Vejamos um algoritmo de exemplo, ilustrando o uso de registros:

{Exemplo de utilizao de registros}


Algoritmo ExemploRegistros1
Tipos
RegAluno : Registro
nome : Caractere;
nota1 : Real;
nota2 : Real;
Fim_Registro
Variveis
aluno1 : RegAluno;
aluno2 : RegAluno;
mediaTemp : Real;
Incio
01 Escreva(Informe o nome do aluno 1);
02 Leia(aluno1.nome);
03 Escreva(Informe a nota 1 do aluno 1);
04 Leia(aluno1.nota1);
05 Escreva(Informe a nota 2 do aluno 1);
06 Leia(aluno1.nota2);

07 Escreva(Informe o nome do aluno 2);


08 Leia(aluno2.nome);
09 Escreva(Informe a nota 1 do aluno 2);
10 Leia(aluno2.nota1);
11 Escreva(Informe a nota 2 do aluno 2);
12 Leia(aluno2.nota2);

13 Imprima(O nome do aluno 1 + aluno1.nome); 87


14 mediaTemp := (aluno1.nota1 + aluno1.nota2) /2;
15 Imprima(A mdia do aluno 1 + mediaTemp);

Estruturas de Dados Heterogneas


16 Imprima(O nome do aluno 2 + aluno2.nome);
17 mediaTemp := (aluno2.nota1 + aluno2.nota2) /2;
18 Imprima(A mdia do aluno 2 + mediaTemp);
Fim

O algoritmo acima define um registro capaz de armazenar os dados de um aluno (bloco


Tipos). Em seguida, no bloco Variveis, declara dois registros do tipo definido. No corpo
do algoritmo, solicitado ao usurio a entrada dos dados de cada aluno (linhas 1 a 12), e as
informaes so armazenadas nos registros. Por fim, os dados dos alunos so enviados para a
impressora (linhas 13 a 18).
Este um exemplo bastante simples, que serve para ilustrar apenas um uso bsico dos
registros. Em aplicaes do mundo real, os registros muitas vezes so utilizados para trabalhar
com volumes maiores de dados.
Mas, por exemplo, se a turma tiver 40 alunos, teramos que declarar 40 registros? No.
E voc j conhece a resposta para atender a esta demanda. Anteriormente, ns estudamos uma
estrutura de dados capaz de armazenar um conjunto de elementos de mesmo tipo, lembra?
Estamos falando dos vetores. Como um registro um tipo de dado, ele pode ser armazenado
em vetores. Ento, para atender demanda dos 40 alunos, bastaria criarmos um vetor contendo
40 registros do tipo RegAluno. Veja:

{Exemplo com vetor de registros}


Algoritmo ExemploRegistros2
Tipos
RegAluno : Registro
nome : Caractere;
nota1 : Real;
nota2 : Real;
Fim_Registro
Variveis
alunos : Vetor[1..40] De RegAluno;
mediaTemp : Real;
cont : Inteiro;
Incio
01 Para cont De 1 At 40 Passo 1 Faa
02 Escreva(Informe o nome do aluno + cont);
03 Leia(alunos[cont].nome);
88 04 Escreva(Informe a nota 1 do aluno + cont);
05 Leia(alunos[cont].nota1);
06 Escreva(Informe a nota 2 do aluno + cont);
Estruturas de Dados Heterogneas

07 Leia(alunos[cont].nota2);
08 Fim_Para

09 Para cont De 1 At 40 Passo 1 Faa


10 Imprima(O nome do aluno + cont + +
alunos[cont].nome);
11 mediaTemp := (alunos[cont].nota1 + alunos[cont].nota2) /2;
12 Imprima(A mdia do aluno + cont + + mediaTemp);
13 Fim_Para
Fim

O algoritmo acima declara um vetor com 40 registros e, entre as linhas 1 e 8, popula o


vetor com dados solicitados ao usurio. Depois, entre as linhas 9 e 13, imprimem-se os nomes
e as mdias de todos os alunos. A utilizao de vetores de registros permite a criao de algorit-
mos mais enxutos, simples e funcionais.
Veja este algoritmo representado em fluxograma:

Incio

cont , 1,
40, 1 A

cont, 1,
Informe o nome 40, 1
do aluno <cont>

alunos[cont].nome
O nome do aluno <cont>
<alunos>[<cont>].<nome>

Informe a nota 1
do aluno <cont>

mediaTemp :=
(alunos[cont ].nota1 +
alunos[cont].nota2) /2

alunos[cont].nota1

A mdia do aluno
<cont>
Informe a nota 2 <mediaTemp>
do aluno <cont>

89
Fim
alunos[cont].nota2

Estruturas de Dados Heterogneas


A

A definio de registros no representada nos fluxogramas. E assim como acontece em


relao s variveis e estruturas homogneas, a declarao de registros tambm no deve ser
representada.
Com relao estrutura dos registros, existe outra possibilidade que ainda no explora-
mos: a criao de registros contendo vetores. Esta uma opo interessante para determinados
tipos de implementao, pois mantm a estrutura dos dados bem organizada, ao mesmo tempo
em que facilita a atribuio/leitura de valores por meio de loops.
Imagine que tenhamos de armazenar os nmeros sorteados em cada um dos ltimos dez
concursos da Mega-Sena. Teremos, ento, um vetor de registros em que cada registro ter o
nmero do concurso, a data do sorteio e um vetor com os seis nmeros sorteados.
Veja como ficaria um algoritmo para atender a esta demanda:

{Exemplo com vetor de registros, em que cada registro tem um vetor}


Algoritmo ExemploRegistros1
Tipos
RegConcurso : Registro
numero : Inteiro;
data : Caractere;
numeros : Vetor[1..6] De Inteiro;
Fim_Registro
Variveis
concursos : Vetor[1..10] De RegConcurso;
cont, conNum : Inteiro;
Incio
01 Escreva(Informe os dados dos ltimos 10 concursos
da megasena);
02 Para cont De 1 At 10 Passo 1 Faa
03 Escreva(Informe o numero do concurso + cont);
04 Leia(concursos[cont].numero);
05 Escreva(Informe a data do concurso + cont);
06 Leia(concursos[cont].data);

07 Para contNum de 1 at 6 Passo 1 Faa


08 Escreva(Informe o nmero + contNum);
90 Leia(concursos[cont].numeros[contNum]);
09
10 Fim_Para
11 Fim_Para
Estruturas de Dados Heterogneas

12 Imprima(Relao dos nmeros sorteados nos ltimos


10 concursos da megasena);
13 Para cont De 1 At 10 Passo 1 Faa
14 Imprima(Numero do concurso: + concursos[cont].numero);
15 Imprima(Data do concurso + concursos[cont].data);
16 Imprima(Nmeros sorteados: );
17 Para contNum de 1 at 6 Passo 1 Faa
18 Escreva([ + concursos[cont].numeros[contNum] + ]);
19 Fim_Para
20 Fim_Para
Fim

Assim, criamos um algoritmo que manipula um vetor de registros, onde cada registro
possui outro vetor dentro de si. Preste ateno nas linhas 9 e 18, cujos dados dos vetores inter-
nos de cada registro so atribudos e lidos, respectivamente.
Como estamos acessando nosso registro dentro de um vetor, precisamos informar o
ndice em que o registro se encontra no vetor (concursos[cont]), e como dentro do nosso
registro existe um outro vetor, tambm temos que indicar o ndice para acessar um elemento
deste vetor (numeros[contNum]). Para que seja possvel este acesso, utilizamos duas estrutu-
ras de repetio, uma para percorrer o vetor de registros, e outra para percorrer o vetor interno
de cada registro.
Como voc pode ver, a utilizao conjunta de estruturas de dados homogneas e hetero-
gneas permite manipular maiores volumes de dados de forma mais organizada e eficiente, com
algoritmos bem estruturados e sem grande complexidade.

Atividades
Todos os exerccios a seguir devem ser implementados em
pseudocdigo.

1) Crie um algoritmo que utilize um registro para armazenar os


dados de uma ficha cadastral informados pelo usurio (no
mnimo 5 campos). Os dados do registro lido devero ser
enviados para a impressora.

2) Crie um programa capaz de armazenar o resultado dos 10


jogos realizados em uma rodada do campeonato brasileiro de 91
futebol. Para cada jogo, ser necessrio armazenar as seguin-
tes informaes:

Estruturas de Dados Heterogneas


a. Data do jogo;
b. Local;
c. Time mandante;
d. Time visitante;
e. Escore do mandante;
f. Escore do visitante.

Depois dos dados informados, o algoritmo deve escrever na tela


os dados de cada jogo, indicando quem foi o vencedor do con-
fronto. Utilize um vetor de registros na sua implementao.

3) Crie um algoritmo para realizar emprstimos de DVDs em uma


locadora, sabendo que o cliente pode retirar at 5 DVDs de cada
vez. necessrio imprimir um relatrio com os dados do cliente
e os cdigos dos filmes que ele est levando emprestado. Na
sua implementao, utilize um vetor dentro do registro para
armazenar os cdigos dos filmes que esto sendo retirados.
081

Sub-rotinas
Voc deve lembrar que as estruturas de controle so mecanismos que permitem modificar
o fluxo de execuo dos algoritmos. Agora, iremos conhecer outro tipo de estrutura de con-
trole, chamada de sub-rotina.
De forma bastante simples, uma sub-rotina um conjunto de instrues que no faz
parte do corpo principal do algoritmo, mas que pode ser executado n (zero ou muitas) vezes ao
longo da execuo do algoritmo, por meio de chamadas ao seu nome.

92 Quando uma sub-rotina chamada, o fluxo de execuo desviado para o corpo da


sub-rotina. Ao final da execuo, o fluxo de execuo retorna para o ponto de onde partiu a
chamada, continuando a execuo a partir da prxima instruo abaixo da chamada.
Sub-rotinas

Sub-rotina 1
Fluxo Principal

Sub-rotina 2

Sub-rotina 3
Um dos princpios do paradigma cientfico cartesiano diz que um problema
grande pode ser resolvido de forma mais fcil se for subdividido em vrios pro-
blemas pequenos. Esta a ideia por trs das sub-rotinas. Ao invs de termos um
algoritmo enorme, cheio de estruturas de seleo e repetio, podemos quebr-lo
em vrios pedaos, gerando sub-rotinas responsveis por determinadas tarefas
que fazem parte da resoluo do problema. Assim, podemos pensar na lgica
necessria para resolver cada um dos pequenos problemas, esquecendo-nos tem-
porariamente do todo, enquanto nos focamos na tarefa que uma determinada
sub-rotina dever executar.
O uso de sub-rotinas permite modularizar os algoritmos, de modo que os
conjuntos de instrues responsveis por determinadas tarefas estejam estruturados
de forma mais organizada, facilitando seu entendimento e manuteno. Alm disso,
aumentamos a possibilidade de reutilizao das solues implementadas.
Existem dois tipos de sub-rotinas: os Procedimentos e as Funes.

Procedimentos
O procedimento, tambm chamado de Proc, um tipo de sub-rotina
comumente utilizada para agrupar instrues relacionadas a uma determinada ati-
vidade. Um dos usos frequentes dos procedimentos consiste em realizar a interao
com o usurio os comandos Leia, Imprima e Escreva podem ser implemen-
tados dentro de procedimentos. Isso torna a leitura do algoritmo mais agradvel 93
e, ao mesmo tempo, encapsula cada uma das atividades em blocos de instrues
especializadas em resolver uma parte do problema. Isto facilita o reaproveitamento

Sub-rotinas
de solues entre os algoritmos, pois uma vez que j existe uma sub-rotina capaz
de resolver uma determinada parte de um problema, basta copi-la para outro algo-
ritmo e utiliz-la.
Um procedimento declarado em um bloco prprio, com incio e fim
demarcados. Dentro deste bloco insere-se o conjunto de comandos relacionados
atividade para a qual o procedimento foi criado. A declarao de procedimentos
deve ser realizada aps o bloco de variveis e antes do demarcador de incio do
corpo principal do algoritmo. O corpo principal do algoritmo o ltimo segmento
a ser declarado e por onde se inicia a execuo do algoritmo.
O padro de declarao de procedimentos em pseudocdigo segue a
seguinte sintaxe:

Procedimento <nome do procedimento>()


Incio
<comandos>
Fim_Procedimento
Depois de sua declarao, um procedimento poder ser executado em qualquer ponto do
algoritmo. A chamada a um procedimento realizada por meio de seu nome, por isso inte-
ressante que este seja condizente com as atividades que o procedimento executa. Alm disso,
uma boa prtica nomear os procedimentos iniciando com um verbo. Exemplos: LerNotas(),
ImprimirRelatorio(), CalcularMedias(), ListarAlunosAprovados().
Vejamos um exemplo simples, utilizando procedimento:

{Exemplo de procedimento}
Algoritmo ExemploProcedimento
Variveis
valores : Vetor[1..10] De Inteiro;
contador : Inteiro;

Procedimento LerValores()
Incio
Para contador De 1 At 10 Passo 1 Faa
Escreva(Digite um valor para a posio + contador + :);
Leia(valores[contador]);
Fim_Para
Fim_Procedimento

Procedimento EscreverValores()
Incio
Para contador De 1 At 10 Passo 1 Faa
Escreva(O elemento da posio + contador +
vale + valores[contador])
Fim_Para
Fim_Procedimento
94
Incio
LerValores();
Sub-rotinas

EscreverValores();
Fim

O algoritmo acima apenas popula um vetor e depois escreve na tela os valores lidos.
Perceba que foram declarados dois procedimentos, um para ler e outro para escrever os dados.
No corpo principal do algoritmo, foram inseridas as chamadas aos procedimentos.
Procure pensar nas possibilidades que este mtodo de trabalho nos abre. Por exemplo,
se fosse necessrio escrever os valores diversas vezes, bastaria inserir no corpo do algo-
ritmo diversas chamadas ao procedimento, ao invs de repetir vrias vezes o mesmo bloco de
instrues.
Nos fluxogramas, os procedimentos so representados utilizando-se os seguintes
padres:
A declarao do procedimento representada em outro fluxograma, que deve estar
anexo ao principal.
Nos fluxogramas que representam procedimentos, no lugar das instrues
Incio e Fim, utiliza-se Procedimento <Nome do Procedimento> e
Fim Procedimento, mantendo-se o uso da figura terminador em ambos os casos.
A chamada de um procedimento representada pela figura procedimento, apresen-
tada abaixo:

Procedimento
Representa a execuo de uma sub-rotina do tipo procedimento

Veja o algoritmo do exemplo anterior, representado em fluxograma:

Procedimento LerValores

Procedimento EscreverValores
Incio
contador,
1, 10, 1
contador,
1, 10, 1
LerValores
Digite um valor
para a posio
<contador>:
O elemento da posio
<contador> vale
EscreverValores <valores>[<contador>]

valores[contador]

Fim
Fim Procedimento

Fim Procedimento
95

Sub-rotinas
Agora vejamos o uso de procedimentos em um exemplo um pouco mais elaborado:

{Exemplo Procedimento 2}
01 Algoritmo ExemploProcedimento2
02 Tipos
03 RegFuncionario : Registro
04 nome : Caractere;
05 cargo : Caractere;
06 salario : Real;
07 bonificacao : Real;
08 Fim_Registro
09 Variveis
10 funcionarios : Vetor[1..50] De RegFuncionario;
11 cont, ir, ia : Inteiro;
12 aux : RegFuncionario;
13 totalTemp : Real;
14 Procedimento LerFuncionarios()
15 Incio
16 Escreva(Informe os dados dos funcionrios);
17 Para cont De 1 At 50 Passo 1 Faa
18 Escreva(Informe o nome do funcionrio + cont);
19 Leia(funcionarios[cont].nome);
20 Escreva(Informe o cargo do funcionario + cont);
21 Leia(funcionarios[cont].cargo);
22 Escreva(Informe o salrio do funcionrio + cont);
23 Leia(funcionarios[cont].salario);
24 funcionarios[cont].bonificacao := 0;
25 Fim_Para
26 Fim_Procedimento

{Ordena o vetor de funcionrios com base no cargo, para que saia orde-
nado no relatrio}
Procedimento OrdenarFuncionariosPorCargo()
27 Incio
28 Para ir De 1 At 49 Passo 1 Faa
29 Para ia De ir+1 At 50 Passo 1 Faa
30 Se(funcionarios[ir].cargo > funcionarios[ia].cargo) Ento
31 aux := funcionarios[ir];
32 funcionarios[ir] := funcionarios[ia];
33 funcionarios[ia] := aux;
34 Fim_Se
35 Fim_Para
36 Fim_Para
96 37 Fim_Procedimento
38
{Gera bonificao para os funcionrios, seguindo as seguintes regras:
Sub-rotinas

- Vendedor: 10% sobre o salrio


- Caixa: 5% sobre o salrio
- Demais cargos: No h bonificao}
Procedimento GerarBonificacao()
39 Incio
40 Para cont De 1 At 50 Passo 1 Faa
41 Se(Funcionarios[cont].cargo = Vendedor) Ento
42 Funcionarios[cont].bonificacao :=
43 Funcionarios[cont].salario * 0,1;
Seno
44 Se(Funcionarios[cont].cargo = Caixa) Ento
45 Funcionarios[cont].bonificacao :=
46 Funcionarios[cont].salario * 0,05;
47 Fim_Se
48 Fim_Se
49 Fim_Para
50 Fim_Procedimento
51 Procedimento GerarRelatorioHonorarios()
52 Incio
53 OrdenarFuncionariosPorCargo(); {solicita a ordenao do vetor}
54 Para cont De 1 At 50 Passo 1 Faa
55 Imprima(- - - - - - - - - - - - - - - - - - - - - -);
56 Imprima(Funcionrio: + funcionario[cont].nome);
57 Imprima(Cargo: + funcionario[cont].cargo);
58 Imprima(Salrio: + funcionario[cont].salario);
59 Imprima(Bonificao: + funcionario[cont].bonificacao);
60 totalTemp := funcionario[cont].salario +
funcionario[cont].bonificacao;
61 Imprima(Total a Receber: + totalTemp);
62 Fim_Para
63 Imprima(- - - - - - - - - - - - - - - - - - - - - -);
64 Escreva(O Relatrio de Honorrios foi enviado
para a impressora);
65 Fim_Procedimento

66 Incio
67 LerFuncionarios();
68 GerarBonificacao();
69 GerarRelatorioHonorarios();
70 Escreva(Fim de execuo);
71 Fim
97

Sub-rotinas
Neste exemplo, utilizamos vrios dos recursos que estudamos at o momento:
Para armazenar os dados dos funcionrios, foi utilizado um vetor de registros, decla-
rado na linha 10, utilizando a definio de registro realizada entre as linhas 3 e 8.
Entre as linhas 14 e 26, foi declarado o procedimento responsvel por realizar a leitura
dos dados dos funcionrios.
A ordenao do vetor foi implementada em um procedimento declarado entre as linhas
27 e 38, o qual posteriormente chamado a partir de outro procedimento.
Foi criado um procedimento para realizar o clculo da bonificao dos funcionrios
(linhas 39 a 50), considerando algumas regras comentadas no prprio algoritmo. Veja
que a insero de comentrios nos algoritmos ajuda a esclarecer as chamadas regras
de negcio, ou seja, aquelas regras que so consideradas na implementao do algo-
ritmo para atender s necessidades dos usurios do sistema. Muitas vezes, estas regras
no sero claras para quem estiver lendo um algoritmo escrito por outra pessoa, por
isso os comentrios so importantes nestes casos. Lembre, uma regra que bvia para
voc pode no ser para outra pessoa.
Entre as linhas 51 e 65, encontra-se a declarao do procedimento responsvel por
gerar um relatrio de honorrios dos funcionrios. este procedimento que chama o
procedimento de ordenao, antes de imprimir os dados. A chamada ao procedimento
de ordenao poderia ser feita no corpo principal do algoritmo, antes da chamada ao
procedimento que gera o relatrio, mas como a ordenao interessa ao relatrio (pode-
mos considerar uma sub-tarefa do relatrio) fica mais lgico solicitar a ordenao do
relatrio a partir deste ponto.

Funes
Assim como os procedimentos, as funes so sub-rotinas comumente utilizadas para
encapsular a execuo de uma determinada atividade. A diferena bsica entre as funes e os proce-
dimentos que as funes sempre retornam um valor ao final de sua execuo. Este valor retornado
pode ser utilizado em uma atribuio ou, ento, enviado para a tela ou para a impressora.
O padro de declarao de funes em pseudocdigo segue a seguinte sintaxe:

Funo <nome da funo>() : <tipo de dado retornado>


Incio
<comandos>
<nome da funo> := <valor de retorno>;
Fim_Funo

98
No pseudocdigo, as convenes de nomenclatura adotadas para as funes so as mes-
mas utilizadas para os procedimentos.
Sub-rotinas

Vejamos um exemplo de algoritmo utilizando funo:

{Exemplo de funo}
01 Algoritmo ExemploFuncao
02 Variveis
03 valorVenda, valorComissao : Real;

{Retorna um valor de comisso referente ao valor da venda.


Regras: 5% para vendas >= 500 e 7,5% para vendas < 500}
04 Funo CalcularComissao() : Real
05 Incio
06 Se(valorVenda >= 500) Ento
07 CalcularComissao := valorVenda * 0,05;
08 Seno
09 CalcularComissao := valorVenda * 0,075;
10 Fim_Se
11 Fim_Funo
12 Incio
13 valorVenda := 0;
14 Escreva(Clculo de comisso sobre venda);
15 Repita
16 Escreva(Digite o valor da venda ou 0 para sair: );
17 Leia(valorVenda);
18 valorComissao := CalcularComissao();
19 Escreva(O valor da comisso : + valorComissao);
20 At_Que(valorVenda = 0)
21 Escreva(Fim de execuo);
22 Fim

Entre as linhas 4 e 11, declarada uma funo responsvel por calcular o valor da comis-
so sobre a venda informada. A funo chamada na linha 18, sendo o seu valor de retorno
atribudo varivel valorComissao.
Ao contrrio dos procedimentos, cuja chamada s pode ser realizada isoladamente (em
uma linha exclusiva), as funes tambm podem ser chamadas dentro de expresses, comandos
ou chamadas a outras funes.
As funes tambm trazem a vantagem de reduzir o nmero de variveis necessrias ao
longo do algoritmo. Por exemplo, no algoritmo acima, as linhas 18 e 19 poderiam ser substi-
tudas pela linha abaixo, reduzindo o tamanho do algoritmo e evitando a criao da varivel
valorComissao:

Escreva(O valor da comisso : + CalcularComissao()); 99

Sub-rotinas
Mas ateno! Nem sempre economizar no nmero de variveis
vale a pena. Caso seja necessrio utilizar o valor retornado pela funo
em outros pontos do algoritmo, provavelmente ser mais vantajoso,
em termos de economia de recursos, manter a varivel na memria,
do que executar vrias vezes a funo.

Na hora de definir a implementao de um algoritmo, procure levar em considerao


outras possveis solues para o problema. Utilize sempre o bom senso, pense sobre as conse-
quncias resultantes de cada uma das suas opes de implementao.
Nos fluxogramas, as funes so representadas utilizando-se os seguintes padres:
Do mesmo modo que ocorre com um procedimento, a declarao de uma funo
representada em outro fluxograma, que deve estar anexo ao principal.
Nos fluxogramas que representam funes, no lugar das instrues Incio e Fim,
utiliza-se Funo <Nome do Procedimento> e Fim Funo, mantendo-se o uso
da figura Terminador em ambos os casos.
A representao de chamada a uma funo no realizada por meio de uma figura espec-
fica, sendo que a representao depende da forma como o retorno da funo utilizado.
Quando o retorno atribudo a uma varivel, utiliza-se a figura Processamento; j
quando o resultado enviado para a tela, utiliza-se a figura Vdeo; e assim por diante,
sempre com a chamada funo aparecendo dentro da figura. Exemplo:
...
...

maiorNota := PesquisarMaiorNota() A mdia geral da turma :


<CalcularMediaGeral()>

...
...

Vejamos outro exemplo de algoritmo utilizando funes:

{Exemplo funes 2}
01 Algoritmo ExemploFuncoes2
02 Tipos
03 RegAluno : Registro
04 nome : Caractere;
05 nota1, nota2, media : Real;
06 Fim_Registro
07 Variveis
100 08 alunos : Vetor[1..40] De RegAluno;
09 notasTemp : Real;
10 cont, qtdeAprovados : Inteiro;
Sub-rotinas

11 Procedimento LerAlunos()
12 Incio
13 Escreva(Informe os dados dos alunos);
14 Para cont De 1 At 40 Passo 1 Faa
15 Escreva(Informe o nome do aluno + cont);
16 Leia(alunos[cont].nome);
17 Escreva(Informe a nota 1:);
18 Leia(alunos[cont].nota1);
19 Escreva(Informe a nota 2:);
20 Leia(alunos[cont].nota2);
21 alunos[cont].media :=
(alunos[cont].nota1 + alunos[cont].nota2) / 2;
22 Fim_Para
23 Fim_Procedimento
24 Funo CalcularMediaGeral() : Real
25 Incio
26 notasTemp := 0;
27 Para cont De 1 At 40 Passo 1 Faa
28 notasTemp := notasTemp + alunos[cont].media
29 Fim_Para
30 CalcularMediaGeral := notasTemp / 40;
31 Fim_Funo

32 Funo ContarAprovados() : Real


33 Incio
34 qtdeAprovados := 0;
35 Para cont De 1 At 40 Passo 1 Faa
36 Se(alunos[cont].media >= 7) Ento
37 qtdeAprovados := qtdeAprovados + 1
38 Fim_Se
39 Fim_Para
40 ContarAprovados := qtdeAprovados;
41 Fim_Funo

42 Incio
43 LerAlunos();
44 Escreva(A mdia geral da turma : CalcularMediaGeral());
45 Escreva(A quantidade de alunos aprovados na turma :
+ ContarAprovados());
46 Fim

101

O exemplo acima utiliza um vetor de registros para armazenar os dados dos alunos de

Sub-rotinas
uma turma. Os dados so lidos por um procedimento (declarado entre as linhas 11 e 23), pois
no h necessidade de um valor de retorno. Entre as linhas 24 e 31, foi declarada uma funo
responsvel por calcular a mdia geral da turma, sendo esta funo chamada na linha 44, de
modo a enviar o valor de retorno diretamente para a tela. Entre as linhas 32 e 41, foi declarada
uma funo capaz de contar a quantidade de alunos aprovados. Esta funo, por sua vez, cha-
mada na linha 45, onde o valor de retorno tambm enviado para a tela.

Escopo de Variveis
O escopo de uma varivel diz respeito rea do programa cuja varivel ir existir. a
definio de sua criao e visibilidade dentro do programa.
Quanto ao escopo, as variveis se dividem em: Variveis Globais e Variveis Locais.

Variveis Globais
As variveis utilizadas nos exemplos anteriores foram declaradas no nvel do algoritmo
(ou no nvel do programa) e, por isso, so chamadas de variveis globais. Elas esto acessveis
em qualquer ponto do algoritmo, e dentro de todas as sub-rotinas. Alm disso, so criadas no
incio da execuo do algoritmo e s sero destrudas quando o algoritmo for finalizado.
Perceba que no exemplo anterior as funes CalcularMedia e ContarAprovados uti-
lizaram as variveis notasTemp e qtdeAprovados, ambas declaradas no escopo do algoritmo,
ou seja, variveis globais.
Em muitos casos, porm, no interessante que isso ocorra. Quando uma varivel inte-
ressa apenas execuo de uma determinada sub-rotina, o melhor declar-la como uma
varivel local.

Variveis Locais
Como as sub-rotinas possuem uma estrutura prpria, independente do corpo principal
do algoritmo, possvel declarar variveis pertencentes apenas a esta estrutura. Estas variveis
recebem o nome de Variveis Locais, pelo fato de s existirem dentro da sub-rotina onde
forem declaradas.
Ao contrrio do que acontece com uma varivel global, uma varivel local s acessvel
dentro da sub-rotina onde ela foi declarada.
Veja o exemplo:

{Exemplo de variveis locais x globais}


01 Algoritmo ExemploEscopoVar
02 Variveis
03 valorA, valorB : Inteiro;

04 Funo EscreverVarLocal() : Inteiro


102 05 Variveis
06 valorB, valorC : Inteiro;
07 Incio
Sub-rotinas

08 valorB := ValorA * 2;
09 Escreva(valorB);
10 valorC := 7;
11 Fim_Funo

12 Incio
13 valorA := 5;
14 valorB := 3;
15 Escreva(valorB) {escreve 3}
16 Escreva(EscreverVarLocal); {escreve 10}
17 Escreva(valorB) {escreve 3}
18 Escreva(valorC) {gerar um erro, por valorC no existe aqui}
19 Fim

O bloco padro de declarao de variveis a que estamos acostumados aquele em que


so declaradas as variveis globais. A declarao de variveis locais feita dentro da sub-rotina a
que elas estaro subordinadas, conforme as linhas 5 e 6 do exemplo acima.
Veja que, no bloco de declarao de variveis globais, so decla-
radas as variveis valorA e valorB, enquanto que, dentro da funo
EscreverVarLocal, so declaradas as variveis valorB e valorC. Ento:
valorA est disponvel em qualquer lugar do algoritmo;
valorB global estar disponvel em qualquer lugar do algoritmo,
exceto na funo EscreverVarLocal, pois nesta existe uma varivel
local com o mesmo nome;
valorB local estar disponvel apenas dentro da funo
EscreverVarLocal;
valorC estar disponvel apenas dentro da funo
EscreverVarLocal;
Quando no corpo principal do algoritmo, escrevemos na tela o valor
da varivel valorB, acessamos a varivel valorB global (linhas 15 e 17).
Entretanto, quando dentro da funo EscreveVarLocal, atribumos e escreve-
mos a varivel valorB, estamos acessando a varivel valorB local (linhas 8 e 9).
Alm disso, o comando da linha 18 gerar um erro, pois a varivel valorC s
existe dentro do escopo da funo EscreveVarLocal.
A utilizao de variveis locais pode trazer vrios benefcios, entre eles
o de reduzir o nmero de variveis globais, tornando o programa mais limpo.
Alm disso, em termos de manuteno bastante desagradvel ter que ficar
pesquisando onde uma varivel global utilizada antes de ter certeza de que
se pode alter-la sem comprometer o funcionamento do programa. Quando 103
as variveis que so utilizadas de forma temporria para a execuo de uma
sub-rotina so declaradas dentro de sua estrutura, tudo fica mais fcil de

Sub-rotinas
entender e de fazer manuteno.

uma boa prtica evitar a declarao de variveis


globais que so utilizadas apenas por uma sub-rotina.
O ideal definir como globais apenas as variveis que
sejam teis ao longo da execuo do algoritmo.

Outra vantagem relacionada ao uso de variveis locais a melhoria


do gerenciamento de memria, pois as variveis locais so criadas apenas
quando a execuo da sub-rotina iniciada, e so destrudas ao trmino de
sua execuo.
Vejamos uma nova verso do algoritmo apresentado anteriormente
como exemplo, agora fazendo uso de variveis locais dentro das sub-rotinas:
{Exemplo funes com variveis locais}
01 Algoritmo ExemploVarLocais
02 Tipos
03 RegAluno : Registro
04 nome : Caractere;
05 nota1, nota2, media : Real;
06 Fim_Registro
07 Variveis
08 alunos : Vetor[1..40] De RegAluno;

09 Procedimento LerAlunos()
10 Variveis
11 cont : Inteiro;
12 Incio
13 Escreva(Informe os dados dos alunos);
14 Para cont De 1 At 40 Passo 1 Faa
15 Escreva(Informe o nome do aluno + cont);
16 Leia(alunos[cont].nome);
17 Escreva(Informe a nota 1:);
18 Leia(alunos[cont].nota1);
19 Escreva(Informe a nota 2:);
20 Leia(alunos[cont].nota2);
21 alunos[cont].media :=
22 (alunos[cont].nota1 + alunos[cont].nota2) / 2;
23 Fim_Para
104
24 Fim_Procedimento

25 Funo CalcularMediaGeral() : Real


Sub-rotinas

26 Variveis
27 notasTemp : Real;
28 cont : Inteiro;
29 Incio
30 notasTemp := 0;
31 Para cont De 1 At 40 Passo 1 Faa
32 notasTemp := notasTemp + alunos[cont].media
33 Fim_Para
34 CalcularMediaGeral := notasTemp / 40;
35 Fim_Funo
36 Funo ContarAprovados() : Real
37 Variveis
38 cont, qtdeAprovados : Inteiro;
39 Incio
40 qtdeAprovados := 0;
41 Para cont De 1 At 40 Passo 1 Faa
42 Se(alunos[cont].media >= 7) Ento
43 qtdeAprovados := qtdeAprovados + 1
44 Fim_Se
45 Fim_Para
46 ContarAprovados := qtdeAprovados;
47 Fim_Funo

48 Incio
49 LerAlunos();
50 Escreva(A mdia geral da turma : CalcularMediaGeral());
51 Escreva(A quantidade de alunos aprovados na turma :
+ ContarAprovados());
52 Fim

Note que em cada sub-rotina, antes do comando Incio, foi adicionado o bloco Variveis,
contendo as variveis utilizadas pela sub-rotina. O vetor alunos continua sendo declarado com
o escopo global, pois utilizado ao longo do algoritmo.
105
Perceba que as trs sub-rotinas do algoritmo utilizam uma varivel contador (cont) para
percorrer o vetor, porm, ainda assim, optou-se por declarar uma varivel cont local dentro de

Sub-rotinas
cada sub-rotina, a declarar a varivel como global. Isso parece fazer mais sentido, porque torna
a sub-rotina mais independente, ao mesmo tempo em que previne possveis erros.

Consideraes sobre o Uso de


Sub-rotinas
A utilizao de sub-rotinas ajuda a diminuir a complexidade do algoritmo, pois com a
criao de procedimentos/funes responsveis por determinadas atividades, o corpo principal
do algoritmo fica mais limpo e organizado.
As sub-rotinas permitem evitar a duplicao desnecessria de cdigo, visto que so imple-
mentadas apenas uma vez e podem ser utilizadas em diversos locais do algoritmo. Imagine que
em vrios pontos do algoritmo seja necessrio imprimir informaes sobre um produto. Sem
as sub-rotinas, seria necessrio reescrever o mesmo bloco de comandos em vrios lugares. Mas
se criarmos uma sub-rotina, podemos simplesmente invoc-la em qualquer local do algoritmo
quando a impresso do relatrio se fizer necessria.
Outro aspecto importante est ligado manuteno do programa. comum
os programas sofrerem mudanas ao longo do tempo, devido a vrios fatores, mas
um dos mais comuns a modificao das necessidades dos usurios do sistema.
Imaginando que nosso suposto relatrio tivesse de ser modificado, se a imple-
mentao tivesse sido feita em uma sub-rotina, a mudana para o novo formato de
relatrio seria necessria em apenas um local. Por outro lado, se a implementao
fosse repetida vrias vezes ao longo do cdigo, seria necessrio alterar todos estes
lugares para o novo formato de relatrio, sem falar na possibilidade de esquecermos
de modificar algum deles.
Uma sub-rotina no precisa necessariamente ser invocada a partir do bloco
principal do algoritmo, ela tambm pode ser chamada a partir de outra sub-rotina.
No existe um limite sobre quantos nveis de chamadas podem ser realizados, ou seja,
dentro da sub-rotina 1 podemos chamar a sub-rotina 2, que chama a sub-rotina 3, que
chama a sub-rotina 4, e assim por diante. Todavia, cabe ao bom senso do programador
evitar a construo de algoritmos demasiadamente complexos. Lembre-se de que as
sub-rotinas existem para facilitar a nossa vida, e no para complic-la.
A criao de algoritmos utilizando estruturas de controle (seleo, repetio e
sub-rotinas), d origem chamada programao estruturada.

O Uso de Parmetros
106 Muitas vezes necessrio que uma sub-rotina conhea um ou mais valores
para poder realizar o seu processamento. Com o que foi visto at agora, a forma de
se fazer isto seria criar uma varivel global, atribuir-lhe o valor desejado e acess-la
Sub-rotinas

de dentro da sub-rotina.
Embora isto funcione, geralmente no a melhor forma de resolver o pro-
blema, pois traz uma srie de desvantagens para o algoritmo.
Quando uma sub-rotina est acessando uma varivel global, ela passa a ser
dependente desta varivel. Isso significa que, se a varivel for renomeada ou remo-
vida, a sub-rotina deixar de funcionar. Ento, cada vez que uma varivel global for
modificada, poder ser necessrio modificar vrias sub-rotinas.
Outra desvantagem que os algoritmos tornam-se mais complexos de se
entender, de se encontrar problemas e de se incluir novas funcionalidades, pois,
potencialmente, qualquer sub-rotina pode estar dependente de uma varivel global,
ao mesmo tempo em que qualquer sub-rotina pode alterar o valor de uma varivel
global. Assim, no difcil imaginar que o algoritmo tende a se tornar cada vez mais
desorganizado conforme cresce de tamanho.
Alm disso, com o uso de variveis globais dentro de sub-rotinas qualquer
alterao no algoritmo tende a se tornar mais trabalhosa e complexa, o que se reflete
em maior tempo e dinheiro gastos com manuteno.
Esperamos que neste ponto voc j esteja convencido de que o acesso variveis globais
dentro de sub-rotinas no um bom negcio. Mas qual seria, ento, a melhor soluo para o
problema? O uso de parmetros.
Um parmetro uma informao passada para a sub-rotina a partir de sua chamada.
O uso de parmetros uma forma elegante e organizada de passar informaes para uma
sub-rotina, ao mesmo tempo em que a torna independente do restante do algoritmo. Com a
passagem de parmetros, fica explcito a todos os que resolverem utilizar a sub-rotina quais
so os dados de que ela necessita para funcionar. Alm disso, se uma varivel global que estiver
sendo passada como parmetro a uma sub-rotina tiver seu nome modificado, bastar informar
o novo nome na chamada sub-rotina.

De um modo geral, o ideal que as sub-rotinas recebam por


parmetro os valores de que necessitam para realizar seu processa-
mento, e que as variveis globais sejam prioritariamente acessadas no
corpo principal do algoritmo.

Existem dois modos de passar parmetros para uma sub-rotina: Por Valor ou Por
Referncia.

Passagem de Parmetro por Valor


A passagem de parmetro por valor entrega sub-rotina uma cpia da varivel passada
como parmetro, de modo que qualquer alterao no parmetro no gerar impacto na varivel
original. A passagem por valor gera uma varivel local, que recebe uma cpia do valor da vari- 107
vel passada por parmetro, mas que totalmente desvinculada desta.
Esta a forma de passagem de parmetro frequentemente utilizada.

Sub-rotinas
A declarao de sub-rotinas utilizando passagem de parmetros por valor feita da
seguinte forma:

<tipo_sub-rotina> <nome_sub-rotina> (<nome_parmetro> : <tipo_parmetro>)

Por exemplo:

Procedimento imprimeQuadrado(valor : Inteiro)


Incio
Imprime(valor * valor);
Fim_Funo

Sendo que a chamada do procedimento seria feita assim:

imprimeQuadrado(3);
Veja outro exemplo:

{Exemplo de passagem de parmetro por valor}


01 Algoritmo ConversorMoeda
02 Variveis
03 cotDolar, cotEuro, cotPeso : Real;
04 valorReal, valorDolar, valorEuro, valorPeso : Real;

05 Funo Converte(cotacao, valor : Real) : Real


06 Incio
07 Converte := valor / cotacao;
08 Fim_Funo

09 Incio
10 Escreva(Digite a cotao do dia para...);
11 Escreva(Dlar:);
12 Leia(cotDolar);
13 Escreva(Euro:);
14 Leia(cotEuro);
15 Escreva(Peso:);
16 Leia(cotPeso);

17 Repita
18 Escreva(---------------------------------);
19 Escreva(Digite o valor da compra em Real: );
20 Leia(valorReal);
108

21 Se(valorReal > 0) Ento


Sub-rotinas

22 valorDolar := Converte(cotDolar, valorReal);


23 Escreva(Valor em Dlar: + valorDolar);
24 valorEuro := Converte(cotEuro, valorReal);
25 Escreva(Valor em Euro: + valor Euro);
26 valorPeso := Converte(cotPeso, valorReal);
27 Escreva(Valor em Peso: + valorPeso);
28 Fim_Se
29 At_Que(valorReal = 0)
30 Fim

O algoritmo anterior serve para converter o valor de uma compra paga em real para dlar,
euro e peso. Veja que a funo responsvel pela converso, declarada entre as linhas 5 e 8, recebe
por valor dois parmetros do tipo real. Perceba que, como os dois parmetros so do mesmo
tipo, basta separ-los por vrgula e informar o tipo apenas uma vez.
Passagem de Parmetro por Referncia
A passagem de parmetro por referncia d sub-rotina acesso varivel original, de
modo que qualquer alterao realizada no parmetro estar sendo realizada diretamente na
varivel original, e as alteraes persistiro mesmo aps o trmino da execuo da sub-rotina.
Neste caso, o nome do parmetro definido dentro da sub-rotina atua como um apelido
ou um segundo nome que d acesso varivel.
A declarao de sub-rotinas, utilizando passagem de parmetros por referncia, feita da
seguinte forma:
<tipo_sub-rotina> <nome_sub-rotina> (Var <nome_parmetro> : <tipo_parmetro>)

Perceba que em termos de declarao, a nica diferena da passagem por referncia em


relao passagem por valor a incluso do comando Var antes do nome do parmetro.
Por exemplo:
Procedimento adicionaTaxaServico(Var valor : Inteiro)
Incio
valor := valor * 1,1;
Fim_Procedimento

Sendo que a chamada da sub-rotina seria feita da mesma forma que chamaramos uma
109
sub-rotina que estivesse recebendo o parmetro por valor:
adicionaTaxaServico(valorConta);

Sub-rotinas
Podemos dizer que a passagem por referncia uma forma bem estruturada de permitir
a uma sub-rotina alterar valores de variveis globais, evitando os desagradveis problemas que
o acesso direto a estas variveis iria trazer.
Veja outro exemplo:
{Exemplo de passagem de parmetro por referncia}
01 Algoritmo OrdenaVetor
02 Variveis
03 vetNomes : Vetor[1..50] De Caractere;

04 Procedimento LerNomes(Var nomes : Vetor De Caractere)


05 Variveis
06 cont: inteiro;
07 Incio
08 Para cont De 1 At 50 Passo 1 Faa
09 Escreva(Informe o valor + cont);
10 Leia(nomes[cont]);
11 Fim_Para
12 Fim_Procedimento

13 Procedimento OrdenarNomes(Var nomes : Vetor De Caractere)


14 Var
15 ia, ir : Inteiro;
16 aux : Caractere;
17 Incio
18 Para ir De 1 At 49 Passo 1 Faa
19 Para ia De ir+1 At 50 Passo 1 Faa
20 Se(nomes[ir] > nomes[ia]) Ento
21 aux := nomes[ir];
22 nomes[ir] := nomes[ia];
23 nomes[ia] := aux;
24 Fim_Se
25 Fim_Para
26 Fim_Para
27 Fim_Procedimento

28 Procedimento ImprimirNomes(nomes : Vetor De Caractere)


29 Variveis
30 cont: Inteiro;
31 Incio
32 Para cont De 1 At 50 Passo 1 Faa
33 Imprima(nomes[cont]);
34 Fim_Para
35 Fim_Procedimento
110
36 Incio
37 LerNomes(vetNomes);
Sub-rotinas

38 OrdenarNomes(vetNomes);
39 ImprimirNomes(vetNomes);
40 Fim

O algoritmo anterior l 50 nomes e os imprime em ordem alfabtica. Veja que tanto a


sub-rotina LerNomes (linhas 4 a 12), quanto a sub-rotina OrdenarNomes (linhas 13 a 27)
recebem como parmetro um vetor do tipo Caractere. Como ambas necessitam modificar o
contedo do vetor, a passagem de parmetro foi feita por referncia. Por outro lado, como a
sub-rotina ImprimirNomes (linhas 28 a 35) ir apenas ler o contedo do vetor, a passagem do
parmetro foi feita por valor.
Perceba, tambm, que quando um vetor passado por parmetro no se deve informar
seu tamanho, mas apenas seu tipo.

Consideraes sobre o Uso de Parmetros


Os nomes utilizados nos parmetros dentro das sub-rotinas podem ser iguais ou diferen-
tes dos nomes das variveis passadas por parmetro no momento da chamada da sub-rotina.
No existe uma regra quanto a isto, mas o ideal que os nomes definidos dentro das
sub-rotinas no sejam iguais aos de variveis globais, para explicitar que estas no esto sendo
utilizadas dentro da sub-rotina.
Na passagem por valor, podemos utilizar como parmetro, na chamada da sub-rotina,
variveis, constantes ou valores fixos (um nmero, por exemplo). J na passagem por refern-
cia, no possvel (e nem faria sentido) passar como parmetro nada alm de variveis.
Tambm no podemos deixar de citar que possvel utilizar a passagem de parmetro por
valor e por referncia em uma mesma sub-rotina.
Veja um exemplo:

{Exemplo de passagem de parmetro por valor e referncia na


mesma sub-rotina}
01 Algoritmo EnqueteCopa
02 Tipos
03 RegSelecao : Registro
04 nome : Caractere;
05 inicial : Caractere;
06 votos : Inteiro;
07 Fim_Registro
08 Variveis
09 vetSelecoes : Vetor[1..3] De RegSelecao;
10 opcao : Caractere;

11 Procedimento Votar(Var vetSel : Vetor De RegSelecao; voto : Inteiro)


12 Incio
111
13 vetSel[voto].votos := vetSel[voto].votos + 1;
14 Escreva(Voto computado para: + vetSel[voto].nome);

Sub-rotinas
15 Fim

16 Procedimento EmitirResultado(vetSel : Vetor De RegSelecao)


17 Var
18 cont : Inteiro;
19 Incio
20 Para cont De 1 At 3 Passo 1 Faa
21 Escreva(------------);
22 Escreva(Seleo: + vetSel[cont].nome);
23 Escreva(Votos: + vetSel[cont].votos);
24 Fim_Para
25 Fim_Procedimento

26 Procedimento Menu()
27 Incio
28 Escreva(Que seleo ficar melhor colocada na prxima copa?);
29 Escreva(( 1 = Argentina | 2 = Brasil | 3 = Paraguai | 0 = Fim ));
30 Fim
31 Procedimento InicializarSelecoes(Var vetSel : Vetor de RegSelecao);
32 Incio
33 vetSel[1].nome := Argentina;
34 vetSel[1].votos := 0;
35 vetSel[2].nome := Brasil;
36 vetSel[2].votos := 0;
37 vetSel[3].nome := Paraguai;
38 vetSel[3].votos := 0;
39 Fim

40 Incio
41 Repita
42 Menu();
43 Leia(opcao);
44 Se((opcao >= 1) .E. (opcao <= 3)) Ento
45 Votar(vetSelecoes, opcao);
46 Seno
47 Se(opcao <> 0) Ento
48 Escreva(Voto invlido.);
49 Fim_Se
50 Fim_Se
51 At_Que(opcao = 0)
52 Escreva(Fim da Votao);
53 EmitirResultado(vetSelecoes);
54 Fim

112
O algoritmo acima permite a realizao de uma enquete, computando votos at que seja
informado o valor 0 (zero) para sair, quando, ento, exibido o resultado da votao.
Sub-rotinas

Perceba que o procedimento Votar (linhas 11 a 15) recebe como parmetro o vetor
contendo o resultado parcial da votao e tambm a opo escolhida no voto atual. Como
necessrio que o procedimento modifique o vetor, a passagem foi feita por referncia. J a opo
de voto, que apenas lida, foi passada por valor. Note que, para separar parmetros de tipos
diferentes, utilizamos o ponto e vrgula (;).

Atividades
Todos os exerccios a seguir devem ser implementados em
pseudocdigo. Utilize sub-rotinas na resoluo dos exerc-
cios e atente-se para a melhor opo de escopo para cada
varivel.

1) Crie um algoritmo que calcule XY (X elevado a Y), sendo que os


valores de X e Y devem ser nmeros inteiros, positivos, infor-
mados pelo usurio. O resultado deve ser exibido na tela.
2) Construa um algoritmo que permita a consulta ao acervo de
uma biblioteca. Para isso, o sistema deve:
a. Ler os dados de 500 livros (cdigo, ttulo, autor, ano, estante e
prateleira).
b. Entrar no modo consulta, onde o livro pesquisado pelo ttulo,
sendo exibidas na tela todas as informaes sobre a obra. Se
o nome pesquisado for vazio, o programa encerra.

3) Crie um algoritmo que seja capaz de realizar as seguintes


atividades:
a. Ler os dados de uma turma de 40 alunos.
b. Calcular as mdias de todos os alunos.
c. Gerar um relatrio na impressora com os alunos aprovados
(mdia >= 7), listados em ordem alfabtica.
d. Gerar um relatrio na impressora com os alunos em exame
(mdia >= 4 e < 7), listados em ordem alfabtica.
e. Gerar um relatrio na impressora com os alunos reprovados
(mdia < 4), listados em ordem alfabtica.
f. Exibir na tela a maior e a menor mdia da turma, bem como a
mdia geral.
113
4) Desenvolva um algoritmo para gerar uma lista de preos para
uso dos vendedores de uma loja X. Seu algoritmo dever con-

Sub-rotinas
templar as seguintes funcionalidades:
a. A lista de produtos poder ter at 100 itens. Caso seja informado
um produto com cdigo 0 (zero) antes de se chegar aos 100
itens, o programa dever entender que os itens acabaram.
b. Para cada produto, deve-se solicitar cdigo, nome e preo de
custo.
c. Devem-se calcular os preos de venda conforme as regras a
seguir:
Venda vista: 20% de margem de lucro;
Venda com pagamento em 30 dias: 25% de margem de
lucro;
Pagamento em 3x: 30% de margem de lucro.
d. A lista de preos dever ser impressa e conter o nome e as trs
opes de preo de venda de todos os produtos, ordenados
pelo cdigo.
Nos exerccios a seguir, atente para a melhor opo de passa-
gem de parmetro para cada caso.

5) Crie um algoritmo que leia um nmero de 1 a 12 e retorne o


nome do ms correspondente.

6) Desenvolva um algoritmo que contabilize a quantidade de


vagas existentes em uma escola e a quantidade de alunos
matriculados. Para isso, o programa dever realizar as seguintes
atividades:
a. Para cada turma, solicitar as seguintes informaes: nmero
da turma, capacidade mxima, quantidade de matriculados.
b. A capacidade mxima que o programa deve considerar de
100 turmas. Dever ser possvel indicar o trmino das turmas,
informando o valor 0 (zero) no cdigo da turma.
c. Ao final, o programa dever imprimir uma relao de todas as
turmas, com sua capacidade mxima e sua capacidade ocu-
pada. Alm disso, dever imprimir a quantidade total de vagas
que a escola disponibiliza, bem como a quantidade total de
alunos matriculados no momento.

7) Crie um algoritmo que simule uma calculadora, permitindo o


uso das quatro operaes bsicas (multiplicao, diviso, adi-
114
o e subtrao). O funcionamento do programa dever ser o
seguinte:
Sub-rotinas

a. L o primeiro valor.
b. L a operao desejada pelo usurio.
c. L o segundo valor.
d. Apresenta o resultado do clculo e encerra o programa.

8) Crie um algoritmo que permita manter um cadastro de cidades,


com as seguintes funcionalidades:
a. O limite de cidade cadastradas deve ser de 100.
b. Para cada cidade necessrio cadastrar: nome, estado, quan-
tidade de habitantes, PIB e DDD.
c. A qualquer momento deve ser possvel escolher entre cadas-
trar uma nova cidade ou pesquisar uma cidade existente. Para
isso, deve ser exibido um menu ao usurio.
d. A pesquisa de cidades dever ser feita por nome.
e. Deve haver uma opo no menu para sair do programa.
10
9

Introduo Programao
At este ponto, ns aprofundamos nossos estudos no aprendizado da lgica de pro-
gramao. Embora os caminhos para o aprendizado da programao sejam muitos, estamos
convencidos de que este o ponto de partida ideal para a formao de um bom profissional da
rea de desenvolvimento de software. Porm, este apenas o primeiro passo.
Alm de conhecer a lgica de programao, o desenvolvedor Frameworks: 115
precisa aprender uma linguagem de programao, conhecer um um conjunto de objetos que
colaboram para realizar um conjunto
ambiente de desenvolvimento e, por fim, os frameworks e biblio- de responsabilidades para um domnio

Introduo Programao
tecas relacionados tecnologia escolhida (caso existam). de aplicaes de subsistemas.

O escopo deste livro se resume lgica de programao e a uma introduo linguagem


Pascal, que uma linguagem acadmica, simples, porm completa o suficiente para servir como um
excelente ponto de partida para que se aprendam outras linguagens, mais focadas ao mercado.
Entretanto, antes de iniciarmos o trabalho com a linguagem Pascal, importante que voc
compreenda mais alguns conceitos.

Linguagem de Mquina
A linguagem de mquina, tambm chamada de linguagem binria, a nica linguagem
que o computador entende. Em outras palavras, o computador somente consegue interpretar
e executar instrues que estejam escritas nesta linguagem. Ento, qualquer software, para ser
executado, precisa, obrigatoriamente, ser convertido em linguagem de mquina.
A maneira como esta converso de cdigo fonte em linguagem de mquina ser feita,
depender da linguagem de programao em que o programa foi escrito.
Linguagem de Programao
As linguagens de programao so utilizadas para descrever algorit-
mos, de modo que os comandos que compem esses algoritmos possam ser
posteriormente convertidos em linguagem de mquina.
Cada linguagem possui seu prprio conjunto de comandos e padres,
mas muitos deles so parecidos ou, at mesmo, idnticos entre as diferentes
linguagens. O mais importante que a lgica de programao, quando apren-
dida, pode ser aplicada a qualquer linguagem.
As linguagens de programao evitam que os programadores tenham
que escrever seus programas em linguagem de mquina, o que seria muito
mais trabalhoso, lento e complexo. Na verdade, no conseguiramos ter che-
gado ao nvel de complexidade nos softwares que temos hoje, se tivssemos que
trabalhar somente com a linguagem de mquina.
Existem basicamente dois tipos de linguagens de programao: as com-
piladas e as interpretadas.

Linguagens Compiladas
As linguagens de programao compiladas so aquelas que se uti-
lizam de um programa chamado Compilador para converter o cdigo fonte
em linguagem de mquina. De forma simples, podemos dizer que os com-
piladores atuam como tradutores, que leem os comandos escritos em uma
determinada linguagem de programao e os escrevem em linguagem de
116 mquina.
Neste processo, o cdigo convertido fica gravado na forma de um pro-
grama executvel (armazenado em um ou mais arquivos). Um programa
Introduo Programao

compilado, portanto, pode ser executado inmeras vezes sem que seja neces-
srio realizar novamente o processo de compilao.
O Pascal uma linguagem de programao compilada.

Linguagens Interpretadas
Nas linguagens interpretadas, no existe a criao de um programa exe-
cutvel como ocorre nas linguagens compiladas.
Nestas linguagens, os programas so diretamente executados pelos
interpretadores, que vo convertendo os comandos de cdigo fonte em lin-
guagem de mquina, medida em que o programa executado.
Como no gerado um programa executvel gravado em disco, a exe-
cuo do programa feita sempre pelo interpretador.
Cada tipo de linguagem tem suas vantagens e desvantagens e o aprofun-
damento desta questo foge ao escopo deste livro. A seu tempo, voc saber
escolher a melhor opo para cada caso.
Atividades
1) Pesquise pelo menos trs linguagens de programao compi-
ladas e descreva em que tipo de solues elas geralmente so
utilizadas.

2) Pesquise pelo menos trs linguagens de programao inter-


pretadas e descreva em que tipo de solues elas geralmente
so utilizadas.

3) Pesquise as principais vantagens e desvantagens das lingua-


gens de programao compiladas.

4) Pesquise as principais vantagens e desvantagens das lingua-


gens de programao interpretadas.

5) Descubra quais so as linguagens de programao mais utili-


zadas atualmente no mercado de desenvolvimento de software,
e pesquise quais so as principais caractersticas destas
linguagens.

6) Pesquise o que uma IDE e quais so as suas contribuies


para melhorar a vida do programador. Alm disso, descubra 117
quais as IDEs mais utilizadas atualmente e com que lingua-
gens elas so utilizadas.

Introduo Programao
7) Descubra se pode haver diferena no salrio de um programa-
dor dependendo do tipo de linguagem de programao com
que ele trabalha. Caso positivo, reflita sobre os motivos desta
diferena, e levante quais as tecnologias de desenvolvimento
de software mais valorizadas atualmente pelo mercado.

8) Pesquise quais as tecnologias mais utilizadas pelas empresas


de desenvolvimento de software da cidade em que voc vive.
010
1

Linguagem Pascal
Fundamentos
Iniciaremos agora o estudo da linguagem de programao Pascal. Nossa abordagem no
ser profunda a ponto de explicitar todos os recursos da linguagem, pois o intuito apresentar
apenas os recursos equivalentes ao contedo estudado ao longo do livro, para que voc possa
transformar seus algoritmos em programas executveis.
O Pascal uma linguagem de programao de grande adoo no mundo acadmico, espe-
118 cialmente por ser muito bem estruturada e permitir o aprendizado de todos os fundamentos
necessrios ao iniciante no mundo da programao. Favorece o aprendizado da lgica de pro-
gramao, bem como a adoo de boas prticas de desenvolvimento de software, permitindo a
Linguagem Pascal

criao de programas com cdigos simples e de fcil compreenso.


Considere que o aprendizado da linguagem Pascal serve, antes de tudo, para a compre-
enso de fundamentos, o que mais importante do que o aprendizado da linguagem em si.
Linguagens de programao existem inmeras, mas os fundamentos da lgica de programao
se aplicam a praticamente todas elas. Uma vez que o estudante tenha compreendido estes fun-
damentos, ele estar mais preparado para aprender e produzir de forma satisfatria em qualquer
tecnologia de desenvolvimento de software.
importante ter em mente que, na grande maioria dos casos, um programador no
utilizar apenas uma ou duas linguagens ao longo de sua vida profissional. As tecnologias
mudam rpido, e quem quiser ser valorizado no mercado tem de se atualizar e estar sempre
aprendendo. Por isso, os fundamentos so to importantes, eles permitem que a pessoa tenha
mais facilidade em aprender outras linguagens e tecnologias por conta prpria, medida que
isso se fizer necessrio. Nem sempre haver um professor ao seu lado, pense nisso!
Para que voc possa comear a programar com mais facilidade, o Apndice 2 traz um
guia para configurao de um ambiente de estudo de programao com Pascal, abordando os
sistemas Windows e Linux.
Estrutura de um Programa Pascal
A estrutura bsica de um programa Pascal segue o mesmo padro que estudamos no
pseudocdigo. Na verdade, durante nosso estudo utilizando pseudocdigo, ns adotamos pro-
positalmente vrios dos padres utilizados pela linguagem Pascal, sendo que muitos tambm
so adotados por outras linguagens.
A estrutura de um programa Pascal a seguinte:
1. Cabealho contendo o nome do programa;
2. Importao de bibliotecas;
3. Declarao de constantes;
4. Declarao de tipos;
5. Declarao de variveis;
6. Declarao de sub-rotinas;
7. Corpo principal do programa.
Embora alguns dos blocos de declarao possam ter sua posio trocada, esta a sequncia
indicada para evitar erros que podem ocorrer em algumas situaes.

Tipos de Dados
Os tipos de dados do Pascal equivalentes aos que estudamos no pseudocdigo so:

Tipo de dado no Pascal Equivalncia no Pseudocdigo 119


Integer Inteiro
Real Real

Linguagem Pascal
Boolean Lgico
String Caractere
*Existem outros tipos de dados no Pascal que no sero abordados neste contexto.

Declarao de Variveis e Constantes


No Pascal, a declarao de variveis segue o mesmo padro estudado no pseudocdigo,
porm o nome do bloco de declaraes, ao invs de Variveis denominado var. O mesmo
ocorre com as constantes, que, ao invs de Constantes, o Pascal adota a denominao const
para o bloco de declarao.
O Pascal no uma linguagem case sensitive, ou seja, no diferencia maisculas de mins-
culas. Ento possvel declarar uma varivel chamada valor e acess-la utilizando Valor, por
exemplo. Mesmo assim, recomenda-se adotar o mesmo padro de nomenclatura utilizado no
pseudocdigo.
Tambm possvel escrever os comandos da linguagem em maisculas ou minsculas,
porm para uma melhor legibilidade do cdigo, interessante que utilizem-se sempre letras
minsculas ou, ento, maisculas apenas na primeira letra do comando. Nos exemplos apre-
sentados, utilizaremos sempre letras minsculas para nomear os comandos.
Operadores
Operadores Aritmticos
A nica diferena em relao ao que vimos no pseudocdigo que em Pascal no h um
operador de potenciao. Esta feita a partir de funes predefinidas no Pascal.
Precedncia Operador Descrio
1 * Multiplicao
1 / Diviso
2 + Adio
2 - Subtrao

Operadores Relacionais
No Pascal, os operadores relacionais so exatamente iguais ao que estudamos no
pseudocdigo:
Operador Descrio
= Igual
<> Diferente
< Menor
<= Menor ou Igual
> Maior
>= Maior ou Igual
120

Operadores Lgicos
Linguagem Pascal

No Pascal, os operadores lgicos so representados da seguinte forma:


Precedncia Pascal Pseudocdigo
1 NOT .NO.
2 AND .E.
3 OR .OU.

Operador Literal
No Pascal, o operador literal, utilizado na concatenao de strings, no converte o valor
direita para string, caso ele seja de outro tipo. A linguagem oferece funes de converso para
atender a esta demanda.
Operador Descrio
+ Concatenao
Estruturas de Seleo
No pseudocdigo, representamos as estruturas de seleo por meio dos comandos
Se...Ento...Seno...Fim_Se. No Pascal, estas estruturas so representadas pelos comandos
If...Then...Else. Veja:
if(<condio>) then
begin
<instrues>
end
else
begin
<instrues>
end;

Embora no seja necessrio delimitar o bloco de comandos com begin...end quando este
for composto por apenas uma instruo, esta ao sempre recomendada, pois ajuda a manter
o cdigo legvel e a prevenir futuros erros.
Perceba que existe um ponto e vrgula aps o ltimo end.

Primeiro Exemplo em Pascal


Aps conhecer alguns dos fundamentos da linguagem Pascal, vamos ao nosso primeiro
exemplo (este o mesmo exemplo apresentado em pseudocdigo no captulo 4, que trata das
estruturas de controle de seleo): 121

01 {Primeiro programa de exemplo em Pascal}

Linguagem Pascal
02 program PrimeiroExemplo;
03 uses crt;
04 var
05 nota1, nota2, media : real;
06 nome : string[30];
07 resultado : string[10];
08
09 begin
10 clrscr;
11 writeln(Digite o nome do aluno: );
12 read(nome);
13 writeln(Digite a primeira nota: );
14 read(nota1);
15 writeln(Digite a segunda nota: );
16 read(nota2);
17
18 media := (nota1 + nota2) / 2;
19
20 if(media >= 7) then
21 begin
22 resultado := aprovado;
23 end
24 else
25 begin
26 if(media >= 4) then
27 begin
28 resultado := em exame;
29 end
30 else
31 begin
32 resultado := reprovado;
33 end
34 end;
35
36 writeln(O aluno + nome + est + resultado);
37 readkey;
38 end.

Ao invs de Incio e Fim, o Pascal utiliza begin e end para delimitar os blocos. O ltimo
end do programa, indicador do fechamento do corpo principal, deve ser seguido de um ponto
final (.).
Quando utilizamos o tipo string, importante definir o tamanho mximo de caracteres
que a varivel dever ser capaz de armazenar, conforme foi feito nas linhas 6 e 7 do exemplo.
122
possvel declarar uma varivel do tipo string sem definir o tamanho mximo, mas, deste modo,
estaremos desperdiando espao, pois o Pascal reservar o tamanho mximo permitido para
uma string, que de 255 caracteres.
Linguagem Pascal

Perceba tambm que a manipulao de valores do tipo string feita utilizando-se aspas
simples ( ) e no aspas duplas ( ) como feito no pseudocdigo.
Outra diferena est no tipo Real, cujo separador de casas decimais o ponto (.) e no a
vrgula, como estamos acostumados. No Pascal, no se utiliza separador de milhar.
O comando clrscr (linha 10) serve para limpar a tela, geralmente usado no incio do
programa. Alm disso, para que a tela do programa continue sendo exibida ao final da execuo,
necessrio incluirmos o comando readkey (linha 37) antes do fechamento do corpo prin-
cipal este comando faz com que o programa aguarde o pressionamento de uma tecla antes
de encerrar sua execuo. Para que os comandos clrscr e readkey funcionem, necessrio
importar no incio do programa a biblioteca crt, o que feito por meio do comando uses crt,
na linha 3 do exemplo.
Para ler informaes via teclado utilizamos os comandos read() ou readln(), equiva-
lentes ao comando Leia() do pseudocdigo.
No pseudocdigo, para escrever na tela utilizamos o comando Escreva(), enquanto que
no Pascal tambm existem dois comando para esta funo: write e writeLn. A diferena entre
eles, que writeLn gera uma quebra de linha aps a escrita do valor, de modo que a prxima
informao a ser escrita na tela no fique ao lado desta que est sendo escrita no momento.
Reproduzindo no Computador
Para que voc consiga reproduzir o exemplo IDE ( Integrated Development Environment):
anterior no computador, necessrio que esteja Um ambiente integrado para desenvolvimento de
com o ambiente de desenvolvimento instalado software.
(compilador + IDE).
A partir da, o primeiro passo abrir a IDE por meio do atalho criado durante a instalao
e digitar o cdigo fonte. Para salvar, pressione F2.
Todo arquivo de cdigo fonte do Pascal salvo por padro com a extenso .pas. No existe
uma regra a respeito do nome do arquivo, porm interessante utilizar o mesmo nome do programa
definido no cdigo fonte. Neste caso, nomeie seu arquivo como PrimeiroExemplo.pas.
Para compilar o programa, existem duas formas: pela linha de comando ou pela IDE.
A compilao pela IDE mais rpida e prtica. Para compilar o programa pela IDE, selecione
a opo copile do menu compile ou pressione ALT+F9. A IDE ir exibir uma janela com o
resultado da compilao.
Caso a compilao tenha ocorrido sem problema algum, a janela exibida ser parecida
com a imagem abaixo, bastando pressionar qualquer tecla para fech-la:

123

Linguagem Pascal
Caso tenha ocorrido algum erro de compilao, a janela de resultado da compilao ir
exibir a quantidade de erros ocorridos, e ser exibida uma outra janela contendo a lista de erros,
com o nmero da linha e da coluna em que eles se encontram, conforme este exemplo:
Uma vez que o programa tenha sido compilado sem erros, possvel execut-lo pela IDE
pressionando Ctrl+F9.
Tambm seria possvel rodar o programa via linha de comando ou, ainda, por um atalho,
porm, durante o processo de desenvolvimento, estas opes so menos prticas.

Estruturas de Repetio
O Pascal possui os trs tipos de repetio que estudamos no pseudocdigo: Repetio
com Pr-Teste, Repetio com Ps-Teste e Repetio com Varivel de Controle.
Nas repeties do tipo Pr-Teste e Varivel de Controle, sempre utilizaremos os demar-
cadores de bloco begin e end.

Repetio com Pr-Teste


No pseudocdigo, a repetio com Pr-Teste era representada pelo comando
Enquanto...Faa...Fim_Enquanto. No Pascal, o comando para representar esta operao
while...do. Veja um exemplo:
01 {Exemplo de repetio do tipo Pr-Teste}
02 program ExemploPreTeste;
03 uses crt;
04 var
05 contador : integer;
06 nome : string[30];
07 begin
08 clrscr;
124 09 writeln(Digite seu nome: );
10 read(nome);
11 contador := 1;
Linguagem Pascal

12
13 while(contador <= 10) do
14 begin
15 if(contador <= 5) then
16 begin
17 writeln(nome);
18 end
19 else
20 begin
21 writeln([ + nome + ]);
22 end;
23
24 contador := contador + 1;
25 end;
26
27 readkey;
28 end.
Repetio com Ps-Teste
A repetio do tipo Ps-Teste representada no pseudocdigo pelo comando
Repita...At_Que. No Pascal, este tipo de repetio representado pelo comando
repeat...until. Confira o exemplo:
01 {Exemplo de repetio do tipo Ps-Teste}
02 program ExemploPosTeste;
03 uses crt;
04 var
05 nota1, nota2, media : real;
06 resultado : string[10];
07 continuar : string[1];
08 begin
09 repeat
10 clrscr;
11 writeln(Digite a primeira nota: );
12 readln(nota1);
13 writeln(Digite a segunda nota: );
14 readln(nota2);
15
16 media := (nota1 + nota2) / 2;
17 if(media >= 7) then
18 begin
19 resultado := aprovado;
20 end
21 else
22 begin
23 if(media >= 4) then
125
24 begin
25 resultado := exame;
26 end

Linguagem Pascal
27 else
28 begin
29 resultado := reprovado;
30 end
31 end;
32
33 write(A mdia : );
34 write(media:4:2);
35 writeln( [ + resultado + ]);
36
37 repeat
38 write(Calcular outra mdia? (S/N));
39 readln(continuar);
40 continuar := UpCase(continuar);
41 until((continuar = S) or (continuar = N));
42
43 until(continuar = N);
44 writeln(Fim.);
45 readkey;
46 end.
Perceba que na linha 34, cuja mdia exibida na tela, estamos utilizando media:4:2, a
fim de formatar o valor para exibio na tela. O formato :4:2 significa que desejamos preparar o
valor para ser exibido em 4 dgitos, sendo 2 deles como frao.
Entre as linhas 37 e 41, criamos uma segunda repetio do tipo Ps-Teste, a fim de garan-
tir que o usurio informe uma das opes vlidas.
Na linha 40, utilizamos a funo UpCase para transformar para maiscula a entrada do
usurio. Esta uma das muitas funes predefinidas que o Pascal incorpora, a fim de facilitar a
vida do programador. Contudo, o estudo destas funes est fora do nosso escopo neste livro.
Se for do seu interesse, voc pode encontrar mais informaes sobre as funes predefi-
nidas do Pascal nas referncias citadas no final do livro.

Repetio com Varivel de Controle


O tipo de repetio baseado em varivel de controle representado no Pascal pelo comando
for...to...do, com uma estrutura semelhante ao comando Para...De...At...Passo, que utiliza-
mos no pseudocdigo. A principal diferena que no Pascal no necessrio informar o tamanho
do passo, sendo o incremento feito automaticamente de 1 em 1 unidade. Veja o exemplo:

01 {Exemplo de repetio do tipo varivel de controle }


02 program ExemploVarControle;
03 uses crt;
04 var
05 contador : integer;
06 tempMes, tempAnual : Real;
07 begin
126 08 clrscr;
09 writeln(Clculo de temperatura mdia anual);
10 tempAnual := 0;
Linguagem Pascal

11
12 for contador := 1 to 12 do
13 begin
14 write(Digite a temperatura mdia do ms );
15 writeln(contador);
16 read(tempMes);
17
18 if(tempMes > 35) then
19 begin
20 writeln(Que calor!);
21 end
22 else
23 begin
24 if(tempMes < 5) then
25 begin
26 writeln(Que frio!);
27 end
28 end;
29
30 tempAnual := tempAnual + tempMes;
31 end;
32
33 tempAnual := tempAnual / 12;
34 write(A temperatura mdia anual foi );
35 write(tempAnual:4:2);
36 readkey;
37 end.

Estruturas de Dados
Vetores
No Pascal, os vetores so denominados arrays unidimensionais, e sua declarao e uso so
bastante parecidos com o padro utilizado no pseudocdigo. Veja o exemplo:

01 {Exemplo de uso de vetor}


02 program ExemploVetor;
03 uses crt;
04 var
05 valores : array[1..10] of integer;
06 contador : integer;
07 begin 127
08 clrscr;
09 for contador := 1 to 10 do

Linguagem Pascal
10 begin
11 write(Digite um valor para a posio );
12 writeln(contador);
13 read(valores[contador]);
14 end;
15
16 for contador := 1 to 10 do
17 begin
18 write(O elemento da posio );
19 write(contador);
20 write( vale );
21 writeln(valores[contador]);
22 end;
23
24 readkey;
25 end.
Matrizes
As matrizes tambm so utilizadas no Pascal de forma semelhante s do pseudocdigo,
sendo denominadas, neste caso, arrays multidimensionais. Confira o exemplo:

01 {Exemplo de uso de matriz}


02 program ExemploMatriz;
03 uses crt;
04 var
05 nomeDespesas : array[1..4] of string[30];
06 valorDespesas : array[1..12, 1..4] of real;
07 i, j, ano : integer;
08 somatorio, totalAnual : real;
09 begin
10 clrscr;
11 nomeDespesas[1] := Aluguel;
12 nomeDespesas[2] := Condomnio;
13 nomeDespesas[3] := Energia Eltrica;
14 nomeDespesas[4] := Telefone e Internet;
15
16 writeln(Clculo de despesas anuais.);
17 writeln(Informe o ano: );
18 read(ano);
19
20 for i := 1 to 12 do
21 begin
128 22 for j := 1 to 4 do
23 begin
24 write(Informe o gasto com + nomeDespesas[j]
Linguagem Pascal

25 + no ms );
26 writeln(i);
27 read(valorDespesas[i, j]);
28 end
29 end;
30
31 write(Relatrio de gastos com moradia no ano de );
32 writeln(ano);
33 totalAnual := 0;
34 for i := 1 to 4 do
35 begin
36 somatorio := 0;
37 for j := 1 to 12 do
38 begin
39 somatorio := somatorio + valorDespesas[j, i];
40 end;
41
42 write(O total gasto com + nomeDespesas[i]);
43 write( ao longo do ano foi );
44 writeln(somatorio:7:2);
45 totalAnual := totalAnual + somatorio;
46 end;
47
48 write(O total gasto no ano foi );
49 writeln(totalAnual:7:2);
50 write(A mdia mensal de gastos foi );
51 writeln((totalAnual / 12):7:2);
52 readkey;
53 end.

Registros
O Pascal tambm permite a criao de registros de uma forma bastante parecida com a
que estudamos no pseudocdigo. Veja o exemplo:
01 {Exemplo de uso de registro}
02 program ExemploRegistro;
03 uses crt;
04 type
05 RegAluno = record
06 nome : string[30];
129
07 nota1 : real;
08 nota2 : real;
09 end;

Linguagem Pascal
10 var
11 alunos : array[1..40] of RegAluno;
12 mediaTemp : real;
13 cont : integer;
14 begin
15 clrscr;
16 for cont := 1 to 40 do
17 begin
18 write(Informe o nome do aluno );
19 writeln(cont);
20 readln(alunos[cont].nome);
21
22 write(Informe a nota 1 do aluno );
23 writeln(cont);
24 readln(alunos[cont].nota1);
25
26 write(Informe a nota 2 do aluno );
27 writeln(cont);
28 readln(alunos[cont].nota2);
29 end;
30
31 for cont := 1 to 40 do
32 begin
33 write(O nome do aluno );
34 write(cont);
35 writeln( , + alunos[cont].nome);
36
37 mediaTemp := (alunos[cont].nota1 + alunos[cont].nota2) / 2;
38 write(A mdia do aluno );
39 write(cont);
40 write( , );
41 writeln(mediaTemp:4:2);
42 end;
43
44 readkey;
45 end.

Sub-rotinas
130 No Pascal, a definio de sub-rotinas tambm feita de maneira muito prxima ao modo
como trabalhamos no pseudocdigo. Basicamente, o que muda so os comandos utilizados
para declarar as sub-rotinas. Alm disso, o escopo de variveis e a utilizao de parmetros
Linguagem Pascal

seguem os mesmos padres j estudados.

Funes
Para declarar funes no pseudocdigo, utilizamos o comando Funo, ao passo que no
Pascal o comando utilizado function. Confira o exemplo:
01 {Exemplo de uso de funo}
02 program ExemploFuncao;
03 uses crt;
04 var
05 cotDolar, cotEuro, cotPeso : real;
06 valorReal, valorDolar, valorEuro, valorPeso : real;
07
08 function Converte(cotao, valor : real) : real;
09 begin
10 Converte := valor / cotacao;
11 end;
12
13 begin
14 clrscr;
15 writeln(Digite a cotao do dia para...);
16 writeln(Dlar: );
17 read(cotDolar);
18 writeln(Euro: );
19 read(cotEuro);
20 writeln(Peso: );
21 read(cotPeso);
22
23 repeat
24 writeln(---------------------------------);
25 writeln(Digite o valor da compra em Real:);
26 read(valorReal);
27
28 if(valorReal > 0) then
29 begin
30 valorDolar := Converte(cotDolar, valorReal);
31 write(Valor em Dlar: );
32 writeln(valorDolar:7:2);
33
34 valorEuro := Converte(cotEuro, valorReal);
35 write(Valor em Euro: );
36 writeln(valorEuro:7:2);
37
38 valorPeso := Converte(cotPeso, valorReal);
39 write(Valor em Peso: );
40 writeln(valorPeso:7:2);
131
41 end;
42 until(valorReal = 0);
43 readkey;

Linguagem Pascal
44 end.

Procedimentos
No Pascal, os procedimentos so declarados pelo comando procedure, que equivalente
ao comando Procedimento, utilizado no pseudocdigo.
Veja um exemplo:
01 {Exemplo de uso de procedimento}
02 program ExemploProcedimento;
03 uses crt;
04 type
05 RegSelecao = record
06 nome : string[30];
07 votos : integer;
08 end;
09
10 vetRegistros = array[1..3] of RegSelecao;
11 var
12 vetSelecoes : vetRegistros;
13 opcao : integer;
14
15 procedure Votar(var vetSel : vetRegistros; voto : integer);
16 begin
17 vetSel[voto].votos := vetSel[voto].votos + 1;
18 writeln(Voto computado para: + vetSel[voto].nome);
19 end;
20
21 procedure EmitirResultado(vetSel : vetRegistros);
22 var
23 cont : integer;
24 begin
25 for cont := 1 to 3 do
26 begin
27 writeln(--------------------);
28 writeln(Seleo: + vetSel[cont].nome);
29 write(Votos: );
30 writeln(vetSel[cont].votos);
31 end;
32 end;
33
34 procedure InicializarSelecoes(var vetSel : vetRegistros);
35 begin
36 vetSel[1].nome := Argentina;
37 vetSel[1].votos := 0;
132
38 vetSel[2].nome := Brasil;
39 vetSel[2].votos := 0;
40 vetSel[3].nome := Paraguai;
Linguagem Pascal

41 vetSel[3].votos := 0;
42 end;
43
44 procedure Menu();
45 begin
46 writeln(---------------------------------------------------);
47 writeln(Que seleo ficar melhor colocada na prxima copa?);
48 writeln(1 = Argentina | 2 = Brasil | 3 = Paraguai | 0 = Fim);
49 end;
50
51 begin
52 clrscr;
53 InicializarSelecoes(vetSelecoes);
54 repeat
55 Menu();
56 readln(opcao);
57 if((opcao >= 1) and (opcao <= 3)) then
58 begin
59 Votar(vetSelecoes, opcao);
60 end
61 else
62 begin
63 if(opo <> 0) then
64 begin
65 writenln(Voto invlido.);
66 end;
67 end;
68
69 until(opcao = 0);
70 writeln(Fim da votao);
71 EmitirResultado(vetSelecoes);
72 readkey;
73 end.

Atividades
1) Nas atividades de 1 a 3 do captulo 4, voc criou 3 algoritmos
em pseudocdigo. Agora, sua atividade convert-los em pro-
gramas Pascal. Caso voc no os tenha feito anteriormente,
aproveite para faz-los agora.
2) Converta para programas Pascal as atividades 5, 7 e 8 do
captulo 4, que haviam sido resolvidas por meio da criao de
algoritmos em pseudocdigo. Caso voc no os tenha feito 133
anteriormente, aproveite para faz-los agora.

Linguagem Pascal
3) Na atividade 2 do captulo 5, voc criou 3 verses de algoritmo
em pseudocdigo. Agora, sua atividade convert-las em pro-
gramas Pascal. Caso voc no os tenha feito anteriormente,
aproveite para faz-los agora.
4) Converta para programas Pascal as atividades 1, 4 e 5 do
captulo 6, que haviam sido resolvidas por meio da criao de
algoritmos em pseudocdigo. Caso voc no os tenha feito
anteriormente, aproveite para faz-los agora.
5) Converta para programa Pascal a atividade 2 do captulo 7,
que havia sido feita em pseudocdigo. Caso voc no tenha
feito o algoritmo anteriormente, aproveite para faz-lo agora.
6) Converta para programa Pascal a atividade 2 do captulo 8,
que havia sido feita em pseudocdigo. Caso voc no a tenha
resolvido anteriormente, aproveite para faz-la agora.
7) Nas atividades de 5 a 8 do captulo 8, voc criou 4 algoritmos
em pseudocdigo. Agora, sua tarefa convert-los em pro-
gramas Pascal. Caso voc no os tenha feito anteriormente,
aproveite para faz-los agora.
Apndice 1
Principais Figuras Utilizadas na
Representao de Algoritmos Por
Meio de Fluxogramas
Figura Nome Significado

Terminador Demarca o incio ou trmino de um algoritmo.

Representa operaes de processamento, como clcu-


Processamento
los e atribuies de valores.
Representa uma tomada de deciso. Possui uma ou
mais entradas, e sempre duas sadas (uma vez que a
Deciso
expresso analisada resultar sempre em verdadeiro ou
falso).

Vdeo Representa a sada de dados em vdeo.

Impressora Representa a sada de dados em uma impressora.

134 Teclado Representa entrada de dados via teclado.

Representa a entrada ou sada de dados, por um dispo-


Entrada/Sada
sitivo externo.

Representa a execuo de uma sub-rotina do tipo


Procedimento
procedimento.

Representa a preparao de instrues para processa-


Preparao mento em estruturas de repetio do tipo Varivel de
Controle.

Disco Leitura ou gravao de arquivo em disco.

Fluxo Indicador de fluxo de execuo.


Representa o particionamento do algoritmo na mesma
Conector
pgina. Tambm simboliza a unio de fluxos de execuo.

Conector de Representa o particionamento do algoritmo em mais de


Pgina uma pgina.

Utilizado para inserir comentrios ao longo do


Comentrio
fluxograma.
Apndice 2
Configurao de um Ambiente
de Estudo de Programao com
Pascal
Para montar nosso ambiente de estudo de programao iremos utilizar o FreePascal, que
uma distribuio atualizada e gratuita de um compilador Pascal, acompanhado de uma IDE
(ambiente de desenvolvimento). O site oficial do FreePascal : <http://www.freepascal.org/>
O FreePascal est disponvel para diversos sistemas operacionais, o que facilita sua adoo
devido flexibilidade que proporciona. Voc pode, por exemplo, utilizar o FreePascal durante
o perodo de aula no laboratrio Linux de sua escola e, posteriormente, desenvolver seus traba-
lhos com o FreePascal em um computador rodando MS Windows na sua casa.

Instalao do FreePascal em Ambiente Windows


O primeiro passo baixar o FreePascal. Existem diversos locais onde o FreePascal pode
ser encontrado para download, porm optamos por baix-lo diretamente do SourceForge, que
um dos repositrios oficiais. O endereo para download o seguinte:
<http://www.sourceforge.net/projects/freepascal/files/>
135
Abrindo o link acima, voc dever ver algo como a figura a seguir:
Perceba que o site j identifica o sistema operacional que voc est usando e sugere (boto
grande, em verde) o download da verso do FreePascal compatvel com o seu sistema. Caso voc
deseje baixar uma verso para outro sistema, basta rolar a pgina at encontrar o seu sistema
operacional.
Neste exemplo, iremos utilizar a verso para Windows em 32 bits (win32). Veja na figura
abaixo que existem 3 verses disponveis para win32, ento iremos optar pela mais recente
delas, que no caso a 2.4.0.

136

Dentro da verso 2.4.0 ainda existem 3 possibilidades. Iremos escolher a fpc-2.4.0.i386-


win32.exe pois a verso compatvel com computadores rodando Windows de 32 bits. Basta
clicar no link, realizar o download e rodar o instalador.
Ao executar o instalador, a primeira tela que voc ver ser esta:

Basta clicar em Next, e ser exibida a tela abaixo, solicitando o local de instalao:
137
Caso necessrio, modifique o local onde o FreePascal deve ser instalado, e clique em
Next. Nesta prxima tela, ser solicitado o tipo de instalao.

Basta deixar na opo Full instalation e clicar novamente em Next. A tela a seguir
138
permite modificar o nome da pasta onde o atalho para o programa ficar localizado no menu
Iniciar. Apenas clique em Next.
A prxima tela permite associar as extenses dos arquivos fonte pascal com a IDE, e,
tambm, criar uma configurao padro para o ambiente de desenvolvimento. Certifique-se de
ter selecionado as mesmas opes da figura abaixo, e clique em Next.

Esta prxima tela apenas exibe as opes de instalao que foram selecionadas. Basta clicar 139
em Install e aguardar o trmino da instalao.
Ao final do processo de instalao, ser exibida a tela a seguir:

Basta clicar em Next e, na prxima tela, desmarcar a opo View readme.txt e clicar em
Finish.
140
Pronto, o FreePascal est instalado no computador e pronto para o uso. Abrindo o ambiente
pelo link criado durante a instalao, voc ir se deparar com a seguinte interface:

Agora voc est com o ambiente pronto para programar em Pascal. Bom aprendizado!

Instalao do FreePascal em Ambiente Linux 141

Como existem diversas distribuies Linux diferentes, o processo de instalao poder ser
diferente de acordo com a distribuio escolhida. Neste exemplo iremos instalar o FreePascal
no Ubuntu, que uma das mais utilizadas atualmente.
Iremos realizar a instalao diretamente por meio dos repositrios oficiais do Ubuntu.
Para isto, abra um console e digite o seguinte comando:

sudo apt-get install fp-compiler fp-docs fp-ide fp-units-base fp-


units-db fp-units-fcl fp-units-gfx fp-units-gnome1 fp-units-gtk
fp-units-gtk2 fp-units-misc fp-units-net fp-units-rtl

Isto ir realizar a instalao de diversos pacotes referentes ao compilador e ao ambiente de


desenvolvimento do FreePascal.
Aps digitar o comando, pode ser necessrio informar uma senha com poderes adminis-
trativos. Em seguida, ser exibida uma lista dos pacotes que sero baixados/instalados, seguida
de uma solicitao de confirmao. necessrio confirmar informando Y.

Feito isso, a instalao ocorrer de maneira automtica. Ao final da instalao, o terminal


142 ir retornar ao prompt de comando, parecendo-se com a imagem abaixo:
Para abrir o ambiente de desenvolvimento, basta digitar o comando fp no terminal.
A interface do ambiente de desenvolvimento do FreePascal para Linux esta:

Se estiver utilizando outra distribuio Linux, voc poder baixar do SourceForge o ins-
talador compatvel com a sua distribuio:

143

Pronto, agora voc est com o ambiente configurado para programar em Pascal. Bom
aprendizado!
Referncias Bibliogrficas
CANT, M. Essential Pascal. 2. ed. eBook. Disponvel em: <http://www.
marcocantu.com/epascal/>. Acesso em: 20 dez. 2009. Edio do autor,
2003.
EVARISTO, J. Programando com Pascal. 2. ed. So Paulo: Book Express, 2004.
FARRER, H, et al. Algoritmos Estruturados. 3. ed. Rio de Janeiro: LTC Editora,
1999.
LOPES, A; GARCIA, G. Introduo Programao. Rio de Janeiro: Elsevier
Editora, 2002.
MANZANO, J. A. N. G.; OLIVEIRA, J. F. de. Algoritmos: Lgica para
Desenvolvimento de Programao. 7. ed. So Paulo: Erica, s/d.
VENANCIO, C. F. Desenvolvimento de Algoritmos: Uma Nova Abordagem.
So Paulo: rica, 1997.
XAVIER, G. F. C. Lgica de Programao. 11. ed. So Paulo: Senac, 2009.

144