Apostila Completa de Logica

Curso de Lógica de Programação
ÍNDICE
OBJETIVOS DO CURSO....................................................................................................................................................4
MÓDULOS DO CURSO...................................................................................................................................................4
LÓGICA..............................................................................................................................................................................5
O QUE É LÓGICA?............................................................................................................................................................5
A LÓGICA NO DIA-A-DIA..................................................................................................................................................5
TRANSFORMANDO A LÓGICA EM ALGORITMO.................................................................................................................6
O que é Algoritmo?....................................................................................................................................................6
CONCEITOS PRELIMINARES....................................................................................................................................10
TIPOS..............................................................................................................................................................................10
CONSTANTES..................................................................................................................................................................11
VARIÁVEIS.....................................................................................................................................................................12
Declarando Variáveis...............................................................................................................................................12
EXPRESSÕES ARITMÉTICAS.............................................................................................................................................13
Operadores Aritméticos............................................................................................................................................13
Funções Matemáticas...............................................................................................................................................14
Prioridade de Resolução..........................................................................................................................................15
EXPRESSÕES LÓGICAS....................................................................................................................................................15
Operadores Relacionais...........................................................................................................................................15
Operadores Lógicos.................................................................................................................................................16
COMANDO DE ATRIBUIÇÃO............................................................................................................................................17
COMANDOS DE ENTRADA E SAÍDA................................................................................................................................18
Entrada de Dados.....................................................................................................................................................18
Saída de Dados.........................................................................................................................................................18
BLOCOS..........................................................................................................................................................................19
ESTRUTURAS DE CONTROLE...................................................................................................................................19
ESTRUTURA SEQÜENCIAL..............................................................................................................................................19
ESTRUTURA DE SELEÇÃO...............................................................................................................................................21
Seleção Simples........................................................................................................................................................23
Seleção Composta....................................................................................................................................................24
Seleção Encadeada...................................................................................................................................................27
Seleção de Múltipla Escolha....................................................................................................................................31
ESTRUTURA DE REPETIÇÃO............................................................................................................................................33
Repetição com Teste no Início..................................................................................................................................33
Repetição com Teste no final....................................................................................................................................34
Repetição com Variável de Controle........................................................................................................................39
ESTRUTURAS DE DADOS............................................................................................................................................40
VARIÁVEIS COMPOSTAS HOMOGÊNEAS.........................................................................................................................40
Vetores......................................................................................................................................................................40
Matrizes....................................................................................................................................................................44
VARIÁVEIS COMPOSTAS HETEROGÊNEAS......................................................................................................................46
Registros...................................................................................................................................................................46
ARQUIVOS.......................................................................................................................................................................51
ABRINDO UM ARQUIVO..................................................................................................................................................53
FECHANDO UM ARQUIVO...............................................................................................................................................54
COPIANDO UM REGISTRO...............................................................................................................................................54
GUARDANDO UM REGISTRO...........................................................................................................................................55
ACESSO SEQÜENCIAL.....................................................................................................................................................56
ACESSO DIRETO.............................................................................................................................................................58
MÓDULOS.......................................................................................................................................................................60
O QUE É MÓDULO?.........................................................................................................................................................60
ESCOPO DE VARIÁVEIS..................................................................................................................................................61
PASSAGEM DE PARÂMETROS..........................................................................................................................................62
Página 1
RETORNANDO VALORES DE UM MÓDULO.....................................................................................................................64
ESTRUTURA DE DADOS AVANÇADA.......................................................................................................................65
LISTAS............................................................................................................................................................................65
Inserção de Elementos em uma Lista.......................................................................................................................66
Remoção de Elementos em uma Lista......................................................................................................................68
FILAS..............................................................................................................................................................................69
Inserção de Elementos em uma Fila........................................................................................................................70
Remoção de Elementos em uma fila.........................................................................................................................71
PILHAS............................................................................................................................................................................72
Inserção de Elementos em uma Fila........................................................................................................................73
Removendo Elementos de uma Pilha.......................................................................................................................74
ÁRVORES........................................................................................................................................................................74
INTRODUÇÃO À LINGUAGENS DE PROGRAMAÇÃO........................................................................................78
LINGUAGEM DE PROGRAMAÇÃO....................................................................................................................................78
COMPILADOR..................................................................................................................................................................78
CÓDIGO FONTE...............................................................................................................................................................79
EXECUTÁVEL..................................................................................................................................................................79
SISTEMA OPERACIONAL.................................................................................................................................................79
LINGUAGEM DE MÁQUINA.............................................................................................................................................80
LINGUAGENS PARA DOS................................................................................................................................................80
LINGUAGENS PARA WINDOWS.......................................................................................................................................80
LINGUAGEM DE FORMATAÇÃO.......................................................................................................................................80
LINGUAGEM VISUAL......................................................................................................................................................81
LINGUAGEM ORIENTADA A OBJETOS.............................................................................................................................81
LINGUAGEM ESTRUTURADA..........................................................................................................................................81
LINGUAGEM NÃO ESTRUTURADA..................................................................................................................................81
BANCO DE DADOS..........................................................................................................................................................82
TABELA DE CLASSIFICAÇÃO..........................................................................................................................................82
INTRODUÇÃO AO VISUAL BASIC............................................................................................................................83
CARACTERÍSTICAS DA LINGUAGEM VISUAL BASIC.......................................................................................................83
COMANDOS DO VISUAL BASIC.......................................................................................................................................83
For ... Next................................................................................................................................................................83
For ... Each...............................................................................................................................................................84
While ... Wend...........................................................................................................................................................85
Do While / Loop........................................................................................................................................................85
Do / Loop Until.........................................................................................................................................................86
If / Then / Else / End If..............................................................................................................................................87
IIf..............................................................................................................................................................................88
Select Case / End Select...........................................................................................................................................88
INTRODUÇÃO AO DELPHI.........................................................................................................................................89
CARACTERÍSTICAS DA LINGUAGEM DELPHI..................................................................................................................89
COMANDOS DO DELPHI..................................................................................................................................................90
If ... Then...................................................................................................................................................................90
Case ...of...................................................................................................................................................................91
Repeat ... Until..........................................................................................................................................................92
While ... Do...............................................................................................................................................................93
For ... Do..................................................................................................................................................................93
INTRODUÇÃO A LINGUAGEM ORIENTADA A OBJETOS...................................................................................95
OBJETO...........................................................................................................................................................................95
PROPRIEDADES...............................................................................................................................................................95
MÉTODOS.......................................................................................................................................................................96
EVENTOS........................................................................................................................................................................96
CLASSES DE OBJETOS.....................................................................................................................................................96
ENCAPSULAMENTO.........................................................................................................................................................96
HERANÇA.......................................................................................................................................................................97
POLIMORFISMO...............................................................................................................................................................97
Página 2
ÍNDICE DE EXEMPLOS
Algoritmos
Exemplo 1 - Estrutura seqüencial.......................................................................................................20

Exemplo 2 - Estrutura de Seleção Simples........................................................................................23
Exemplo 3 - Estrutura de Seleção Composta.....................................................................................25
Exemplo 4 - Estrutura de Seleção Encadeada.....................................Erro! Indicador não definido.
Exemplo 5 - Estrutura de Seleção de Múltipla Escolha.....................................................................32
Exemplo 6 - Estrutura de Repetição com Teste no Início.................................................................34
Exemplo 7 - Estrutura de Repetição com Teste no Final...................................................................35
Exemplo 8 - Estrutura de Repetição com Variável de Controle.........................................................39
Exemplo 9 - Vetor...............................................................................................................................42
Exemplo 10 - Matriz............................................................................Erro! Indicador não definido.
Exemplo 11 - Registro........................................................................................................................50
Exemplo 12 - Arquivo (Acesso Seqüencial)......................................................................................58
Exemplo 13 - Arquivo (Acesso Direto)..............................................................................................59
Visual Basic
Exemplo 14 - For ... Next...................................................................................................................84

Exemplo 15 - For ... Each...................................................................................................................84
Exemplo 16 - While ... Wend.............................................................................................................85
Exemplo 17 - Do While / Loop..........................................................................................................86
Exemplo 18 - Do / Loop Until............................................................................................................86
Exemplo 19 - If / Then / Else / End If................................................................................................87
Exemplo 20 - IIf.................................................................................................................................88
Exemplo 21 - Select Case / End Select..............................................................................................89
Delphi
Exemplo 22 - If ... Then.....................................................................................................................91

Exemplo 23 - Case ...of......................................................................................................................92
Exemplo 24 - Repeat ... Until.............................................................................................................93
Exemplo 25 - While ... Do..................................................................................................................93
Exemplo 26 - For ... Do......................................................................................................................94
Página 3
OBJETIVOS DO CURSO
Neste curso o aluno aprenderá:
 O que é lógica
 O que é raciocínio lógico
 O que é algoritmo
 Como fazer um algoritmo
 Conceitos Básicos de Programação
 O que são e quais são as Estruturas de Controle
 O que são e quais são as Estruturas de Dados
 O que é Arquivo
 O que é Módulo
 Aspectos Básicos sobre Estrutura de Dados Avançada
 Conceitos Gerais das Linguagens de Programação
 Conceitos Básicos da Programação Orientada a Objetos
 Características Básicas da Linguagem DELPHI
 Comandos da Linguagem DELPHI
 Características Básicas da Linguagem VISUAL BASIC
 Comandos da Linguagem VISUAL BASIC
MÓDULOS DO CURSO
1 - Lógica
2 - Conceitos Básicos
3 - Estruturas de Controle
4 - Estrutura de Dados
5 - Arquivos
6 - Módulos
7 - Estrutura de dados Avançada
8 - Introdução ao DELPHI
9 - Introdução ao VISUAL BASIC
10 - Conceitos Gerais das Linguagens de Programação
11 - Introdução à Linguagem Orientada a Objetos
Página 4
LÓGICA
O que é Lógica?
A Lógica nada mais é do que o ato de se pensar corretamente, de se usar corretamente as

leis do pensamento. Como a forma mais complexa do pensamento é o raciocínio, pode-se dizer
também que a Lógica é a “correção do raciocínio”. Pode-se dizer ainda que a Lógica coloca ordem no
pensamento, evitando que ele funcione desordenadamente.
Exemplos:
a) Todo marciano é verde.

Krista é marciana.
Portanto, Krista é verde.
b) Paris é uma cidade da França.

Todos os parisienses são de Paris.
Portanto todos os parisienses são franceses.
A Lógica no dia-a-dia
Sempre que pensamos, usamos a Lógica ou a Ilógica. Como a palavra falada é a

representação do pensamento, também pensamos quando falamos assim como também pensamos
quando escrevemos, pois a palavra escrita é a representação da palavra falada. Portanto, a Lógica é
importante nas nossas vidas não só na teoria como na prática, pois sempre que queremos pensar, falar
ou escrever precisamos usá-la, ou seja, colocar ordem no pensamento.
Exemplos:
1) Rubens é mais alto que Oscar.

Antônio é mais baixo que Oscar.
Portanto, Rubens é mais alto que Antônio
2) A bolsa está fechada.

A caneta está na bolsa.
Preciso primeiro abrir a bolsa, para depois pegar a caneta.
Página 5
3) Silvia e Jorge tem somente dois filhos.

André é filho de Silvia e Jorge.
Portanto, André tem apenas um irmão.
Transformando a Lógica em Algoritmo
O que é Algoritmo?
“Algoritmo é uma seqüência de passos que visam atingir um objetivo bem definido.”
(Ordem de Pensamento e, portanto, Lógica)
Algoritmos são comuns em nosso cotidiano, como, por exemplo, uma receita de bolo. Nela
está descrita uma série de ingredientes e uma seqüência de diversos passos - ações - necessários para
que se consiga fazer determinado tipo de bolo - que é o objetivo bem definido e aguardado por todos.
Ou então um mapa para chegar à escola, que também possui uma seqüência de passos a
serem seguidos e um objetivo bem definido. Para melhor entendimento do conceito de algoritmo,
vamos tornar mais claro alguns outros conceitos, como, por exemplo, o de ação:
“Ação é um acontecimento que a partir de um estado inicial, após um período de tempo

finito, produz um estado final previsível e bem definido”, em que:
“Estado é a situação atual de dado objeto”.
Portanto, podemos redefinir Algoritmo como:
“Algoritmo é a descrição de um conjunto de ações que, obedecidas, resultam numa

sucessão finita de passos, atingindo o objetivo.”
Em resumo, um Algoritmo fixa uma série de passos a ser executada, com o objetivo de
encontrar, como resultado final, a solução de um problema.
Vamos, então, descrever uma atividade bem cotidiana, como, por exemplo, abrir uma
porta. Muitas vezes fazemos este tipo de atividade inconscientemente, sem percebermos seus pequenos
detalhes.
Descrevendo-a passo a passo:
pegue a chave;
coloque-a na fechadura da porta;
gire a chave;
tire a chave da fechadura;
segure a maçaneta;
gire a maçaneta.
Página 6
Neste algoritmo representamos uma seqüência de ações que são realizadas
involuntariamente, fazendo com que o algoritmo seja seguido por qualquer pessoa, estabelecendo um
padrão de comportamento (qualquer pessoa agiria da mesma maneira).
A seqüenciação das ações tem o objetivo de reger o fluxo de execução, determinando a

ordem dos passos.
Reexaminando o algoritmo anterior, notamos que ele tem um objetivo bem definido: abrir
uma porta. Porém, e se a chave escolhida não for a certa? Aconteceria um erro no meio da execução
dos passos e o objetivo final (abrir a porta) não seria alcançado.
Como solução para esse problema, podemos efetuar um teste, verificando se a chave é a
certa:
pegue a chave;
se a chave for a certa, então:
gire a chave;
segure a maçaneta;
gire a maçaneta.
Deste modo estamos associando algumas ações à condição (chave é a certa), ou seja, se
esta for verdadeira, conseguiremos abrir a porta:
gire a chave;
segure a maçaneta;
gire a maçaneta.
Mas, e se a condição (chave é a certa) for falsa (chave errada)? Não acontecerá erro
durante a execução da seqüência de passos mas também o objetivo final não será alcançado pois a
porta não será aberta. Precisamos então colocar os passos a serem executados caso a chave escolhida
seja a errada.
pegue a chave;
gire a chave;
segure a maçaneta;
gire a maçaneta;
se a chave for errada:
pegue outra chave;
gire a chave;
segure a maçaneta;
gire a maçaneta;
O que ocorreu neste algoritmo foi a inclusão de um teste seletivo (condição) que determina
qual ou quais ações serão executadas (note que anteriormente todas o eram), dependendo do resultado
da inspeção da condição.
Página 7
Como cada pessoa pensa e age de maneira diferente, existem várias formas de resolver um
mesmo problema. Isto significa que para este problema poderíamos ter diversas soluções diferentes e
corretas (se todas atingissem o mesmo resultado), e portanto somente o bom senso é capaz de indicar
qual delas é a mais adequada.
Esta algoritmo parece solucionar bem o problema mas ele não prevê a possibilidade de
que a nova chave também não seja a certa e, portanto, não atinja o objetivo nesta situação específica.
Devemos então pegar outra chave diversas vezes, se necessário, até que encontremos a certa:
pegue a chave;
gire a chave;
segure a maçaneta;
gire a maçaneta;
pegue outra chave;
gire a chave;
segure a maçaneta;
gire a maçaneta;
pegue outra chave;
.
.
.
(Até quando?)
Este algoritmo tornou-se infinito. As ações somente cessarão quando conseguirmos

encontrar a chave certa e, então, abrir a porta, caso contrário ficaremos tentando indefinidamente. Este
algoritmo, apesar de nos dar maior garantia de que a porta será aberta, não diz o número exato de
testes.
O teste da chave é efetuado por uma determinada seqüência de ações:

pegue outra chave;
Portanto, não precisamos escrever várias vezes esta determinada seqüência. Basta, após a
ação “coloque-a na fechadura da porta” executarmos o teste “ se a chave for errada”. Desta forma, esta
seqüência será realizada o número de vezes necessário, sendo escrita apenas uma vez. Só precisamos
determinar um limite para tal repetição para garantir que ela pare quando encontrarmos a chave certa.
enquanto a chave for errada, faça:

pegue outra chave;
Página 8
A condição (chave errada) permaneceu, e estabelecemos uma seqüência repetitiva que será
finalizada assim que a condição for falsa (chave certa).
pegue a chave;
pegue outra chave;
gire a chave;
segure a maçaneta;
gire a maçaneta;
Vamos supor que tivéssemos dez portas para abrir:
pegue a chave;
pegue outra chave;
gire a chave;
segure a maçaneta;
gire a maçaneta;
pegue a chave;
.
.
.
pegue a chave;
.
.
.
Para abrir dez portas teríamos que repetir dez vezes o algoritmo, como mostrado acima? É
claro que não. Basta executarmos o mesmo algoritmo quantas vezes for necessário - no caso, dez:
enquanto quantidade de portas abertas menor que dez, faça:

pegue a chave;
pegue outra chave;
gire a chave;
segure a maçaneta;
gire a maçaneta;
Página 9
Enquanto a condição (quantidade de portas abertas menor que dez) for verdadeira, as ações
para abrir uma porta serão executadas. Caso a condição for falsa, ou seja, todas as dez portas já estão
abertas (quantidade de portas abertas igual a dez), nada mais será executado.
Este exemplo foi desenvolvido a partir do problema de se abrir uma porta. Foram descritas
todas as ações necessárias para chegar a este objetivo, ou seja, foi escrito um algoritmo para este fim.
Nota:
Inicialmente tínhamos apenas um pequeno conjunto de ações que deveriam ser executadas
todas passo a passo, uma após a outra, seqüencialmente compondo uma estrutura seqüencial.
Quando percebemos que nem todas as ações deveriam ser executadas, associamos uma
condição a um conjunto de ações que só seria executado conforme o resultado do teste da condição.
Desta forma, construímos uma estrutura seletiva.
Depois nos deparamos com a necessidade de repetir várias vezes um mesmo conjunto de
ações. Para não precisarmos escrever várias vezes o mesmo trecho do algoritmo, criamos uma
estrutura de repetição de modo que este trecho fosse executado diversas vezes enquanto uma
condição não fosse satisfeita.
É muito simples o ato de se abrir uma porta, tanto para nós como para qualquer outra
pessoa. Poderíamos realiza-lo inconscientemente, baseando-nos em nossas próprias experiências. Mas
um computador não tem conhecimento prévio e nem adquire experiências, portanto devemos descrever
detalhadamente todos as ações que ele deverá realizar para alcançar o objetivo final, levando-se em
conta todos os obstáculos que podem surgir e a forma para resolve-los. É nisto que se baseia o
atividade de programar.
CONCEITOS PRELIMINARES
Tipos
Quando um programa é rodado em um computador, informações são manipuladas por ele.

Tipo é a forma do computador classificar cada informação, definindo como ela agirá e com quais
outras informações ela poderá se relacionar.
Existem vários tipos diferentes na programação. Quando aprendemos uma linguagem de

programação, seja ela qual for, aprendemos os tipos existentes nesta determinada linguagem. Portanto,
agora vamos entender apenas os tipos básicos, ou primitivos:
1. Inteiro: toda informação numérica que pertença ao conjunto dos números inteiros
relativos (negativa, nula ou positiva).
Página 10
Exemplos:
a) A pizza tem 8 pedaços.

b) Ontem fez -2 graus.
2. Real: toda informação numérica que pertença ao conjunto dos números reais (negativa,
nula ou positiva).
Exemplos:
a) O livro custa R$ 85,60.

b) Ela comprou 3,5 Kg de carne.
3. Caractere: toda informação composta por um conjunto de caracteres alfanuméricos

(0...9) e/ou especiais (por exemplo, # $ % & * ? ~ < ! @).
Exemplos:
a) A placa dizia: “Animal em extinção”.

b) No tapete estava escrito: “Bem Vindo!”.
4. Lógico: toda informação que só pode assumir dois estados (biestável).
Exemplos:
a) O computador pode estar ligado ou desligado.

b) A gaveta pode estar aberta ou fechada.
Constantes
Uma informação é constante quando não é alterada no decorrer do tempo. No caso da

programação, uma informação é constante quando seu valor continua o mesmo durante toda a
execução do programa.
Página 11
As informações constantes de tipo caractere serão delimitadas por um par de aspas (“ “)
para serem diferenciadas de outros tipos de informação. Por convenção, as informações de tipo lógico
são sempre verdadeiras ou falsas.
Exemplos:
4, 567, -1,98, “R$ 67,00”, Verdadeiro, “Não Fume”.
Variáveis
Uma informação é considerada variável quando tem a possibilidade de ser alterada durante
o decorrer do tempo. No caso da programação, é quando ela pode ter seu valor alterado durante a
execução do programa.
Vamos supor que precisássemos armazenar a média anual de temperatura. Não poderíamos
usar uma constante, pois o valor da média mudaria a cada ano. Usaríamos, então, um parâmetro para
armazenar o valor da média atual. Este parâmetro poderia ser chamado de MÉDIA. Este nome, que
poderíamos dizer que é o nome da variável que guardará o valor da média anual, é um identificador.
Para criar um identificador, devemos seguir as seguintes regras de formação:
1. Começar por um caracter alfabético;

2. Ser, ou não, seguidos por mais caracteres alfabéticos e/ou numéricos;
3. Não usar caracteres especiais;
4. Os caracteres alfabéticos devem ser escritos em maiúsculo, obrigatoriamente.
Exemplos:
Identificadores válidos: MÉDIA, Y, BK78, NOTAS, D2, SOMA.

Identificadores inválidos: 8Y, M@, X+Y, MÉDIA*2, S(10).
Declarando Variáveis
Em um programa, sempre que usarmos informações variáveis, devemos declarar as

variáveis que armazenarão estas informações. Isto significa que precisamos definir um nome para cada
variável (identificador) e especificar de que tipo ela é, ou seja, qual tipo de informação ela poderá
armazenar. Em outras palavras, declaramos uma variável da seguinte forma:
tipo : lista de variáveis ;
Página 12
Exemplos:
inteiro: A;
real: X, Y, RESULTADO, VALOR;
caractere: NOME, TELEFONE, DATA;
lógico: RESPOSTA;
A é uma variável que só pode armazenar informação, ou valor, do tipo inteiro. A variável
NOME só pode guardar informação do tipo caractere, assim como a variável RESPOSTA só armazena
valores lógicos.
Devemos tomar o cuidado de não darmos o mesmo nome para duas ou mais variáveis, ou
seja, de declararmos duas ou mais variáveis com o mesmo nome pois, quando uma delas for
referenciada, o computador não saberá qual variável usar. Além disso, só poderemos guardar
informações em variáveis do mesmo tipo.
Expressões aritméticas
Expressões aritméticas são aquelas cujos operadores são aritméticos e cujos operandos são
constantes e/ou variáveis numéricas (tipo inteiro ou real).
Operadores Aritméticos
Operadores aritméticos são símbolos que representam as operações básicas da matemática.

São eles:
+ Adição
- Subtração
Multiplicação
/ Divisão
** Potenciação
// Radiciação
Regra de formação de expressões aritméticas:
operando operador aritmético operando
Exemplos:
Página 13
8+2, VALOR/5, SOMA+5, X-Y, 2**3, 4//16.
Existem outras operações matemáticas não-convencionais cujos nomes dos operadores são:
mod -> resto da divisão
div -> quociente da divisão inteira
Exemplos :
11 div 2 resulta 5
11 mod 2 resulta 1
19 div 8 resulta 2
19 mod 8 resulta 3
Funções Matemáticas
Nas expressões aritméticas, podemos usar, além das operações básicas citadas acima,
algumas funções da matemática:
sen(x) retorna o seno de x;

cos(x) retorna o coseno de x;
tg(x) retorna a tangente de x;
arctg(x) retorna arco cuja tangente é x;
arccos(x) retorna arco cujo coseno é x;
arcsen(x) retorna arco cujo seno é x;
abs(x) retorna o módulo de x;
int(x) retorna a parte inteira de um número fracionário;
frac(x) retorna a parte fracionária de x;
ard(x) transforma um número fracionário em inteiro, por arredondamento;
sinal(x) retorna -1, se x for negativo, 1, se for positivo ou 0, se for nulo;
rnd(x) retorna um valor para x, escolhido pelo computador, randomicamente;
Onde x pode ser uma constante, variável, expressão aritmética ou também outra função
matemática.
Exemplos:
int(2.867) retorna 2
frac(2.867) retorna 867
ard(1.79) retorna 2
ard(1.43) retorna 1
abs(-8) retorna 8
sinal(-3) retorna -1
Página 14
Prioridade de Resolução
Como já foi dito, em uma mesma expressão aritmética, podemos ter diferentes operações
e/ou funções matemáticas. Portanto, na hora da resolução precisamos obedecer a uma ordem de
prioridade existente, para não afetarmos o resultado final. A seguinte tabela representa esta ordem de
prioridade:
parênteses mais internos

funções matemáticas
** //
* / div mod
+ -
Quando duas operações possuem a mesma prioridade, resolvemos primeiro aquelas cujos
operadores estão mais à esquerda da tabela, a não ser que usemos parênteses mais internos, o mudaria
a prioridade descrita na tabela.
Expressões Lógicas
Expressões lógicas são aquelas cujos operadores são lógicos e/ou relacionais e cujos
operandos são relações e/ou variáveis e/ou constantes do tipo lógico.
Regra de formação de uma expressão lógica:
operando lógico operador lógico operando lógico
Operadores Relacionais
Operadores relacionais são utilizados para fazerem comparações entre dois valores do
mesmo tipo. Estes valores podem ser constantes, variáveis ou expressões aritméticas. O resultado de
uma comparação é sempre um valor lógico. Os operadores relacionais são:
= Igual
> Maior
< Menor
<> Diferente
>= Maior ou igual
<= Menor ou igual
Exemplos:
Página 15
15 > 10 V
4 =5 F
33 mod 4 <> 1 F
13 div 2 >= 2 V
Operadores Lógicos
Os operadores lógicos são utilizados para se fazer relações entre duas ou mais proposições
conhecidas, resultando em um valor lógico. Os operadores lógicos são:
e conjunção
ou disjunção (não-exclusiva)
xou disjunção (exclusiva)
não negação
Exemplos:
13 > 20 ou 7 = 7 V
10 >= 4 e 6 <> 6 F
não(2 < 9 ) ou 40 <= 34 F
12 > 2 xou 5 <> 8 F
Para melhor exemplificação, são listadas abaixo as Tabelas Verdade. Cada Tabela Verdade
é o conjunto de todas as possibilidades de combinação de um determinado operador lógico. Note que
as variáveis A e B só podem assumir dois valores, Falso ou Verdadeiro, pois são do tipo lógico:
A B AeB A B A ou B A B A xou B A não A

F F F F F F F F F F V
F V F F V V F V V V F
V F F V F V V F V
V V V V V V V V F
Entre operadores lógicos, a resolução obedece a seguinte ordem de prioridade:
não
e ou
xou
Entre todos os operadores, a ordem é a seguinte:
parênteses mais internos

funções matemáticas
operadores aritméticos
operadores relacionais
operadores lógicos
Página 16
Exercícios
1) Determine se a equação resultante é Verdadeira ou Falsa
Equação: X2 + Y > Z
X Y Z
1 2 5 V( ) F( )
4 3 1 V( ) F( )
1 1 2 V( ) F( )
1 2 1 V( ) F( )
2) Resolva a equação a seguir e diga se ela é Verdadeira ou Falsa:
(10 mod 7 < 3 xou (10 div 2 = 5 xou 10 mod 3 > 10))
Comando de Atribuição
Quando queremos atribuir um valor a uma determinada variável, utilizamos o comando de

atribuição, desde que o valor a ser atribuído seja do mesmo tipo que a variável que vai recebe-lo. A
sintaxe do comando de atribuição é a seguinte:
identificador  expressão ;
Exemplo:
real: X, Y;
lógico: RESPOSTA;
X  3,5;
Y  14 div 3 + 0,9;
RESPOSTA  X = Y;
De acordo com o exemplo, podemos perceber que as variáveis X e Y devem ser do tipo
real, já que valores reais são atribuídos à elas, e que a variável RESPOSTA deve ser do tipo lógico, já
que um valor lógico foi atribuído à ela. Tudo isso já foi explicitado na declaração das variáveis.
Página 17
Quando o valor a ser atribuído a uma variável está representado por uma expressão
aritmética ou lógica, estas devem ser resolvidas primeiro, para que depois o resultado possa ser
armazenado na variável. Por exemplo, a variável RESPOSTA receberá verdadeiro se X =Y, caso
contrário, receberá falso.
Comandos de Entrada e Saída
Às vezes, em um programa, precisamos entrar com alguns dados para que este, depois de
executado, nos retorne outros dados. Por exemplo, um programa que soma dois números escolhidos
pelo usuário. Para poder ser executado, é necessário, antes de mais nada, que o usuário digite os dois
números a serem somados, aí então, o computador pode retornar o resultado (soma). Quando o usuário
digita os dois números a serem somados, ele está executando a entrada de dados. Quando o
computador devolve o resultado da soma para o usuário, ele está executando a saída de dados. Ou seja:
Entrada de Dados Processamento dos Dados Saída de Dados
7 12
7+5
5
Quando o usuário Quando o programa é Quando a soma é

digita o número. executado mostrada na tela
Entrada de Dados
Sintaxe da Entrada de Dados
Leia ( variável ) ;
,
Exemplos:
leia ( X ) ;
leia ( A, NOTA, VALOR ) ;
Saída de Dados
Sintaxe da Saída de Dados
Escreva ( variável ) ;
constante
expressão
,
Página 18
Exemplos:
Escreva (Y);
Escreva (A, NOTA, VALOR) ;
Escreva ( “Meu nome é “, NOME ) ;
Escreva (“Você tem “, IDADE, “ anos “ ) ;
Blocos
Um bloco é um conjunto de comandos (ações) com um objetivo definido. Um algoritmo
pode ser considerado um bloco. As variáveis declaradas no interior de um bloco são conhecidas apenas
dentro desse bloco.
Para delimitar um bloco, são usados os delimitadores: início e fim.
início ação fim ;
Exemplos:
início {início do bloco ( algoritmo ) }




 { declaração de variáveis }

{ seqüência de comandos }



fim . { bloco ( algoritmo ) }
ESTRUTURAS DE CONTROLE
Os conceitos de bloco lógico, entrada e saída de dados, variáveis, constantes, atribuições,

expressões lógicas, relacionais e aritméticas e os demais conceitos que traduzem estes conceitos de
forma a representar o conjunto de ações são utilizados na criação de algoritmos.
Para que esse conjunto de ações se torne viável, deve existir uma relação lógica no modo
pelo qual essas ações são executadas.
Utilizando as estruturas básicas de controle de fluxo de execução - seqüenciação, seleção,

repetição - e da combinação delas, poderemos criar um algoritmo para resolver qualquer problema.
Estrutura Seqüencial
É o conjunto de ações primitivas que serão executadas numa seqüência linear (de cima
para baixo e da esquerda para a direita), na mesma ordem em que foram escritas.
Página 19
Todas as ações devem ser seguidas por um ponto e vírgula ( ; ), que tem como finalidade
separar uma ação de outra e auxiliar a organização seqüencial das ações, pois após encontrar um ( ; ),
devemos executar o próximo comando da seqüência.
início { começo do algoritmo }



 comando a;
 comando b;
 comando c; comando d;
 comando e;
 .
 .
 .
 comando n;
fim . { algoritmo }
Exemplo:
Construir um algoritmo que calcule a média aritmética anual de um aluno, a partir de

quatro notas fornecidas pelo usuário.
Temos:
1. Dados de entrada: quatro notas bimestrais (N1, N2, N3, N4 );

2. Dados de saída: média aritmética anual (MA);
3. Processamento: utilizar média aritmética ((N1+N2+N3+N4)/4);
4. Construção do algoritmo:
início { começo do algoritmo }

 real : N1, N2, N3, N4, MA; { declaração de variáveis }
 leia : ( N1, N2, N3, N4 ); { entrada de dados }
 MA  (N1+N2+N3+N4) / 4; {processamento }
 escreva (M); {saída de dados}
fim. { término do algoritmo }
Exemplo 1 - Estrutura seqüencial
Exercícios
Página 20
3) Analise e interprete o algoritmo a seguir e determine o valor final de X, Y e Z.
Inicio
Inteiro: X,Y Resposta:
Real: Z
Leia ( X )
Escreva (X, “ao cubo = “, X**3)
Leia ( Y )
Escreva ( X + Y )
Z X/Y
Escreva ( Z )
Z Int( Z )
Escreva ( Z )
Z Z+1
X ( Y + Z ) mod 2
Escreva ( X )
Escreva ( Y )
Escreva ( Z )
Fim
Dados: X = 3
Y=4
Z=?
4) Crie um Algoritmo que calcule a média de 4 idades:
Página 21
5) Crie um Algoritmo que calcule a área de uma circunferência, e no final apresente a medida da
área calculada:
Dados: A =
~ * R2
~ = 3,14159
6) Crie um Algoritmo que leia uma temperatura em graus Fahrenheit e apresente essa
temperatura convertida em graus Centígrados.
Dados: Cº = (Fº - 32) * (5/9)
Página 22
Estrutura de Seleção
É quando associamos a execução de um conjunto de comandos (ações) a uma determinada
condição, ou seja, se a condição for satisfeita, alguns comandos são executados ou não.
Seleção Simples
se <condição> então

 comando; { comando único ( ação primitiva) }

fimse;
Onde:
<condição> é uma expressão lógica que, quando testada, pode gerar como resultado falso
ou verdadeiro.
Se <condição> for verdadeira, a ação primitiva sob a cláusula (comando) será executada.
Se <condição> for falsa, a estrutura é encerrada (fimse) sem executar nenhum comando.
Agora com vários comandos:
Se <condição> então
 início { bloco verdade }
  C1;
  C2; {seqüência de comandos }
  .
  .
  Cn;
 fim {bloco }
fimse;
Se condição for verdadeira, o "bloco verdade" ( seqüência de comandos C1... Cn ) será

executado; caso contrário ( <condição> falsa ), nada é executado encerrando o comando ( fimse ).
Repare que, por termos vários comandos, precisamos delimitar o bloco ( usando início e fim ).
Exemplo:
início
 real : N1, N2, N3, N4, { notas bimestrais }
 MA ; { média anual }
 leia (N1, N2, N3, N4); {entrada de dados }
 MA  (N1+N2+N3+N4) / 4; { processamento }
 escreva (MA); { saída de dados }
 se MA >= 6 então
 
  escreva ("Aluno Aprovado!");
 
 fimse;
fim.
Exemplo 2 - Estrutura de Seleção Simples
Página 23
Seleção Composta
  C1;
  C2; { seqüência de comandos }
  .
  .
  .
  Cn;
 fim; { bloco verdade }
senão

 C; { comando único }

fimse;
O bloco verdade será executado se <condição> (expressão lógica) for verdadeira. Porém,
se <condição> for falsa, somente o comando C será executado, pois ele pertence à cláusula senão. A
existência do senão caracteriza a seleção composta.
Se existissem vários comandos a serem executados, caso a condição for falsa, a estrutura
do algoritmo ficaria assim:
  C1;
  .
  .
  .
  Cn;
 fim { bloco verdade }
senão
 início { bloco falso }
  C1;
  .
  .
  .
  Cn;
 fim { bloco falso }
fimse;
Página 24
Exemplo:
início
 {declaração de variáveis }
 MA; { média anual }
 leia (N1, N2, N3, N4) ;
 MA  (N1+N2+N3+N4) / 4 ;
 escreva ("Média Anual = ", MA);
 se MA >= 6 então
  início { bloco verdade }
   escreva ("Aluno Aprovado!");
   escreva ("Parabéns!");
  fim; { bloco verdade }
 senão
  início { bloco falso }
   escreva ("Aluno Reprovado!");
   escreva ("Estude Mais!");
  fim { bloco falso }
 fimse;
fim.
Exemplo 3 - Estrutura de Seleção Composta
Exercícios
7) Crie um Algoritmo que leia dois valore inteiros. Efetuar a adição e apresentar o resultado,
caso o valor somado seja maior do que 10.
Página 25
8) Crie um Algoritmo que leia dois valore inteiros. Efetuar a adição e apresentar o resultado da
seguinte forma:
- Caso o resultado seja maior ou igual a 10, deverá ser apresentado somando-se a ele mais 5
- Caso o resultado seja menor que 10 deverá ser apresentado subtraindo-se dele 7
9) Crie um Algoritmo que determine se um número é Par ou Ímpar
Página 26
10) Crie um Algoritmo que “leia uma idade” e “imprima na tela” as seguintes mensagens:
- Maior de Idade
- Menor de Idade
Condição para ser maior de idade: 21 anos
Seleção Encadeada
Quando, devido à necessidade de processamento, agruparmos várias seleções, formaremos

uma seleção encadeada. Normalmente tal formação ocorre quando uma determinada ação ou bloco
deve ser executado se um grande conjunto de possibilidades ou combinações de situações for
satisfeito.
Seleção Encadeada Heterogênea
Página 27
Exemplo:
se <condição 1> então

 se <condição 2> então
  início { bloco verdade 1}
   C1;
   C2; { seqüência de comandos }
   .
   .
   .
   Cn;
  fim { bloco verdade 1 }
 fimse;
senão
  início { bloco verdade 2 }
   C1;
   C2; { seqüência de comandos }
   .
   .
   .
   Cn;
  fim { bloco verdade 2 }
 senão
  se <condição 4> então
   se <condição 5 > então
   
    CV; { comando verdade }
   
   fimse;
  senão
  
   CF; { comando falso }
  
  fimse;
 fimse;
fimse;
Seleção Encadeada Homogênea
Exemplo 1:
se <condição 1> então

  se <condição 3> então
   se <condição 4> então
    W;
   fimse;
  fimse;
 fimse;
fimse;
Página 28
Exemplo 2:
se X = V1 então
 C1;
fimse;
se X = V2 então
 C2;
fimse;
se X = V3 então
 C3;
fimse;
se X = V4 então
 C4;
fimse;
Exemplo 3:
se X = V1 então
 C1;
senão
 se X = V2 então
  C2;
 senão
  se X = V3 então
   C3;
  senão
   se X = V4 então
    C4;
   fimse;
  fimse;
 fimse;
fimse;
Exercícios
11) Faça um algoritmo que calcule o peso ideal de uma pessoa, dependendo do sexo da mesma.
Dados:
- Cálculo do Masculino: P = (72,7 * h) – 58
- Cálculo do Feminino: P = (62,1 * h) – 44,7
Condições:
- S = Sexo
- h = Altura
- P = Peso Ideal
Obs.: Solicitar ao usuário o Peso e a Altura.
Página 29
12) Crie um algoritmo que calcule o reajuste de salário de um funcionário:
Dados:
- Reajuste de 15% se o salário for menor que R$ 500,00
- Reajuste de 10% se o salário for maior ou igual a R$ 500,00 mas menor ou igual a R$ 1.000,00
- Reajuste de 5% se o salário for maior que R$ 1.000,00
13) Faça um algoritmo que leia 3 variáveis inteiras, A, B, C, que seriam os lados de um triângulo.
Mostrar as seguintes mensagens:
- Não Forma Triângulo

- Triângulo Equilátero
- Triângulo Isósceles
- Triângulo Escaleno
Condições:
1) Para ser Triângulo, cada lado tem que ser menor que a soma dos outros dois
2) Triângulo Equilátero, tem todos os lados iguais]
3) Triângulo Isósceles, tem dois lados iguais
4) Triângulo Escaleno, tem todos os lados diferentes
Página 30
Seleção de Múltipla Escolha
escolha X
 caso V1 : C1;
 caso V2 : C2;
 caso V3 : C3;
 caso V4 : C4;
fimescolha;
Caso o conteúdo da variável X seja igual ao valor V1, então o comando C1 será executado.
Caso o conteúdo da variável X seja igual ao valor V2, então o comando C2 será executado, e assim por
diante, até que seja encontrada a igualdade ou terminarem os casos.
Outra forma:
escolha X
 caso V1 : C1;
 caso V2, V3 : C2;
 caso V4 : C3;
 caso V5 : C4;
 caso contrário : C5;
fimescolha;
Exemplo:
Construa um algoritmo que, tendo como dados de entrada o preço de um produto e um

código de origem, emita o preço junto de sua procedência. Caso o código não seja nenhum
dos especificados, o produto deve ser encarado como importado.
Código de origem:
1 - Sul 5 ou 6 - Nordeste
2 - Norte 7, 8 ou 9 - Sudeste
3 - Leste 10 até 20 - Centro-Oeste
4 - Oeste 25 até 50 - Nordeste
Página 31
início
 real : PREÇO;
 inteiro : ORIGEM;
 leia (PREÇO, ORIGEM);
 escolha ORIGEM
  caso 1 : escreva (PREÇO, " - Produto do Sul");
  caso 2 : escreva (PREÇO, " - Produto do Norte");
  caso 3 : escreva (PREÇO, " - Produto do Leste");
  caso 4 : escreva (PREÇO, " - Produto do Oeste");
  caso 7, 8, 9 : escreva (PREÇO, " - Produto do Sudeste");
  caso 10..20 : escreva (PREÇO, " - Produto do Centro-Oeste");
  caso 5, 6, 25..50 : escreva (PREÇO, " - Produto do Nordeste");
  caso contrário: escreva (PREÇO," - Produto Importado");
 fimescolha;
fim.
Exemplo 4 - Estrutura de Seleção de Múltipla Escolha
Exercícios
14) Faça um algoritmo que leia um produto, seu preço inicial e calcule o seu preço final,
dependendo da categoria de reajuste.
CATEGORIA ÍNDICE
A 1,10
B 1,20
C 1,30
D 1,40
E 1,50
F 1,60
G 1,70
H 1,80
Página 32
Estrutura de Repetição
Voltando ao algoritmo da média aritmética, quantas vezes ele será executado? Do modo no
qual se encontra o processamento, só é realizado uma única vez e para um único aluno. E se fossem 50
alunos?
Poderíamos resolver o problema escrevendo o algoritmo 50 vezes, uma para cada aluno. É
uma solução simples, porém, inviável.
Poderíamos também utilizar a mesma seqüência de comandos novamente, realizando um

retrocesso - ao início dos comandos - para cada aluno, fazendo, portanto, com que o fluxo lógico fosse
uma repetição de certo trecho do algoritmo. Desta forma, executaríamos o mesmo trecho 50 vezes,
sem Ter que escrevê-lo 50 vezes.
Esses trechos do algoritmo que são repetidos são chamados de laços de repetição ou loops.
O número de repetições pode ser indefinido, mas deve sempre ser finito. Para tanto podemos proceder
de dois modos:
 calcular a média enquanto a quantidade de médias calculadas for menor ou igual a

50;
 calcular a média até que o número de médias calculadas atinja 50.
Repetição com Teste no Início
É uma estrutura de controle de fluxo lógico que permite executar várias vezes o mesmo
trecho do algoritmo, mas sempre verificando antes de cada execução se é permitido repetir o mesmo
trecho.
Para tanto, utilizamos a estrutura enquanto, que permite que um bloco ou um simples
comando seja repetido enquanto uma determinada <condição> for verdadeira.
enquanto <condição> faça

 C1;
 C2;
 .
 .
 .
 Cn;
fimenquanto;
Página 33
Quando <condição> não for mais verdadeira, o bloco ou o comando não é mais executado.
Se já no primeiro teste a condição for falsa, os comandos não são executados nenhuma vez.
No exemplo da média aritmética, teríamos:
início
 inteiro : CONTADOR;
 CONTADOR  0;
 enquanto CONTADOR < 50 faça { teste da condição }
  leia (N1, N2, N3, N4) ;
  MA  (N1+N2+N3+N4) / 4 ;
  escreva ("Média Anual = ", MA);
  se MA >= 6 então
   início { bloco verdade }
    escreva ("Aluno Aprovado!");
    escreva ("Parabéns!");
   fim; { bloco verdade }
  senão
   início { bloco falso }
    escreva ("Aluno Reprovado!");
    escreva ("Estude Mais!");
   fim { bloco falso }
  fimse;
  CONTADOR  CONTADOR + 1;
 fimenquanto;
fim.
Exemplo 5 - Estrutura de Repetição com Teste no Início
Repetição com Teste no final
Para realizar a repetição com teste no final, utilizamos a estrutura repita, que permite que
um bloco ou um comando seja repetido até que uma determinada condição seja verdadeira.
repita
 C1;
 C2;
 .
 .
 .
 Cn;
até <condição>;
Página 34
Percebemos que o bloco (C1...Cn) é executado pelo menos uma vez, independente da
validade da condição. Isto ocorre porque a inspeção da condição é feita após a execução do bloco.
No exemplo da média aritmética, teríamos:
início
 CONTADOR  0;
 repita
  leia (N1, N2, N3, N4) ;
  MA  (N1+N2+N3+N4) / 4 ;
  senão
  fimse;
  CONTADOR  CONTADOR + 1;
 até CONTADOR >= 50; {teste da condição }
fim.
Exemplo 6 - Estrutura de Repetição com Teste no Final
Exercícios
15) Crie um algoritmo que apresente o total da soma obtida dos cem primeiros números inteiros:
Página 35
16) Crie um algoritmo que apresente o resultado de uma tabuada de um número qualquer
informado pelo usuário, no seguinte formato:
Obs.: Considerando que o usuário tenha digitado o número 2
2X1=2
2X2=4
2X3=6
( ... )
2 X 10 = 20
17) Faça um algoritmo que leia 10 idade. Mostre a cada idade lida se é maior ou menor de idade.
No final mostrar a media geral de idades.
Condição para ser maior: 21 anos
18) Crie um algoritmo que leia 5 idades, e mostre qual a menor idade.
Página 36
19) Faça um algoritmo que calcule a soma dos números pares de 0 a 100.
20) Crie um algoritmo que leia 10 idades. Achar a maior idade e a média geral dessas idades.
Página 37
21) Crie um algoritmo que leia um número inteiro e calcule o fatorial desse número.
Repetição com Variável de Controle
Página 38
Nas estruturas de repetição vistas até agora, ocorrem casos em que não é possível
determinar quantas vezes o bloco será repetido. A estrutura para repete a execução do bloco um
número definido de vezes, pois ela possui limites fixos.
para X de vi até vf passo p faça

 C1;
 C2;
 .
 .
 .
 Cn;
fimpara;
Onde:
 X é a variável de controle;
 vi é o valor inicial da variável X;
 vf é o valor final da variável X, ou seja, o valor até o qual ela pode chegar;
 p é o passo do incremento dado à variável X.
Exemplo:
início
 para CONTADOR de 1 até 50 passo 1 faça
  leia (N1, N2, N3, N4) ;
  MA  (N1+N2+N3+N4) / 4 ;
  senão
  fimse;
 fimpara;
fim.
Exemplo 7 - Estrutura de Repetição com Variável de Controle
Página 39
ESTRUTURAS DE DADOS
A quantidade de tipos de informações estipulados ( tipos primitivos ) não é suficiente para

representar toda e qualquer informação que possa surgir. Portanto, seria bom se existissem mais tipos
de informação ou, ainda melhor, se esses tipos pudessem ser "construídos", criados, à medida que se
fizessem necessários.
Podemos construir novos tipos, denominados "tipos construídos", a partir da composição

de tipos primitivos. Esses novos tipos têm um formato denominado ESTRUTURA DE DADOS, que
define como os tipos primitivos estão organizados.
Variáveis Compostas Homogêneas
Uma variável pode ser interpretada como um elemento e uma Estrutura de Dados como um
conjunto. Quando uma determinada Estrutura de Dados for composta de variáveis com o mesmo tipo
primitivo, temos um conjunto homogêneo de dados.
Vetores
Vetor é uma variável composta unidimensional. Para entender melhor este conceito,
imaginemos um edifício com um número finito de andares, representando uma estrutura de dados, e
seus andares, partições dessa estrutura. Como os andares são uma segmentação direta do prédio, estes
compõem então o que é chamado de estrutura unidimensional ( uma dimensão ).
Declaração:
tipo IDENTIFICADOR = vetor [LI..LF] de <tipo>;

IDENTIFICADOR : lista de variáveis;
Onde:
LI - é o valor inicial do vetor;
LF - é o limite final do vetor;
<tipo> - é qualquer um dos tipos básicos ou tipos anteriormente definido;
lista de variáveis - uma ou mais variáveis que terão o mesmo tipo denotado por
IDENTIFICADOR.
Página 40
Exemplo:
tipo CLASSE = vetor [1..40 ] de reais ;

CLASSE : VCLASSE;
VCLASSE
4.6 3.9 8.5 9.1 7.3 ..................... 2.4 1.5
1 2 3 4 5 39 40
LI e LF devem ser obrigatoriamente constantes inteiras e LF > LI.
As posições do vetor são identificadas a partir de LI, com incrementos unitários, até LF. O
números de elementos do vetor é dado por LF - LI + 1.
LI LI+1 LI+2 LI+3 LI+4 LF-1 LF
Ao imaginarmos o elevador de um prédio, sabemos que este é capaz de acessar qualquer

um de seus andares. Entretanto, não basta saber que andar desejamos atingir se não soubermos o nome
do edifício, pois qualquer um possui andares. O que precisamos, antes de mais nada, é saber o nome do
edifício e só então nos preocuparmos para qual daqueles andares queremos ir.
O mesmo acontece com os vetores, já que são compostos por diversas variáveis e, como
podem existir muitos vetores, torna-se necessário determinar primeiro qual vetor contém o dado
desejado e depois especificar em qual posição este se encontra.
Exemplo:
VCLASSE [ 5 ]
............................
1 2 3 4 5 40
O nome do vetor é determinado por meio do identificador que foi utilizado na definição de
variáveis, e a posição, por meio da constante, expressão aritmética ou variável que estiver dentro dos
colchetes, também denominada ÍNDICE.
Após isolar um único elemento do vetor, poderemos manipulá-lo através de qualquer

operação de entrada, saída ou atribuição.
Página 41
Exemplo:
V [5]  45;
leia (V [5]);
escreva (V [5]);
Exemplo:
O seguinte algoritmo calcula a média aritmética das notas de 10 alunos e depois mostra
quantas notas estão acima da média.
início
 tipo CLASSE = vetor [1..10] de reais;
 { declaração de variávei}
 CLASSE : VCLASSE;
 real : SOMA, MÉDIA;
 inteiro : NOTACIMA, X;
 SOMA  0;
 NOTACIMA  0;
 para X de 1 até 10 faça
  leia (VCLASSE [X]); {entrada das notas dos alunos }
 fimpara;
  SOMA  SOMA + VCLASSE [X];
 fimpara;
 MÉDIA  SOMA/10;
  se VCLASSE [X] > MÉDIA então
   NOTACIMA  NOTACIMA + 1;
  fimse;
 fimpara;
 escreva (NOTACIMA);
fim.
Exemplo 8 - Vetor
Página 42
Exercícios
22) Faça um algoritmo usando um vetor, para ler uma palavra com até 30 caracteres (letra a
letra). Após o usuário entrar com os caracteres, verificar quantas letras “A” possui essa palavra.
Exemplo: Se o usuário digitar a palavra “CASA”, o algoritmo deverá informar que essa palavra
possui 02 (duas) letras “A”.
23) Faça um algoritmo que carregue um vetor de notas, com 10 posições. Ache primeiramente a
média geral de notas, após achar a média, verifique quais as notas ficaram acima da média.
Página 43
Matrizes
Vamos supor que, além do acesso pelo elevador até um determinado andar, tenhamos
também a divisão desse andar em apartamentos. Para chegar a algum deles não basta só o número do
andar, precisamos também do número do apartamento.
Os vetores, por serem estruturas unidimensionais, necessitam somente de um índice para

endereçamento. Uma estrutura que precisasse de mais de um índice, como no caso do edifício dividido
em apartamentos, seria então denominada estrutura composta multidimensional, neste caso, de duas
dimensões (bidimensional).
Declaração:
tipo IDENTIFICADOR = matriz [LI1..LF1, LI2..LF2, ..., LIn..LFn] de <tipo>

Onde:
LI1..LF1, LI2..LF2, ..., LIn..LFn - são os limites dos intervalos de variação dos índices da
variável, onde cada par de limites está associado a um índice;
<tipo> - representa qualquer um dos tipos básicos ou tipos anteriormente definido;
lista de variáveis - lista de variáveis (separadas por vírgulas) que terão o mesmo tipo
denotado por IDENTIFICADOR.
Exemplo:
tipo SALA = matriz [1..4, 1..4] de inteiros;

SALA: MSALA;
O número de dimensões da matriz é igual ao número de intervalos.
O número de elementos é igual ao produto do número de elementos de cada dimensão:

(LF1-LI1+1)*( LF2-LI2+1)*...*( LFn-LIn+1).
Exemplo:
tipo M = matriz [1..3, 2..4] de reais;

M : MAT;
MAT tem duas dimensões e (3-1+1)*(4-2+1) = 9 elementos.
MSALA tem duas dimensões e (4-1+1)* (4-1+1) = 16 elementos.
Para acessar um elemento numa estrutura composta multidimensional- matriz -

precisamos, como num edifício, de seu nome, de seu andar e de seu apartamento. Considerando uma
estrutura bidimensional (dois índices: andar e apartamento), o primeiro índice indica linha e o segundo,
a coluna.
Página 44
Exemplo:
MSALA [2,3]
1 2 3 4
Podemos perceber que uma estrutura composta multidimensional é na realidade um

conjunto de vetores que são determinados por cada intervalo que compõe o tipo matriz.
Para manipular o vetor, nós o inserimos em um único laço de repetição, já que ele possui
apenas um índice. Como uma estrutura multidimensional possui mais de um índice, é necessária a
utilização de mais laços de repetição em mesmo número do que o número de dimensões da matriz.
As matrizes mais utilizadas são as bidimensionais, devido a sua direta relação com muitas
aplicações (por exemplo, tabelas), que devem possuir dois laços de repetição.
Exercícios
24) Crie um algoritmo que leia duas matrizes e inclua o valor da soma dessas matrizes em uma
terceira matriz.
Obs.: Todas as matrizes devem ser Real e ter 5 X 5 posições.
Página 45
Variáveis Compostas Heterogêneas
Um conjunto homogêneo de dados é composto por variáveis de mesmo tipo primitivo. Mas
podemos também criar conjuntos de dados de tipos diferentes. Deste modo teríamos um conjunto
heterogêneo de dados.
Registros
Para melhor entendimento desta estrutura de dados, vamos imaginar uma passagem de
ônibus, que é formada por um conjunto de informações logicamente relacionadas, porém de tipos
diferentes, tais como:
número da passagem (inteiro),

origem e destino (caractere ),
data (caractere),
horário (caractere),
poltrona (inteiro),
distância (real),
fumante (lógico).
Estas subdivisões do registro, são chamadas de campos.
Número: _________ Fumante: ____________
De: _____________________ Para: _____________________
Data: ___/___/_____ Horário: _____:_____
Poltrona: ______ Distância: ____________ Km
Declaração:
tipo IDENTIFICADOR = registro

 tipo1 : campo1;
 tipo2 : campo2;
 . .
 . .
 . .
 tipon : campon;
fimregistro;
Onde:
Página 46
IDENTIFICADOR - representa o nome associado ao tipo registro construído;
tipo1, tipo2, ..., tipon - podem ser qualquer um dos tipos básicos ou tipo anteriormente
definido;
campo1, campo2, campon - representam nomes associados a cada campo de registro;
lista de variáveis - lista de variáveis (separadas por vírgulas) que terão o mesmo tipo
denotado por IDENTIFICADOR.
Exemplo:
tipo REGPASSAGEM = registro

 inteiro : NÚMERO, POLTRONA;
 caractere : ORIGEM, DESTINO, DATA, HORÁRIO;
 real : DISTÂNCIA;
 lógico : FUMANTE;
fimregistro;
REGPASSAGEM : PASSAGEM;
Quando acessamos o registro genericamente, estamos referenciando obrigatoriamente

todos os campos por ele envolvidos.
Exemplo:
leia (PASSAGEM);
escreva (PASSAGEM);
Para utilizar um campo específico do registro, devemos diferenciar esse campo. Para tal
utilizamos o caractere "." (ponto) para estabelecer a separação do nome do registro do nome do campo.
Exemplo:
leia (PASSAGEM.POLTRONA);
escreva (PASSAGEM.FUMANTE);
Página 47
Exemplo:
início
 {definições anteriores}
 .
 .
 .
 leia (PASSAGEM.NÚMERO); {acesso específico}
 leia (PASSAGEM.ORIGEM); {a um campo do registro}
 leia (PASSAGEM.DESTINO);
 .
 .
 .
 escreva (PASSAGEM); {acesso genérico ao registro]
fim.
Os registros vistos até agora possuíam em seus campos apenas informações de tipos
primitivos, entretanto, podemos dispor também de campos que são compostos, ou seja, formados por
outros tipos construídos (vetores ou matrizes).
Exemplo de declaração:
a) tipo VDIAS = vetor [1..6] de inteiros;

tipo REGPROD = registro
 caractere : NOME;
 inteiro : CÓDIGO;
 real : PREÇO;
 VDIAS : BAIXA;
fimregistro;
REGPROD : PRODUTO;
Nome: ________________________________________
Código: _______________ Preço: _______________
1 2 3 4 5 6
Baixa:
Para acessar:
Página 48
PRODUTO.BAIXA [2]
b) tipo MATDIAS = matriz [1..4, 1..6] de inteiros;

tipo REGPROD2 = registro
 inteiro : CÓDIGO;
 real : PREÇO;
 MATDIAS : BAIXA;
fimregistro;
REGPROD2 : PRODUTO2;
Nome: ________________________________________
Código: _______________ Preço: _______________

1
1 2 3 4 5 6
Baixas: 2
2
3
Para acessar:
PRODUTO2.BAIXA [2,5]
Nas estruturas compostas homogêneas (vetores e matrizes) utilizamos tipos de dados

primitivos como sendo os elementos dessas estruturas. Agora utilizaremos como componente dessa
estrutura não apenas um tipo primitivo, mas sim os tipos construídos, neste caso os registros.
Exemplo:
Para manter um registro de informações relativas a passagens rodoviárias de todos os

lugares de um ônibus, utilizaremos um registro referente a cada poltrona (PASSAGEM), e
para agrupar todos eles utilizaremos um conjunto desses registros.
Como existem 44 lugares num ônibus, numerados seqüencialmente de 1 até 44, podemos,
para uni-los, criar um vetor no qual cada posição é um elemento do tipo construído
registro.
1
3
Número: _________ Fumante: ____________
De: _____________________ Para: _____________________
. Data: ___/___/_____ Horário: _____:_____

. Página 49
. Poltrona: ______ Distância: ____________ Km
Declaração:
tipo REGPASSAGEM = registro

 inteiro : NÚMERO, POLTRONA;
 caractere : ORIGEM, DESTINO, DATA, HORÁRIO;
 real : DISTÂNCIA;
 lógico : FUMANTE;
fimregistro;
tipo VETPASSAGEM = vetor [1..44] de REGPASSAGEM;
VETPASSAGEM : ÔNIBUS;
Exemplo:
O seguinte algoritmo lê e imprime todas as passagens de um ônibus com 44 lugares:
início
 { definição de tipos }
 tipo REGPASSAGEM = registro
  inteiro : NÚMERO, POLTRONA;
  caractere : ORIGEM, DESTINO, DATA, HORÁRIO;
  real : DISTÂNCIA;
  lógico : FUMANTE;
 fimregistro;
 tipo VETPASSAGEM = vetor [1..44] de REGPASSAGEM;
 VETPASSAGEM : ÔNIBUS;
 inteiro : N;
 para N de 1 até 44 faça
  leia (ÔNIBUS[N].NÚMERO);
  leia (ÔNIBUS[N].POLTRONA);
  leia (ÔNIBUS[N].ORIGEM);
  leia (ÔNIBUS[N].DESTINO);
  leia (ÔNIBUS[N].DATA);
  leia (ÔNIBUS[N].HORÁRIO);
  leia (ÔNIBUS[N].DISTÂNCIA);
  leia (ÔNIBUS[N].FUMANTE);
 fimpara;
 para N de 1 até 44 faça
  escreva (ÔNIBUS[N].NÚMERO);
  escreva (ÔNIBUS[N].POLTRONA);
  escreva (ÔNIBUS[N].ORIGEM);
  escreva (ÔNIBUS[N].DESTINO);
  escreva (ÔNIBUS[N].DATA);
  escreva (ÔNIBUS[N].HORÁRIO);
  escreva (ÔNIBUS[N].DISTÂNCIA);
  escreva (ÔNIBUS[N].FUMANTE);
 fimpara;
fim.
Exemplo 9 - Registro
Página 50
ARQUIVOS
Em nosso cotidiano é normal a utilização de arquivos para armazenar grandes quantidades

de informação com maleabilidade e por um grande período de tempo, como, por exemplo, os arquivos
mantidos por uma companhia telefônica acerca de seus assinantes.
Um arquivo é um conjunto de registros (ou seja, é uma estrutura de dados), no qual cada
registro não ocupa uma posição fixa dentro da estrutura, não possuindo, portanto, tamanho
preestabelecido. Os registros são formados por unidades de informação denominadas campos.
Como exemplo básico, utilizaremos um arquivo de amigos, no qual cada amigo é

catalogado por meio de um registro, compondo em seu conjunto um arquivo correspondente a todos os
amigos.
Vejamos a ficha de catalogação de amigos especificada:
Código do Amigo: _________________
Nome: _________________________________________________
Endereço: ______________________________________________
Telefone: _______________________ Idade: ___________
Data de Aniversário: ____/____/______ Sexo: ___________
Nesta ficha encontramos os dados referentes a um livro: Código, Nome, Endereço,

Telefone, Idade, Data de Aniversário e Sexo, que formam uma estrutura de dados denominada registro:
Código Nome Endereço Telefone Idade Data Aniv. Sexo
244 Pedro XXXX 999999 XX YYY MASC
A relação lógica existente entre as informações é que refere ao mesmo amigo, assim, se
armazenássemos todas as fichas de controle, formaríamos o arquivo de amigos.
Página 51
Arquivo de Amigos:
Código do Amigo: 766
Código Nome:
do Amigo: 690
_____________________________________________
Código Nome: Endereço:

do Amigo: 140 __________________________________________
_____________________________________________
Telefone: _______________________ Idade: _______
Código Nome: Endereço:
do Amigo: 320 __________________________________________
_____________________________________________
Data de Aniversário: ____/____/______ Sexo: ___________
Nome: Pedro Telefone: _______________________ Idade: _______
Endereço: ___________________________________________
Endereço: Data de Aniversário: ____/____/______
XXXX Sexo: ___________
Telefone: _______________________ Idade: ________
Telefone: 999999
Data de Aniversário: ____/____/______Idade: XX
Sexo: ___________
Data de Aniversário: YYY Sexo: MASC
Como um arquivo é um conjunto de registros, precisamos definir o registro que compõe o

arquivo primeiro, para somente então definir o arquivo. Segundo nosso exemplo, cada amigo é
representado por uma ficha e esta é implementada por um registro.
tipo AMIGO = registro

 inteiro: CÓDIGO, IDADE;
 caractere: NOME, ENDEREÇO, TELEFONE, DATA, SEXO;
fimregistro;
Podemos então, definir o arquivo, segundo a sintaxe abaixo:
tipo IDENTIFICADOR = arquivo composto de <tipo>;

IDENTIFICADOR: lista de variáveis;
Onde:
IDENTIFICADOR - é o nome do tipo arquivo;
<tipo> - é o nome do tipo registro previamente definido;
lista de variáveis - variáveis que serão do tipo arquivo definido;
Deste modo, teríamos:

Página 52
tipo AMIGO = registro

 inteiro: CÓDIGO, IDADE;
 caractere: NOME, ENDEREÇO, TELEFONE, DATA, SEXO;
fimregistro;
tipo ARQAMIGO = arquivo composto de AMIGO ;
AMIGO: FICHA;
ARQAMIGO: TODOS;
Onde:
AMIGO - é o identificador da estrutura do tipo registro que formará o arquivo;
ARQAMIGO - é o identificador do tipo associado ao arquivo, formado pêlos tipos de

registro AMIGO;
FICHA - é a variável de registro;
TODOS - é a variável de arquivo;
As variáveis FICHA e TODOS serão utilizadas no algoritmo para a manipulação do

arquivo; são as variáveis que armazenarão as informações.
Podemos admitir que todo arquivo possui maneiras semelhantes de ser manipulado,
independentemente de como foi concebido.
Podemos consultar e/ou acrescentar alguma informação ao arquivo. Temos, então,

algoritmos básicos envolvidos nestas duas circunstâncias:
Consultar arquivo Acrescentar arquivo
Abrir arquivo Abrir arquivo
Achar ficha procurada Achar posição de inserção
Copiar informações da ficha Guardar ficha nova
Fechar arquivo Fechar arquivo
Abrindo um Arquivo
Não podemos obter alguma informação contida num arquivo sem antes abri-lo. Em nossos
algoritmos, isto será feito através do seguinte comando:
Página 53
abra ( ARQUIVO ) ;
Onde:
ARQUIVO - é o identificador da variável de arquivo previamente definida
Exemplos:
abra (TODOS);
Após a execução deste comando (de abertura), a ficha que está à disposição será sempre a
primeira que foi nele armazenada.
Fechando um Arquivo
Não devemos manter um arquivo aberto depois de usá-lo, por isso, convém sempre fechar
os arquivos após sua utilização. Para tal, usaremos o seguinte comando:
fecha ( ARQUIVO ) ;
Onde:
Exemplos:
fecha (TODOS);
Copiando um Registro
Num arquivo não se devem retirar informações, pois se assim fosse ele se tornaria vazio
rapidamente. Devemos enfatizar que, via de regra, um arquivo não deve ser "consumido" e sim
consultado, e, para tal, precisamos copiar o conteúdo que nos interessa em algum lugar. Para tanto,
utilizaremos:
Página 54
copie ( ARQUIVO , REGISTRO ) ;
Onde:
ARQUIVO - é o identificador da variável de arquivo previamente definida;
REGISTRO - é o identificador de um registro de formato igual àquele que

compõe o arquivo.
Exemplo:
copie (TODOS, FICHA);
Neste comando copiam-se as informações da posição corrente do arquivo para o registro

especificado no comando, o qual possui um formato idêntico ao do registro que compõe o arquivo.
Todos os campos do registro do arquivo são copiados para os respectivos campos do registro
estabelecido no comando.
Guardando um Registro
Para guardarmos um registro no arquivo, é necessário que este possua estruturação de

campos idêntica à dos registros já armazenados, e ao mesmo tempo esteja complemente preenchido.
Para efetuar esta operação, temos o comando:
guarde ( ARQUIVO , REGISTRO ) ;
Onde:
REGISTRO - é o identificador de um registro de formato igual àquele que

compõe o arquivo.
Exemplo:
guarde (TODOS, FICHA);
Neste comando guarda-se sempre alguma informação de dado registro (definido no

comando) para a posição atual do arquivo.
Página 55
Acesso Seqüencial
Quando a gravação dos registros ( que não estão em ordem) no arquivo é feita de forma
contínua, um após o outro, estaremos estabelecendo uma circunstância de seqüência no
armazenamento dos registros, obtendo um arquivo de acesso seqüencial, ou seja, para acessar um
registro específico precisamos obedecer a sua ordem de gravação, o que implica percorrer todos os
registros que o antecedem.
Neste caso, para guardarmos um registro no arquivo, precisamos ir até o fim do arquivo,
para então armazenarmos o registro.
Podemos fazer isso da seguinte forma:
avance ( ARQUIVO ) ;
Onde:
Este comando posiciona o arquivo na posição consecutiva, ou seja, no próximo registro. Se

utilizado repetidas vezes permite percorrer o arquivo passando por uma série consecutiva de registros.
E também com o auxílio de:
Fda ( ARQUIVO ) ;
Onde:
Esta instrução retorna verdadeiro quando a posição corrente é o Fim Do Arquivo, e falso
em caso contrário.
Página 56
Exemplo:
O seguinte algoritmo guarda números de telefones em uma agenda telefônica:
início
 tipo PESSOA = registro
  caractere : NOME;
  inteiro: FONE;
 fimregistro;
 tipo PESSOAL = arquivo composto de PESSOA;
 PESSOA : AUX;
 PESSOAL : AGENDA;
 abra (AGENDA);
 repita
  avance (AGENDA);
 ate fda (AGENDA);
 leia (AUX.NOME, AUX.FONE);
 guarde (AGENDA, AUX);
 feche (AGENDA);
fim.
Observamos que:
- Sempre que o comando Abra é executado, deparamo-nos com o primeiro conjunto de

informações armazenada, ou seja, a posição corrente do arquivo é o primeiro registro;
- Somente podemos guardar o registro quando este estiver complemente preenchido, o

que neste caso foi garantido com um comando de leitura sobre ambos os campos;
- O comando Guarde armazenará todas as informações contidas no registro (registro

completo) na posição corrente do arquivo, a qual foi premeditadamente selecionada
como a última posição do mesmo.
Exemplo:
Página 57
Este algoritmo atualiza o telefone de um amigo específico, na agenda de telefones:
início
 tipo PESSOA = registro
  inteiro: FONE;
 fimregistro;
 tipo PESSOAL = arquivo composto de PESSOA;
 PESSOA : AUX;
 PESSOAL : AGENDA;
 caractere : NOMEPROCURADO;
 inteiro : NOVOFONE;
 abra (AGENDA);
 leia (NOMEPROCURADO);
 copie (AGENDA, AUX);
 enquanto (AUX.NOME <> NOMEPROCURADO) e (não fda (AGENDA)) faça
  avance (AGENDA);
  copie (AGENDA, AUX);
 fimenquanto
 se (AUX.NOME = NOMEPROCURADO) então
  início
   escreva (AUX.NOME, " possui fone ",AUX.FONE);
   escreva ("Novo telefone");
   leia (NOVOFONE);
   AUX.FONE  NOVOFONE;
   guarde (AGENDA, AUX);
  fim;
 senão escreva ("Telefone não registrado!");
 fimse;
 feche (AGENDA);
fim.
Exemplo 10 - Arquivo (Acesso Seqüencial)
Acesso Direto
Em um arquivo de acesso direto, ao contrário de um de acesso seqüencial, os registros não

ficam localizados na ordem em que são gravados, o que leva a entender que cada registro possui um
lugar "reservado" para ser guardado, lugar este identificado através da chave.
Neste caso, o acesso não é feito de forma seqüencial, um após o outro, e sim de forma
direta.
Vamos imaginar, por exemplo, a situação de um professor que deseja armazenar

informações referentes a uma de suas turmas, como o nome do aluno e suas quatro notas (bimestrais).
Para tanto, ele utiliza como chave o código de chamada do aluno, informação que também faz parte
Página 58
integrante do registro e é única, ou seja, cada aluno possui seu número, não havendo possibilidade de
números iguais.
À medida que o professor possui a nota de um aluno, precisa cadastrá-la no arquivo,

guardar suas informações no lugar "reservado" para esse registro. A posição é conhecida pela chave de
acesso (código do aluno) e, para que a posição corrente do arquivo passe a ser a indicada pela chave,
utilizamos o comando:
posicione ( ARQUIVO , CHAVE ) ;
Onde:
CHAVE - é um inteiro (constante ou variável) que indica a posição corrente desejada.
Exemplo:
O seguinte algoritmo permite saber a nota de algum aluno já cadastrado, procurando

diretamente o conjunto de informações desse aluno no arquivo, ou seja, acessando o registro de forma
instantânea através de sua chave.
início
 tipo ALUNO = registro
  inteiro : NÚMERO;
  real : N1, N2, N3, N4;
 fimregistro ;
 tipo SALA = arquivo composto de ALUNO;
 ALUNO: AUX;
 SALA: DIÁRIO;
 inteiro : NÚMEROALUNO;
 abra (DIÁRIO);
 leia (NÚMEROALUNO);
 posicione (DIÁRIO, NÚMEROALUNO);
 copie (DIÁRIO, AUX);
 escreva (AUX.NOME, "possui nota", AUX.N1);
 feche (DIÁRIO);
fim.
Exemplo 11 - Arquivo (Acesso Direto)
Página 59
MÓDULOS
Ao transformar a lógica em algoritmos, desenvolvemos seqüências de passos que

representam as ações que levam à resolução de um determinado problema. Essas ações eram dirigidas
segundo as estruturas de controle (seqüência, seleção e repetição), totalizando assim o algoritmo e
representando-o com sendo um único bloco lógico (INÍCIO... FIM).
À medida que os problemas a serem solucionados se tornam mais complexos, ou seja,

apresentam uma variedade maior de situações diferentes a serem resolvidas, temos, então, uma série de
pequenos problemas, cujas respectivas soluções integrarão o conjunto de ações definitivo.
Quando tal conjunto é construído, podemos nos deparar literalmente com um amontoado
de ações que afetam a legibilidade, porque não ficam claras e concisas as pequenas partes lógicas que
solucionam cada pequeno problema, o que dificulta a assimilação desta construção por outra pessoa,
além de inviabilizar uma perfeita coesão interna do algoritmo.
Como técnica de combate a essas circunstâncias, utilizamos uma estrutura que explicite as
pequenas soluções, o que resulta numa atividade conhecida por modularização.
O que é módulo?
Ao modularizar um algoritmo, buscamos aumentar a funcionalidade das partes do conjunto

solução, separando-as logicamente, em módulos.
Para delimitar um módulo, utilizamos os delimitadores módulo e fimmódulo:
módulo IDENTIFICADOR AÇÃO fimmódulo ;
Exemplo:
módulo <IDENTIFICADOR> {início do bloco lógico}


 {declarações das variáveis internas}

 {conjunto de ações}

fimmódulo; {fim do bloco lógico}
Página 60
Onde:
IDENTIFICADOR - é o nome pelo qual o módulo será referenciado no algoritmo.
Quando construímos um módulo, estamos, na verdade, construindo um algoritmo em

instância menor, ou seja, um pequeno conjunto solução, praticamente independente.
Este subalgoritmo pode inclusive utilizar outros módulos.
Com o emprego de subalgoritmos utilizados especificamente para resolver problemas

pequenos, aumenta-se o grau de clareza, facilitando a compreensão de cada parte isoladamente, assim
como o relacionamento entre elas.
A ativação de um módulo ocorre quando um determinado ponto do algoritmo contém o
identificador que foi usado na definição do módulo, o que é conhecido por chamada (ou ativação) do
módulo, que por sua vez representa a execução das ações deste naquele trecho do algoritmo.
Exemplificando:
______________
________________
________________ módulo PRIMEIRO;
_________________ ________________
____________________
PRIMEIRO; __________________
_________________ ______________
________________ fimmódulo;
_______________
________________ módulo SEGUNDO;
________________ ____________________
________________
SEGUNDO;
____________________
_____ _______________
______________ fimmódulo;
_________________
_________________
Escopo de Variáveis
Conforme dividimos um algoritmo em conjuntos de ações, que compõem os módulos,

devemos agrupar as variáveis coerentemente, ou seja, de acordo com o seu emprego na estrutura
definida. Todas as variáveis utilizadas no algoritmo encontram-se declaradas no seu início, o que as
torna passíveis de aplicação por qualquer módulo integrante. Estas variáveis são denominadas globais.
Em alguns casos, uma determinada variável é utilizada apenas por um módulo específico,
o que não justifica uma definição global, pois somente se fazem necessários o conhecimento e a
utilização dessa variável dentro dos limites desse bloco lógico.
Página 61
Esta situação ocorre quando a variável é declarada internamente ao módulo e é

denominada variável local.
O escopo de uma variável, na realidade, denota a sua visibilidade (conhecimento e

aplicações) perante os diversos módulos integrantes do algoritmo. A visibilidade é relativa à
hierarquia, podemos dizer então que uma variável é global a todos os módulos hierarquicamente
inferiores e é local quando é visível apenas em seu contexto e não aos módulos hierarquicamente
superiores.
Passagem de Parâmetros
Quando modularizamos um algoritmo, procuramos identificar problemas de instância

menor que possam ser desenvolvidos separadamente, pois possuem uma independência relativa ao
conjunto solução total.
Com freqüência, nesta atividade podem ser encontrados subproblemas semelhantes, que
divergem no tratamento de circunstâncias específicas, cuja conseqüência é a elaboração de vários
subalgoritmos que possuem, em essência, a mesma solução.
Transpomos esta circunstância à medida que conseguimos conceber um módulo capaz de

satisfazer a todas as necessidades dos problemas, ou seja, generalizamos a solução.
A generalização pode ser obtida através da parametrização da solução, isto é, da

composição de atributos cuja alteração de valores modifica a solução do problema sem modificar a sua
natureza. Criar parâmetros significa definir variáveis que servem para transformar informações
específicas que funcionam como entrada para o conjunto de ações do módulo que está sendo ativado.
Sintaxe da declaração de um módulo com passagem de parâmetro:
módulo IDENTIFICADOR ( tipo : variável )
AÇÃO fimmódulo ;
Página 62
Exemplo:
módulo <IDENTIFICADOR> (tipo : V1, V2, V3)


 {declarações das variáveis internas}

 {conjunto de ações}

fimmódulo; {fim do bloco lógico}
Onde:
IDENTIFICADOR - é o nome pelo qual o módulo será referenciado no algoritmo.
V1, V2 E V3 - são as variáveis declaradas como os parâmetros do módulo
Na utilização de módulos que devem receber informações através de seus parâmetros,

devemos enviá-las junto à chamada do módulo através de variáveis e/ou constantes, na respectiva
ordem de declaração dos parâmetros. Por exemplo, no seguinte módulo que efetua a troca recíproca de
conteúdo de duas variáveis:
módulo TROCA (inteiro : X, Y)

 inteiro : AUX;
 AUX  X;
 X  Y;
 Y  AUX;
fimmódulo;
Supondo o seguinte trecho de algoritmo:
.
.
.
A  12;
B  5;
TROCA (A, B);
escreva (A, B);
.
.
.
Quando chamamos o módulo troca, o valor de A (12) é transferido para seu respectivo
parâmetro X, assim como o de B (5) é transferido para Y. Após executadas todas as ações do módulo,
X valerá 5 e Y, 12, e, ao retornar, os valores X e Y são transferidos respectivamente para A e B,
concretizando assim a troca de conteúdos.
Página 63
Retornando Valores de um Módulo
Para que um módulo possa retornar um valor, ou seja, devolver um resultado como
resposta, será necessário que explicitemos qual é o valor a retornar, o que será efetuado através do
comando:
retorne ( expressão ) ;
Exemplo:
retorne (10);
retorne (SOMA);
retorne (X*Y);
O seguinte módulo verifica o sinal de um número que recebe como parâmetro, sendo que
ele retorna -1 se o número for negativo, 0 se o número for nulo e +1 se for positivo:
módulo SINAL (inteiro : X)

 se X > 0 então
  retorne (1);
 senão
  se X = 0 então
   retorne (0);
  senão
   retorne (-1);
  fimse;
 fimse;
fimmódulo;
Supondo o seguinte trecho de algoritmo:
.
.
.
V  -3;
S  SINAL (V);
escreva (S);
.
.
.
Página 64
O valor de V (-3) é enviado como parâmetro ao módulo SINAL, onde é recebido e
utilizado através do argumento X; usando as comparações, o módulo retorna o devido valor, no caso,
-1, que será o valor atribuído a variável S e exibido pelo comando escreva.
Devemos tomar cuidado ao utilizarmos módulos com retorno de resultado, pois quando
atribuímos o retorno do módulo a uma variável, recebemos um valor de mesmo tipo ao da expressão
utilizada no comando retorne, sendo necessária a compatibilidade de tipos. ESTRUTURA DE DADOS
AVANÇADA
Listas
Lista, ou lista encadeada é um conjunto de elementos individualizados em que cada um

referencia um outro elemento distinto como sucessor.
Sobre o elo ou ligação existente entre dois elementos também pode-se dizer que cada
elemento "aponta para" um sucessor, o que quer dizer que cada elemento indica o próximo elemento
da lista como se apontasse para ele.
Exemplo:
Para compor uma lista precisamos de um vetor de registros que segundo o exemplo seria:
tipo REG = registro

 caractere : ITEM;
 inteiro : PROX;
fimregistro;
tipo VET = vetor [1..100] de REG;
VET : LISTA;
inteiro : INÍCIO;
INÍCIO  2
Usaremos a variável início como referência ao ponto de partida da lista encadeada e o

valor 0 (ou outro valor não válido) como fim da lista.
Vejamos então como fica a disposição dos elementos da lista ao longo da estrutura de
dados utilizada:
azul 7 rosa 4 verde 6 amarelo 1 branco 0 roxo 8 laranja 3 marrom 5
1 2 3 4 5 6 7 8
O que vem a representar o seguinte encadeamento lógico:
Página 65
início fim
rosa amarelo azul laranja verde roxo marrom branco
Inserção de Elementos em uma Lista
Qualquer elemento que fosse inserido neste vetor seria alocado a partir da posição nove,
porém, devido à independência dos elementos, poderia estar logicamente encadeado em qualquer lugar
da lista: supondo que fosse necessário incluir vermelho na lista de cores, temos três possibilidades:
1) No meio da lista
vermelho(9)
Antes
laranja(7) verde(3)
vermelho(9)
1º passo
laranja(7) verde(3)
vermelho(9) 2º passo
laranja(7) verde(3)
1º passo: LISTA[9].PROX  LISTA[7].PROX;

2º passo: LISTA[7].PROX  9;
2) No fim da lista
vermelho(9)
Antes
branco(5) 0
vermelho(9)
1º passo
branco(5) 0
Página 66
vermelho(9)
2º passo
branco(5) 0
1º passo: LISTA[9].PROX  LISTA[5].PROX;

2º passo: LISTA[5].PROX  9;
3) No início da lista
vermelho(9)
Antes
início rosa(2)
vermelho(9)
1º passo
início rosa(2)
vermelho(9)
2º passo
início rosa(2)
1º passo: LISTA[9].PROX  INÍCIO;

2º passo: INÍCIO  9;
Para melhor generalizarmos todos os casos de inserção, criamos o seguinte módulo:
módulo INSERE (inteiro: NOVO, ANTECESSOR)

 LISTA [NOVO].PROX  ANTECESSOR;
 ANTECESSOR  NOVO;
fimmódulo;
Usamos como primeiro parâmetro (NOVO) a posição do novo elemento a ser inserido no
vetor da lista, e como segundo parâmetro (ANTECESSOR) o elemento que precederá aquele que será
inserido.
Exemplo:
INSERE (9,LISTA[7].PROX); (1)

INSERE (9,INÍCIO); (3)
Página 67
Remoção de Elementos em uma Lista
Qualquer elemento que fosse removido seria simplesmente "desligado" da lista, isto é,
nenhum outro elemento da lista apontaria para ele, mesmo que continuasse ocupando uma das
posições do vetor. Para remoção também temos três situações:
1) No meio da lista
Antes
azul(1) laranja(7) verde(3)
1º passo
azul(1) laranja(7) verde(3)
1º passo: LISTA[1].PROX  LISTA[7].PROX
2) No início da lista
Antes
início rosa(2) amarelo(4)
1º passo
início rosa(2) amarelo(4)
1º passo: INÍCIO  LISTA[2].PROX
3) No fim da lista
Antes
marrom(8) branco(5) fim
1º passo
marrom(8) branco(5) fim
Página 68
1º passo: LISTA[8].PROX  LISTA[5].PROX
Para melhor generalizarmos todos os casos de remoção num único módulo, temos:
módulo REMOVE (inteiro: VELHO, ANTECESSOR)

 ANTECESSOR  LISTA[VELHO].PROX;
fimmódulo;
Usamos como primeiro parâmetro (VELHO) a posição do elemento a ser removido do

vetor da lista, e como segundo parâmetro (ANTECESSOR) a antiga posição ao elemento que será
removido.
Exemplo:
REMOVE (7,LISTA[1].PROX); (1)

INSERE (2,INÍCIO); (2)
Observamos que no exemplo desenvolvido nos preocupamos com os passos fundamentais,

ou seja, desconsideramos o tratamento de exceções, tais como a verificação da existência do elemento
a ser removido ou mesmo da existência de elementos na lista, o que numa real aplicação seria
indispensável.
Filas
Filas são estruturas de dados que se comportam assim como as filas que conhecemos. Na
verdade, uma fila nada mais é do que uma lista na qual é aplicada uma disciplina de acesso
característica: todo elemento que entra na lista entra no fim desta e todo elemento que sai, sai do início
da lista, exatamente como uma fila real; daí utilizar a denominação fila a esta lista. Esta disciplina de
acesso também é conhecida por PEPS - primeiro que entra, primeiro que sai ( = FIFO - first in, first
out), ou seja, qualquer elemento que tenha entrado numa fila sai da mesma antes de qualquer outro que
tenha entrado depois dele. Portanto, fila é a lista em que todo elemento entra no final e sai no início, e
possui como principal finalidade registrar a ordem de chegada de seus componentes.
Exemplo:
Utilizaremos um exemplo de fila bancária. Para tal aplicaremos as seguintes definições:
tipo REG = registro

 inteiro : PROX;
fimregistro;
VET : FILA;
inteiro : INÍCIO, FIM;
INÍCIO  4;
FIM  2.
Página 69
Vejamos então como fica a disposição dos elementos da lista ao longo da estrutura de
dados utilizada:
Maria 3 João 0 Nelson 5 Pedro 1 Silvia 2
1 2 3 4 5
O que vem a representar o seguinte encadeamento lógico:
início fim
Pedro Maria Nelson Silvia João
Inserção de Elementos em uma Fila
De acordo com a definição de fila, todas as inserções são feitas no final com o auxílio de
uma variável que indica a posição do último da fila.
fim
Antes
João(2) Bete(6)
fim
1º passo
João(2) Bete(6)
fim
2º passo
João(2) Bete(6)
Página 70
1º passo: FILA [2].PROX  6;
2º passo: FIM  6;
Para criar um módulo de inserção numa fila, precisamos apenas identificar qual é o
elemento a ser inserido, o que é estabelecido através do parâmetro novo.
módulo ENTRA (inteiro: NOVO)

 FILA [FIM].PROX  NOVO;
 FIM  NOVO;
fimmódulo ;
Exemplo:
ENTRA (6);
ENTRA (7);
Remoção de Elementos em uma fila
De maneira similar à inserção, todas as remoções são feitas no início da fila.
início
Antes
Pedro(4) Maria(1)
fim
1º passo
Pedro(4) Maria(1)
1º passo: INÍCIO  FILA[4].PROX
Para remover um elemento de uma fila, podemos construir um módulo da seguinte forma:
módulo SAI;
 se INÍCIO < FIM então
 INÍCIO  FILA [INÍCIO].PROX;
 fimse;
fimmódulo ;
Página 71
Exemplo:
SAI;
SAI;
As situações de erro devem ser tratadas necessariamente num algoritmo completo, bem
como a utilização de módulos mais específicos à circunstância gerada.
Pilhas
Assim como as filas, as pilhas são listas nas quais é aplicada uma disciplina de acesso
antagônica denominada UEPS - último que entra, primeiro que sai (= LIFO last in, first out), ou seja,
qualquer elemento que entrar na pilha somente sairá quando todos os que entraram depois dele saírem.
Portanto, pilha é a lista na qual todo elemento entra no final e sai também no final, e possui como
finalidade principal tornar disponíveis primeiro os elementos mais recentes.
Exemplo:
Utilizaremos um exemplo de fila bancária. Para tal aplicaremos as seguintes definições:
tipo REG = registro

 caractere : LOCAL;
 inteiro : PROX;
fimregistro;
VET : PILHA;
inteiro : TOPO;
TOPO  2.
A pilha representada no vetor ficaria assim esquematizada:
cama 3 cadeira 4 sofá 5 mesa 1 armário 0
1 2 3 4 5
E a estrutura pilha:
topo
armário sofá cama mesa cadeira
Página 72
Inserção de Elementos em uma Fila
De acordo com a definição de pilha, todas as inserções, também denominadas

empilhamentos, são feitas no final com o auxílio de uma variável que indica a posição do topo da
pilha.
topo
Antes
cadeira(2) estante(6)
topo
1º passo
topo
2º passo
1º passo: PILHA [6].PROX  2

2º passo: TOPO  6;
Para criar um módulo de inserção numa pilha, precisamos apenas identificar qual é o
elemento a ser inserido, o que é estabelecido através do parâmetro NOVO.
módulo EMPILHA (inteiro : NOVO);

 PILHA [ NOVO].PROX  TOPO
 TOPO  NOVO;
fimmódulo ;
Exemplo:
EMPILHA(6);
EMPILHA(7);
Página 73
Removendo Elementos de uma Pilha
De maneira similar à inserção, todas as remoções, também denominadas

desempilhamentos, são feitas no topo da pilha.
topo
Antes
mesa(4) cadeira(2)
topo
1º passo
mesa(4) cadeira(2)
1º passo: TOPO  PILHA [2].PROX;
Para retirar um elemento da pilha, podemos utilizar um módulo sem utilizar nenhum
parâmetro, da seguinte forma:
módulo DESEMPILHA ;
 TOPO  PILHA [TOPO].PROX;
fimmódulo ;
Exemplo:
DESEMPILHA;
DESEMPILHA;
Para uma real aplicação da pilha, devemos levar em conta o tratamento de exceções tais
como uma remoção na qual a pilha não deve estar vazia. Outros módulos mais específicos podem ser
desenvolvidos de acordo com a circunstância de cada aplicação.
Árvores
É uma lista na qual cada elemento possui dois ou mais sucessores, porém, todos os
elementos possuem apenas um antecessor, como ilustra a figura:
Página 74
I
B E J
K
A F
D H L
O primeiro elemento, que dá origem aos demais, é chamado de raiz da árvore; qualquer
elemento é chamado de nó; a quantidade de níveis a partir do nó raiz até o nó mais distante é dita
altura da árvore; assim como o número máximo de ramificações a partir de um nó é denominado grau.
Numa estrutura em árvore, os sucessores de um determinado nó são chamados filhos ou descendentes,
o único antecessor de um dado elemento é chamado pai ou ancestral e cada elemento final (sem
descendentes) é conhecido por folha. Assim, no exemplo acima, F e G são descendentes (filhos) de C,
assim como H é o ancestral (pai) de L. A árvore possui raiz em A, altura 4 , grau 3 e folhas F, G, I, J, K
e L.
Exemplo:
O vetor de registros que foi usado sem problemas até aqui precisará sofrer modificações,
visto que cada elemento da árvore pode assumir diversos sucessores. Utilizaremos, portanto, a seguinte
estrutura:
tipo VETFILHO = vetor [1..4] de inteiros ;

tipo NO = registro
 caractere : INFO;
 inteiro : FILHO;
fimregistro;
tipo VET = vetor [1..1000] de NO;
VET : ÁRVORE;
Página 75
O vetor de sucessores (filhos) deve sempre ser inicializado com zero, e quando um filho
vale zero representa que não possui descendente. Uma árvore se apresenta sob o formato linear em seu
vetor.
A 2 3 4 0 B 5 0 0 0 C 6 7 0 0 D 8 0 0 0 E 9 1011 0 F 0 0 0 0 G 0 0 0 0 ...
1 2 3 4 5 6 7
Podemos ilustrar a árvore, para facilitar a visualização, como segue:
B C D
E F G H
L
I J K
Página 76
O algoritmo a seguir percorre toda uma árvore e descobre a localização de um determinado
nó, caso exista:
início
 tipo VETFILHO = vetor [1..4] de inteiros ;
 tipo NO = registro
  caractere : INFO;
  inteiro : FILHO;
 fimregistro;
 tipo VET = vetor [1..1000] de NO;
 VET : ÁRVORE;
 tipo REG = registro
  caractere : LOCAL;
  inteiro : PROX;
 fimregistro;
 tipo VTP = vetor [1..100] de REG;
 VTP: PILHA;

 inteiro: NO, TOPO, I;

 módulo EMPILHA (inteiro : NOVO)
  PILHA [NOVO].PROX  TOPO;
  TOPO  NOVO;
 fimmódulo;

 módulo DESEMPILHA
  TOPO  PILHA[TOPO].PROX;
 fimmódulo; Conteúdo do nó desejado

 TOPO  0;
 NO  1;
 enquanto ÁRVORE[NO].INFO <> "MAR" faça
  para I de 4 até 1 passo -1 faça
   se ÁRVORE[NO].FILHO[ i ] <> 0 então
    EMPILHA (ÁRVORE[NO].FILHO [ i ] ;
   fimse;
  fimpara;
  NO  TOPO;
  DESEMPILHA;
 fimenquanto;
 se ÁRVORE[NO].INFO = "MAR" então
  escreva ("Nó existente",NO);
 senão
  escreva ("Nó não existente");
 fimse;
fim.
Nesta apostila, foi abordado apenas um método de busca em árvore, entre muitos outros
existentes, além do que não foi abordada nenhuma técnica de inserção e remoção, pois estas dependem
da estrutura da árvore (grau, ordenação, ....)
Página 77
INTRODUÇÃO À LINGUAGENS DE PROGRAMAÇÃO
Neste capítulo vamos aprender a definição de várias expressões que, embora sejam muito
comuns na área de informática, são desconhecidas por muitas pessoas que ainda se confundem com o
seu significado.
Linguagem de Programação
Linguagem de programação é uma linguagem usada para se fazer programas de

computador. Uma linguagem de programação nada mais é do que um conjunto de palavras e
expressões, assim como uma língua falada em um país, por exemplo, o português ou o inglês. A
linguagem de programação também possui uma "gramática" que define como suas palavras e
expressões devem ser usadas.
Quem usa uma linguagem de programação para fazer programas é um programador. Para
se usar uma linguagem de programação é necessário ter um conhecimento dela, nem que seja básico,
do mesmo jeito que se precisa saber inglês para se usar o inglês.
É com o uso de uma linguagem de programação que nós "dizemos" para o computador o
que é para ele fazer, através do programa (que foi escrito, linha por linha, em uma linguagem de
programação escolhida).
Existem várias linguagens de programação hoje em dia. Algumas, mais antigas, já estão
ultrapassadas pois seus recursos tornaram-se limitados à medida que foram surgindo outras linguagens,
mais novas e mais potentes. Existem também diferentes tipos de linguagens de programação
( estruturada, orientada à objetos, visual, de formatação, etc...)que serão vistos mais adiante.
Exemplos de linguagens de programação: Pascal, Cobol, Clipper, C, C++, Visual Basic,

Delphi, Java, HMTL, etc.
Compilador
Depois que escrevemos um programa utilizando uma determinada linguagem, precisamos

compilá-lo. Quem compila um programa é o compilador. O compilador percorre todas as linhas do
nosso programa verificando se a linguagem foi utilizada corretamente, ou seja, se foram respeitadas
suas regras de utilização. Após fazer essa verificação, se estiver tudo de acordo, o compilador então
"traduz" o nosso programa para o computador, numa linguagem que o computador entenda. Daí então
o nosso programa está pronto para ser rodado.
Cada linguagem de programação possui o seu compilador, que conhece todas as suas
palavras, expressões e regras de utilização.
Para se fazer um programa é imprescindível, além do uso de uma linguagem de

programação, o uso do compilador.
Página 78
Código Fonte
Quando escrevemos um programa, usando uma linguagem de programação, é claro,

estamos escrevendo o código fonte do programa, ou seja , onde serão buscadas todas as instruções do
que é para ser feito pelo computador. Em outras palavras, o código fonte de um programa é o conjunto
de todas as instruções (palavras e expressões da linguagem) que tem como objetivo o próprio objetivo
do programa.
O código fonte, em algumas linguagens, é um arquivo com a extensão correspondente à

linguagem com a qual foi escrito. Por exemplo, o código fonte de um programa escrito em Pascal
possui a extensão .PAS, na linguagem C possui a extensão .C, etc...
O código fonte é o programa antes de se tornar executável. Ele só roda no ambiente de

programação da linguagem utilizada.
Executável
Depois que escrevemos um programa e o compilamos, podemos gerar o executável deste

programa. O executável é um arquivo com a extensão .EXE. Este arquivo pode ser rodado em
qualquer diretório do seu computador ou em um outro computador, diferente do programa que não é
executável (sem extensão .EXE) que só roda no editor da linguagem com a qual foi escrito. Editor de
linguagem é o ambiente de programação de uma linguagem específica. Neste ambiente é escrito o
código fonte do programa e nele está o compilador.
Sistema Operacional
Todo computador, para funcionar, precisa de um sistema operacional. Sistema Operacional

nada mais é do que um programa que inicializa o computador, fazendo a checagem nos drivers
existentes, o reconhecimento dos discos rígidos existentes, a identificação do processador, etc. Estas
ações são realizadas quando ligamos o computador e aparecem várias coisas na tela, antes de entrar no
Windows. Além disso, o sistema operacional faz a interface, ou seja, uma ligação entre o usuário e o
computador.
Exemplo de sistemas operacionais: DOS, OS/2, UNIX .
Página 79
Linguagem de Máquina
Linguagem de máquina também é uma linguagem de programação, só que de baixo nível,

ou seja, para ser usada diretamente com a máquina (computador). Linguagens como Pascal, C, Visual
Basic e Delphi, são linguagens de alto nível, ou seja, são usadas diretamente com os usuários
(programadores) e depois são traduzidas pelo compilador para uma linguagem de máquina, que é
entendida pelo computador. Em outras palavras, o computador não entende um programa escrito em
uma linguagem de alto nível. É preciso que este programa seja traduzido para uma linguagem de
máquina (o que é feito pelo compilador), para então o computador saber o que deve ser feito, e faze-lo.
As linguagens de alto nível são criadas usando-se linguagens de baixo nível .
Exemplo de linguagem de máquina: Assembler.
Linguagens para DOS
Linguagens para DOS são linguagens cujos programas só podem ser rodados no ambiente
DOS. Estas linguagens são mais antigas e possuem recursos gráficos limitados.
Exemplo de linguagens para DOS: Cobol, Pascal, Fortran.
Linguagens para Windows
Linguagens para Windows são linguagens cujos programas necessitam do ambiente

Windows para serem executados. Estas linguagens são mais recentes e possuem recursos gráficos
avançados. Em geral, elas possuem os mesmos recursos gráficos existentes no Windows.
Exemplo de linguagens para Windows: Visual Basic, Delphi.
Linguagem de Formatação
Linguagens de formatação são linguagens específicas para a formatação de textos e

figuras. Estas linguagens não possuem comandos de ação como if...then...else, repeat...until, etc...,
como as outras linguagens de programação. Estas linguagens são usadas para criar páginas para a
Internet. Para se rodar um programa feito numa linguagem de formatação é necessário um browser
(navegador) para a Internet, como o Netscape ou o Explorer.
Exemplo de linguagem de formatação: HTML.
Página 80
Linguagem Visual
Linguagens visuais são linguagens que possuem um ambiente de programação visual, com
recursos gráficos que auxiliam o programador durante a criação do programa.
Exemplo de linguagens visuais: Visual Basic, Delphi, Visual Java, Visual C++.
Linguagem Orientada a Objetos
Linguagens orientadas a objetos são linguagens que tratam tudo como se fossem um
objeto. Para elas, uma janela, um botão, uma caixa de texto, uma caixa de diálogo são objetos. Como
os objetos possuem propriedades , que são as suas características, e métodos, que são as ações
relacionadas a eles, uma linguagem orientada a objetos funciona baseada em seus objetos e suas
respectivas propriedades e métodos. Veremos mais detalhes das linguagens orientadas a objetos mais
adiante, no capítulo Introdução à Linguagem Orientada a Objetos.
Exemplo de linguagens orientadas a objetos: Java, C++, Delphi, Visual Basic.
Linguagem Estruturada
Linguagens estruturadas são linguagens cujos programas são criados de forma seqüencial,
ou seja, cujo código fonte de seus programas, onde estão todos os comandos e instruções que levam a
um objetivo específico, é escrito de forma seqüencial, partindo-se do início do programa, passando
pela declaração de tipos, variáveis, procedimentos e funções, pelo corpo do programa, onde são usadas
as variáveis, os procedimentos e funções declarados, além de outros comandos, até chegar ao fim do
programa.
Exemplo de linguagens estruturadas: Pascal, Cobol, C.
Linguagem Não Estruturada
Linguagens não estruturadas são linguagens cujos programas não são criados de forma
seqüencial. Eles podem ter vários módulos de programação, cada um referente a um objeto do
programa, por exemplo.
Exemplo de linguagens não estruturadas: Visual Basic, Delphi, Java.
Página 81
Banco de Dados
Existem alguns sistemas especiais para a criação, manipulação e manutenção de bancos de

dados. Estes sistemas possuem uma interface gráfica que nos ajuda a desenvolver este tipo de
atividade.
Exemplo de banco de dados: SQL, Oracle, Sybase.
Tabela de Classificação
A tabela de classificação segue as seguintes definições:
LM - Linguagem de Máquina
LD - Linguagem para DOS
LW - Linguagem para WINDOWS
LF - Linguagem de Formatação
LE - Linguagem Estruturada
LNE - Linguagem Não Estruturada
LV - Linguagem Visual
LOO - Linguagem Orientada a Objetos
BD - Banco de Dados
LM LD LW LF LE LNE LV LOO BD
Pascal X X
Cobol X X
Clipper X X
Assembler X
Fortran X X
Dbase X X
Basic X X
C X X
C++ X X X
Visual C++ X X X X
HTML X
Java X X X
Visual Java X X X X
Visual Basic X X X X
Delphi X X X X
Visual Dbase X
SQL X
Sybase X
Oracle X
Página 82
INTRODUÇÃO AO VISUAL BASIC
Características da Linguagem Visual Basic
A versão mais nova da linguagem Visual Basic, no mercado, é a 5.0.
O Visual Basic foi a primeira linguagem de aplicação Windows. Muito aplicativos, não só
os da Microsoft, permitem o Visual Basic for Aplications, ou seja, pode-se programar em aplicativos
como Word e Excel utilizando o VBA.
É possível ter páginas na Internet com VBScripts ou com um servidor que interprete
VBScript, além de o próprio sistema operacional NT 4.0 ou 95 com Option Pack aceitar a criação de
lotes de comandos usando VBScript.
Com o Visual Basic o acesso ao banco de dados Access é mais simples, pois o Visual Basic
adota o Access como padrão para banco de dados.
A parte de componentes do Windows DNA (Windows Distributed interNet Applications

architecture ) é baseado no Component Object Model (COM) que tem sido a base tecnológica de
objetos de toda a plataforma Windows. Existe uma grande integração entre Visual Basic e COM. Para
todos os efeitos, uma instância de uma classe VB é um objeto COM.
O Visual Basic pode ser visto como uma ferramenta RAD para a construção de objetos que
serão executados no Microsoft Transaction Server.
As ferramentas da Microsoft OLEDB e ActiveX Data Objects (ADO), permitem acesso

não somente a bases relacionais como também a bases de dados como arquivos VSAM no mainframe.
Além disso, toda esta tecnologia funciona na Internet através do Remote Data Services
(RDS), o que torna possível a um navegador executar uma consulta em um banco de dados ou ter
acesso a um objeto de negócio escrito em Visual Basic através da Internet sobre protocolo HTTP.
Comandos do Visual Basic
For ... Next
Sintaxe:
For contador = início To fim
sub-rotina
Next contador
Página 83
Este comando utiliza um contador (contador) que começa com um valor inicial (início) e
vai sendo incrementado, de um em um , cada vez que executa a subrotina, até chegar ao valor final
(fim).
Exemplo:
For N = 1 To 8
MsgBox "O valor é " & N
Next N
Exemplo 12 - For ... Next
Este exemplo executará 8 vezes a instrução MsgBox. Se quisermos sair do laço, por algum
motivo, podemos usar a instrução Exit For, que passará a execução do programa para o próximo
comando depois de Next.
For ... Each
Sintaxe:
For Each Objeto in Coleção
sub-rotina
Next Objeto
Neste comando, para cada objeto, é realizada a sub-rotina. A instrução Next lê o próximo
objeto e indica o fim do loop.
Exemplo:
Dim varobj As Object
For Each varobj In FRMCadastro
MsgBox "Objeto : " & varobj.Name
Next varobj
Exemplo 13 - For ... Each
Página 84
Neste exemplo, para cada objeto existente no form cadastro, será listado o seu nome. Se
quisermos sair do laço, por algum motivo, podemos usar a instrução Exit For, que passará a execução
do programa para o próximo comando depois de Next.
While ... Wend
Sintaxe:
While Condição
sub-rotina
Wend
Enquanto a condição for verdadeira, a sub-rotina é executada. A instrução Wend indica o

fim do loop.
Exemplo:
N=0
While N < 10
N=N+1
MsgBox ("Esta é a " & N & " vez que este laço é executado")
Wend
Exemplo 14 - While ... Wend
Enquanto N for menor que 10, N será incrementado de um em um e será mostrada uma
MsgBox informando o valor atual de N. Quando N for igual a 10, o loop será terminado.
Caso N já comece com um valor maior ou igual a 10, o loop não será executado nenhuma
vez.
Do While / Loop
Sintaxe:
Do While Condição
sub-rotina
Loop
Página 85
Enquanto a condição for verdadeira, a sub-rotina é executada. Quando chega na instrução loop,
ele retorna a instrução Do While e testa a condição novamente. A sub-rotina deve alterar o valor da
condição, caso contrário, estaremos em um loop infinito.
Exemplo:
N=0
Do While N < 10
N=N+1
Loop
Exemplo 15 - Do While / Loop
Enquanto N for menor que 10, N será incrementado de um em um e será mostrada uma
MsgBox informando o valor atual de N. Quando N for igual a 10, o loop será terminado.
Caso N já comece com um valor maior ou igual a 10, o loop não será executado nenhuma
vez.
Do / Loop Until
Sintaxe:
Do
sub-rotina
Loop Until Condição
O comando anterior (Do While / Loop) testa primeiro a condição para depois executar a
sub-rotina. Este comando (Do / Loop Until) executa a sub-rotina primeiro, e depois faz o teste da
condição que determinará se a sub-rotina será executada novamente, ou não.
Exemplo:
N=0
Do
N=N+1
Loop Until N > 10
Exemplo 16 - Do / Loop Until
Página 86
A sub-rotina será executada até que N seja maior que 10. Este exemplo tem o mesmo
resultado que o exemplo do comando Do While / Loop, porém, neste caso, a sub-rotina será executada
enquanto a condição for falsa.
If / Then / Else / End If
Sintaxe:
If condição1 Then
sub-rotina1
[ ElseIf condição2 Then
sub-rotina2 ]
[ Else
sub-rotina3 ]
End If
O comando If executa um a sub-rotina de acordo com o resultado de uma condição. Se a

condição 1 for verdadeira, então a sub-rotina 1 é executada. Caso contrário, a condição 2 é testada e se
ela for verdadeira, então a sub-rotina 2 é executada. Senão, é executada a sub-rotina 3.
Exemplo:
If N =1 Then
Msgbox "O valor é 1 "
ElseIf N =2 Then
Msgbox "O valor é 2"
Else
Msgbox "O valor é " & N
End If
Exemplo 17 - If / Then / Else / End If
Página 87
Se o valor de N for 1, será mostrada a 1ª MsgBox, Senão, se o valor de N for 2, será

mostrada a 2ª MsgBox. Caso contrário, será mostrada a 3ª Msgbox, dizendo qual é o valor de N.
IIf
Sintaxe:
IIf (condição, parteverdadeira, partefalsa)
Se a condição for verdadeira, é executada a parte verdadeira, se a condição for falsa, é

executada a parte falsa.
Exemplo:
Dim saldo As Currency
saldo = -500
MsgBox "Saldo " & IIf (saldo > 0, "Credor", "Devedor")
Exemplo 18 - IIf
Se saldo for maior que 0 (condição verdadeira) será escrito na MsgBox "Credor", se saldo
for menor que 0 (condição falsa) será escrito "Devedor".
Select Case / End Select
Sintaxe:
Select Case variável
Case expressão
sub-rotina1
Case Else
sub-rotina2
End Select
Página 88
Este comando executa uma sub-rotina de acordo com o valor de uma variável. Os valores
das variáveis são testados. Pode-se ter tantos Cases quantos forem os valores a serem testados. Pode-se
ainda usar o Case Else caso nenhuma rotina anterior tenha sido executada.
Exemplo:
N = InputBox ("Digite um número de 1 a 3")
Select Case N
Case 1
MsgBox ("Você digitou 1")
Case 2
Case 3
Case Else
MsgBox ("Você digitou " & N)
End Select
Exemplo 19 - Select Case / End Select
Se N for 1, será mostrada a 1ª MsgBox, se N for 2, será mostrada a 2ª MsgBox, se N for 3,

será mostrada a 3ª MsgBox. Se N for um outro valor qualquer será mostrada a 4ª MsgBox.
INTRODUÇÃO AO DELPHI
Características da Linguagem Delphi
A versão mais nova da linguagem Delphi, no mercado, é a Delphi 3.0 Client/Server.
Entre as vantagens desta linguagem, podemos ressaltar a RAD, ou Rapid Application

Development. Este é um termo largamente utilizado hoje na área de desenvolvimento. Nele estão a
disposição mais de 140 componentes já prontos para serem utilizados, além de uma além de uma
imensa gama de bibliotecas desenvolvidas por terceiros com as mais variadas utilidades. Existem
Página 89
também recursos de ambiente como CodeInsight e CodeCompletion que ajudam no aprendizado da
ferramenta.
O mecanismo de banco de dados utilizado pelo Delphi permite a conexão nativa aos
seguintes bancos de dados: Dbase, Paradox, Access, FoxPro, Oracle, Interbase, Sybase, DB2, Informix
e SQL Server. Para Ter acesso a um banco de dados fora dessa lista, basta utilizar ODBC. É possível
com o Delphi, por exemplo, fazer uma pesquisa relacionando essas tabelas, mesmo sendo de banco de
dados totalmente diferentes.
Muitas empresas hoje em dia utilizam uma arquitetura de desenvolvimento chamada

multitier que é considerada a evolução do processo cliente/servidor. O Delphi tem um conjunto de
componentes específicos para fornecer toda a funcionalidade de aplicações distribuídas e não é
necessário ter um conhecimento profundo para poder implementar o multitier.
Com o Delphi, o desenvolvedor tem a capacidade de criar aplicações utilizando a

metodologia de programação orientada a objetos e a sua versão 3.0 permite a criação de aplicações que
serão executadas em servidores Web. Neste recurso é importante ressaltar a independência de padrões
de servidores que essas aplicações possuam.
Comandos do Delphi
If ... Then
Sintaxe:
If <condição> then
<comando1>
Else
<comando2>;
Se a condição for verdadeira, executa o comando 1, senão executa o comando 2.
Página 90
Exemplo:
Var
idade : Integer;
Begin
Write ('Quantos anos você tem?');
Readln (idade);
If (idade < 1) or (idade > 130) then
Writeln ('Você não está falando a verdade')
Else
Writeln ('Você tem ', idade,' anos');
End;
Exemplo 20 - If ... Then
Case ...of
Sintaxe:
Case <variável> of
<valor1> : <comando1>;
<valor2>, <valor3> : <comando2>
else
<comando3>
Caso o valor da variável seja igual ao valor1, será executado o comando1. Caso o valor da
variável seja igual ao valor2 ou igual ao valor3, será executado o comando2. Caso o valor da variável
não seja nenhum dos anteriores, será executado o comando3.
Página 91
Exemplo:
Var
letra : Char;
Begin
Read (letra);
Case letra of
'a' : Writeln ('Você escreveu um a minúsculo');
'Z' : Writeln ('Você escreveu um z maiúsculo')
else
Writeln ('Você escreveu outra letra');
End;
Exemplo 21 - Case ...of
Repeat ... Until
Sintaxe:
Repeat
<comandos>;
until <condição>;
Este comando repetirá um ou mais comandos até que a condição seja verdadeira.
Página 92
Exemplo:
Var
I : Char;
Begin
Repeat
Write ('Digite uma tecla: ');
Read ( I );
Until (I = 'q') or (I = 'Q');
End;
Exemplo 22 - Repeat ... Until
While ... Do
Sintaxe:
While <condição> do
Begin
<comandos>
end;
Enquanto <condição> for verdadeira, os comandos entre Begin e End serão executados.
Exemplo:
Var
I : Char;
Begin
While (I <> 'q') or (I <> 'Q') do
Begin
Write ('Digite uma tecla: ');
Read ( I );
End;
End;
Exemplo 23 - While ... Do
Página 93
For ... Do
Sintaxe:
For contador ::= <valorinicial> to <valorfinal> do
Begin
<comandos>
End;
A variável contador partirá de um valor inicial e será incrementada de um em um até

chegar ao valor final. Para cada vez que ela for incrementada, os comandos entre Begin e End serão
executados.
Exemplo:
Var
Cont : integer;
Begin
For cont ::=1 to 10 do
Begin
Writeln ( cont, ' ª vez');
End;
End;
Exemplo 24 - For ... Do
Página 94
INTRODUÇÃO A LINGUAGEM ORIENTADA A OBJETOS
Neste capítulo vamos fazer uma introdução a linguagem orientada a objetos. Este tipo de
linguagem vem tomando cada vez mais espaço no mercado de trabalho da computação, devido a sua
concepção inovadora que nos permite criar programas de forma mais fácil, clara e simples. Além disso,
os programas gerados nestas linguagens possuem maior facilidade de manutenção. Devido a estes
benefícios, e ao fato de que as linguagens orientadas a objetos estão sendo cada vez mais procuradas
nos profissionais de informática, torna-se fator de diferenciação o seu conhecimento.
A programação orientada a objetos permite-lhe pensar nos elementos de programa como

objetos. No caso de um objeto janela, você não precisa pensar nos detalhes de como ela funciona, nem
precisa saber sobre os campos de dados privados da janela. Você precisa apenas saber como chamar as
diversas funções (métodos) que fazem a janela operar. Vamos tomar como exemplo, um carro. Para
dirigir um carro, você não precisa saber os detalhes de como ele funciona. Precisa saber apenas como
dirigi-lo.
As linguagens orientadas a objetos tratam tudo como de fosse um objeto, e funcionam

baseadas em seus objetos e em suas respectivas propriedades e métodos.
Mas a linguagem orientada a objetos é muito mais do que isso. Para aprender a respeito
dela, é necessário entender alguns conceitos principais que são a espinha dorsal da OOP (Object
Oriented Programming).
Com o objetivo de dar a vocês uma base de como é e como funciona uma linguagem
orientada a objetos, vamos definir seus principais conceitos.
Objeto
Podemos dizer que qualquer coisa é um objeto. Uma cadeira, um vaso, uma caneta são
objetos. As linguagens de programação orientadas a objetos tratam tudo como se fosse um objeto. Para
essas linguagens, uma janela , um botão, uma caixa de texto, por exemplo, são objetos.
Propriedades
Um objeto de uma linguagem, assim como um outro objeto qualquer, também possui
propriedades. Tomando como exemplo um carro, ele possui características como cor, marca, modelo,
ano de fabricação, combustível, etc.... Estas são suas propriedades. Um objeto de uma linguagem,
como por exemplo, um botão, tem como propriedades nome, tamanho, cor, posição na tela, etc...
Página 95
Métodos
Assim como os objetos tem propriedades, eles também tem ações ligadas a eles. Por
exemplo, uma televisão possui como propriedades a marca, o modelo e a quantidade de polegadas.
Além disso ela pode mudar de canal, aumentar ou diminuir o volume, ligar e desligar. Estas são as
ações que estão associadas à ela. Um objeto de uma linguagem também possui ações específicas que é
capaz de realizar. Essas ações são denominadas métodos.
Eventos
Eventos são ações que os objetos sofrem, como por exemplo, um clique, duplo clique, um
arraste com o mouse. Para escrever um programa numa linguagem orientada a objetos, tratam-se os
eventos que forem necessários, associando um evento a um código do programa que executará ações
específicas. Por exemplo, quando o usuário clicar em um botão, ele está atribuindo o evento clique a
este botão. Quando o usuário aperta o botão do mouse em um formulário, ele está atribuindo o evento
mouse pressionado a este formulário.
Classes de Objetos
Todo objeto se origina a partir de uma classe de objeto. A classe de um objeto são as
características e métodos que aquele objeto possui, e servem apenas para criar os objetos propriamente
ditos. Um botão é uma classe de objeto, que dá origem a objetos botões.
Encapsulamento
Uma diferença básica entre programação estruturada convencional e a programação

orientada a objetos é algo prático chamado encapsulamento. O encapsulamento permite que se
ocultem, dentro do objeto, tanto os campos de dados como os métodos que agem naqueles dados. Após
fazer isto, você pode controlar o acesso aos dados, forçando os programas a extrair ou modificar os
dados apenas através da interface do objeto. Em termos estritos, no projeto orientado a objetos, os
dados de um objeto são sempre privados ao objeto. Outras partes de um programa jamais devem ter
acesso direto àqueles dados.
Em uma abordagem de programação estruturada, nós podemos ocultar dados dentro de

funções, simplesmente tornando estes dados locais em relação à função. Entretanto surge um problema
quando queremos tornar dados de uma função disponíveis para outras funções. A maneira de fazer isto
em um programa estruturado é tornar os dados globais em relação ao programa, o que fará com que
qualquer função tenha acesso a ele. O encapsulamento usa um outro nível de escopo, um que torna os
dados globais às funções que precisam deles, mas ainda assim impede que outras funções ganhem
Página 96
acesso. Num objeto, os membros de dados encapsulados são globais em relação aos métodos dos
objetos, mas são locais em relação ao objeto. Eles não são variáveis globais.
Herança
A herança permite ao programador criar uma classe que é semelhante a uma classe
previamente definida, mas que ainda possua algumas propriedades próprias. Considere um programa
para simulação de um carro. Suponha que você tenha uma classe para um carro comum, mas agora
queira criar um carro com câmbio automático. Num programa tradicional, talvez seja preciso
modificar profundamente o código existente e talvez acabe introduzindo alguns bugs num código que
funcionava bem antes das modificações. Para evitar estes conflitos, poderia ser usada uma abordagem
de programação orientada a objetos, criando uma nova classe por herança. Esta nova classe herda
todos os dados e métodos da classe-base testada. Desse modo você tem apenas de se preocupar em
testar o novo código acrescentado à classe derivada.
Polimorfismo
A última característica principal da programação orientada a objetos é o polimorfismo. Pela utilização

de polimorfismo, você pode criar novos objetos que executam as mesmas funções que o objeto-base,
mas que executam uma ou mais funções de maneira diferente. Por exemplo, talvez você tenha um
objeto forma que desenha um círculo na tela. Usando o polimorfismo, podemos criar um objeto forma
que desenhe um retângulo e não um círculo. Isto é feito pela criação de uma nova versão do método
que desenha a forma na tela. Tanto o antigo método de desenho de um círculo como o novo método de
desenho de um retângulo possuem o mesmo nome, mas exec
Página 97
INTRODUÇÃO À SQL
Quando quisermos capturar apenas alguns registros podemos usar SQL. SQL (Structured
Query Language) é uma linguagem que nos habilita a especificar quais registros desejamos
capturar do banco de dados. Podemos submeter uma Query a um banco de dados e este
retoma todas as
linhas que atendam a query. Além disso, podemos recuperar informações de múltiplas
tabelas de
uma só vez.
SELECT
A cláusula SELECT seleciona registros de um banco de dados de acordo com
uma ou mais
condições, retomando, deste modo, um conjunto de registros que satisfaz as condições
especificadas.
Sintaxe
SELECT [predicado] { * | tabela.* [tabela. ]campo l [AS aliasl] [, [tabela. ]campo2 [AS alias2] [,
.-]]}
FROM nometabela [,...] [IN nomebancodedados]
[WHERE... ]
[GROUPBY...]
[HAVING... ]
[ORDERBY...]
[WITH OWNERACCESS OPTION]
Onde:
Predicado Um dos seguintes predicados : ALL, DISTINCT, DISTINCTROW or

TOP.
Você usa o predicado para restringir o numero de registro retornando.
Se nenhum e especificado, o default e ALL.
* Especifica que todos os campos da tabela ou tabela especificadas
são selecionados.
Tabela O nome da tabela contendo os campos cujos registros são
selecionados.
Campo1, campo2 Os nomes dos campos contendo os dados que você quer obter. Se
você concluir mais do que um campo, eles serão retornados na
ordem listada.
Alias1, alias2 Os nomes para usar como cabeçalho dos nomes de colunas originais
na tabela.
Nometabela O nome da tabela ou tabela contendo o dado que você quer obter.
Nomebancodedados O nome do banco de dados contendo as tabelas especificadas em
nometabela se elas não estão no banco de dados corrente.
Página 98
WHERE
O comando WHERE especifica a condição para capturar o registro. Por exemplo:
Where: SQL = "SELECT *FROM Funcionários WHERE Nome = '" & txtNome & " ' "
Where In: "SELECT Funcionários. Nome FROM Funcionários WHERE Funcionários. Uf in"
_
"('SP´,´RJ´)´´
Where Between: "SELECT Orderld FROM Orders WHERE (OrderDate BETWEEN" _

"#01/01/93# AND #01/31/93#)"
Where Like: "SELECT * FROM Amigos WHERE Nome LIKE '" & txtnome & "*'"
ORDERBY
Com o comando ORDER BY podemos ordenar os registros segundo um
determinado campo
em ordem ascendente (ASC) ou descendente (DESC). Por exemplo:
SELECT * FROM Funcionários ORDER BY [Nome]
Exemplos
1. SELECT * FROM Funcionários;
2. SELECT Funcionários. Departamento, Supervisores.NomeSup

FROM Funcionários INNER JOIN Supervisores
WHERE Funcionários. Departamento == Supervisores. Departamento;
3. SELECT DataNascimento
AS DataNasc FROM Funcionários;
4. SELECT COUNT(NumFuncionario)
AS NumTotal FROM Funcionários;
INSERT
A cláusula INSERT adiciona um registro ou vários registros a uma tabela. E referenciado

como uma query de ação que adiciona novos registros ao final de uma tabela ou de uma
query
existente. Uma query de ação não retoma registros.
Sintaxe
INSERT INTO tabeladestino [(campol[, campo2[,...]])]
VALUES (valor1[, valor2[, ...])
Página 99
Onde:
Tabeladestino O nome da tabela para onde copiar os registros.

Campo1, campo2 Nome dos campos para onde copiar os dados
Valor1, valor2 Os valores para serem inseridos nos campos nos campos especificados do
novo registro.
Cada valor e inserido no campo que corresponde a posição na lista: valor1 e
inserido no campo1 do novo registro , valor1 no campo2 e assim por diante.
Você deve se parar os valores por virgula e delimitar o texto com apostrofe.
Exemplos
1. INSERT INTO Funcionários "

& "(Nome.Sobrenome, Cargo) VALUES " _
& "('Paulo', 'Oliveira', 'Gerente');"
2. "INSERT INTO Funcionários (Nome, Função) VALUES ("' & txtnome & '",'" & txttelefone &
"’);”
UPDATE
A cláusula UPDATE altera o valor de um campo em uma tabela especificada
baseada em
um critério especificado. Também é referenciada como uma query de ação, portanto não
retoma
registros.
Sintaxe
UPDATE tabela
SET novo valor
WHERE critério,
Onde:
Tabela O nome de uma tabela contendo o dado que você quer alterar.
Novovalor Uma expressão que determina o novo valor a ser inserido no campo
do registro a ser modificado.
Critério Uma expressão que determina quais registros serão modificados.
Somente registros que satisfaçam a expressão serão alterados.
Exemplos
Página 100
l. UPDATE Pedidos
SET ValorPedidos = ValorPedidos * 1. 1,
Frete = Frete* 1.03
WHERE UFCliente <> 'SP';
2. "UPDATE Funcionários” _
& "SET DiasFolga = 1 " _

& "WHERE DiasFolga = 2;"
3. "UPDATE Funcionários SET Nome ='" & nomenovo & '", Telefone ='" & telefonenovo & '"
WHERE Nome =1" & nomevelho & '""
DELETE
A cláusula DELETE remove registros de uma ou mais tabelas listadas na

cláusula FROM
que satisfaçam a cláusula WHERE. Também é referenciada como uma query de ação,
portanto não
retoma registros.
Sintaxe
DELETE [tabela.*]
FROM tabela
WHERE critério
Onde:
Tabela O nome opcional de uma tabela de onde os registros serão delatados

Tabela O nome da tabela de onde os registro serão delatados
Critério Uma expressão que determina quais registros serão delatados
Exemplos
1. DELETE * FROM Funcionários WHERE Cargo = Trainee'
2. "DELETE * FROM Funcionários WHERE Nome = '" João '""
Página 101
Usando Select com Múltiplas Tabelas
Podemos usar uma operação Join para combinar registros de múltiplas tabelas.
Por
exemplo, suponhamos que queremos mostrar a categoria e o nome dos produtos.
Precisamos ligar
as tabelas Categorias e Produtos.
A cláusula INNER JOIN especifica que você quer registros que sejam fruto da
intersecção
entre as tabelas Categorias e Produtos, onde deve existir um campo em comum.
Exemplo:
SELECT NomeCategoria, NomeProdutos
FROM Categorias INNER JOIN Produtos
ON Categorias.Código = Produtos.CodigoCategoria;
INTRODUÇÃO
A linguagem JavaScript foi criada pela Sun MicroSystem Inc. em parceria com a
Netscape Comunications.
O JavaScript é uma linguagem baseada no Java, com isso ela contém regras menos
restritas e menos complexas, sendo indicada para programação de tarefas mais simples.
Existem também outras linguagens script além do próprio JavaScript, como o
VisuaIScript (baseado no Visual Basic) e o PerI (amplamente utilizado na criação de
CGI).
Os parágrafos de lógica do JavaScript podem estar "soltos" ou atrelados a ocorrência

de eventos. Os parágrafos soltos são executados na seqüência em que aparecem na
página (documento HTML) e os eventos são executados apenas quando o evento
ocorre, por exemplo quando for pressionado um botão de formulário.
Para inserir parágrafos de programação dentro do HTML é necessário identificar o início

e o fim do set de JavaScript, com a tag HTML <SCRIPT> e </SCRIPT>, Este procedimento
pode ser adotado em qualquer local da página. Entretanto, para melhor visualização e
facilidade de manutenção, recomenda-se que toda a lógica seja escrita no início do
documento entre as tags <HEAD> e </HEAD>, através da criação de funções a serem
invocadas quando se fizer necessário (normalmente atreladas a eventos).
Os comandos JavaScript são sensíveis ao tipo de letra (maiúsculas e minúsculas) em

sua sintaxe. Portanto, é necessário que seja obedecida a forma de escrever os
comandos, de acordo com a forma apresentada ao longo desta apostila. Caso seja
cometido algum erro de sintaxe quando da escrita de um comando, o JavaScript
interpretará, o que seria um comando, como sendo o nome de uma variável.
Página 102
CRIAÇÃO DE VARIÁVEIS
Uma variável é criada automaticamente, pela simples associação de valores a mesma.

Exemplo:
NovaVariavel = "José"
Foi criada a variável de nome NovaVariavel que, passou a conter a string José. As
variáveis podem ser Locais ou Globais. As variáveis que são criadas dentro de uma
função são Locais e referenciáveis apenas dentro da função. As variáveis criadas fora de
funções são Globais, podendo serem referenciadas em qualquer parte do documento.
Desta forma, variáveis que precisam ser referenciadas por várias funções ou em outra
parte do documento, precisam ser definidas como globais. Embora não seja
recomendável, em uma função, pode ser definida uma variável local com o mesmo
nome de uma variável global. Para isso utiliza-se o método de definição VAR. Exemplo:
Variável Global: MinhaVariavel = "Seu Nome"

Variável Local: var MinhaVariavel = "Seu Sobrenome"
3 – OPERADORES
3.1 - Operadores Lógicos
São operadores a serem utilizados em comandos condicionais, tais como: AND, OR e

NOT. Os comandos condicionais serão vistos mais a frente. O operador AND é
representado no código JavaScript por &&, o operador OR é representado por ]| e o
operador NOT é representado !.
3.2 - Operadores Aritméticos
São operadores a serem utilizados dentro do código JavaScript em referências de

indexadores, cálculos e manuseio de strings. Ao longo da apostila estes operadores
serão largamente utilizados, dando, assim, uma noção mais precisa do seu potencial.
Onde o operador + soma os valores, - subtrai os valores, * multiplica os valores, / faz a
divisão de valores e % obtém o resto de uma divisão, por exemplo: 150 % 13 retomará
"7" e 7 % 3 retornará "1".
Página 103
<html>
<head>
<script language="javascript">
x =10+5; //valor de x e 15
y =20-3; //valor de y e 17
z =120* 2; //valor de z e 240
w=;30/2; //valor de w e 15
r = 3 % 2; //valor de r e 1
</script>
</head>
</html>
3.3 - Operadores Short-Cut
São operadores alternativos aos operadores aritméticos, utilizados para efetuar

operações matemáticas mais rapidamente.
Modo Normal Modo Short-Cut

X=x+y X += y
X=x-y X -= y
X=x*y X *= y
X=x/y X /= y
X=x%y X %= y
3.4 - Operadores Comparativos

São operadores de comparação que retornam um valor booleano baseado na
comparação se é verdadeira ou não.
Operador Descrição
== Igual
!= Diferente
> Maior
< Menor
>= Maior ou igual
<= Menor ou igual
Página 104
4 - TIPOS DE EXPRESSÕES
Uma expressão é um conjunto de variáveis, operadores, literais e outras expressões

que determinam um valor que pode ser numérico, booleano ou string. Uma expressão
também pode atribuir um valor a uma variável (maiores detalhes no tópico
correspondente a variáveis).
Tipo de Expressões Descrição

Aritméticas Determinam um valor
Lógicas numérico
String Determinam um valor
Condicionais booleano
Determinam uma string
Assumem um valor baseado
em condições
Os delimitadores naturais para uma string são " (aspa dupla) ou ' (aspa simples). Caso
seja necessário a utilização destes caracteres como parte da uma string, utilize o sinal \
precedendo " (aspa dupla) ou ' (aspa simples). Por exemplo:
<html>
<head>
alert ("Cuidado com o uso de \" ou V em uma string")
</head>
</html>
</script>
5 - CONTROLES ESPECIAIS
Tratam-se de comandos inseridos junto as strings no código JavaScript e que permitem

determinadas funções e manuseios.
Controle Descrição
\b Backspace
\n New line caracters
\r Carriage return
\t Tab caracters
// Linhas de comentário
/* ... */ Delimitadores para
comentários
Com mais de uma linha
Página 105
6 - COMANDOS CONDICIONAIS
São comandos que permitem a execução de uma certa tarefa à veracidade ou não de
uma outra condição, ou enquanto determinada condição for verdadeira.
6.1 - Estrutura de Decisão - Comando ÍF – eLSE
Os comandos condicionais IF e ELSE permitem a você realizar determinadas ações

baseadas em uma condição lógica. Caso a condição (que pode ser uma expressão)
for verdadeira, será executado o comando ou bloco de comandos declarados logo
após a condição. Caso contrário, será executado o comando ou bloco de comandos
declarados logo após a instrução dele. A sintaxe para está estrutura é:
if (condição)
{ação para condição satisfeita}
else
{ação para condição não satisfeita}
Exemplo:
<html>
<head>
idade=15
if (idade < 18)
{Categoria = "Menor"}
else
{Categoria = "Maior"}
</script>
</head>
</html>
A cláusula ELSE é opcional, isto é, se não for necessário, não é preciso declará-la.
6.2 - Move Condicional
receptor = ((condição) ? verdadeiro : falso)
Ex.
NomeSexo = ((VarSexo == "M") ? "Masculino": "Feminino")
Página 106
6.3 - Estrutura de Repetição
6.3.1 - Comando FOR
O comando FOR repete um comando ou bloco de comandos enquanto uma

especificada condição for verdadeira. Você pode especificar uma variável para ser
incrementada/decrementada a cada execução do loop. A sintaxe é:
for (inicialização;condição;incremente)
{ ação }
Exemplo:
<html>
<head>
for(x= O ; x<= 10 ; x++)
{alert ("X igual a " + x)}
</script>
</head>
</html>
6.3.2- Comando WHILE
O comando WHILE executa o comando ou bloco de comandos enquanto uma

condição especificada for verdadeira. Esse comando ou bloco de comandos é
executado novamente e assim sucessivamente até que a condição especificada não
seja mais satisfeita. A sintaxe é:
While (condição)
{ação}
Exemplo:
<html>
<head>
var contador =10
while (contador > 1) {
contador -;
alert ("Menor que zero ainda...")}
</script>
</head>
</html>
Página 107
7- Comentários
Em JavaScript pode-se utilizar vários tipos de comentários de acordo com a

necessidade.
/* : utilizado para comentários longos. O barra-asterisco inicia um bloco de comentário

que pode conter quantas linhas você precisar todo o texto após o barra asterisco é
ignorado, até que asterisco-barra seja encontrado, terminando assim o bloco de

comentário */.
//: utilizado para comentários de uma linha, para introduzir o comentário. Todo o texto
seguindo este símbolo até o próximo carriage-return será considerado um comentário
e
ignorado para fins de processamento.
Exemplo:
// este texto será tratado como comentário
8 - CRIANDO FUNÇÕES
Uma função é um conjunto de instruções, que só devem ser executadas quando a

função for acionada. A sintaxe geral é a seguinte:
function NomeFunção (Parâmetros)

{ Ação }
Suponha uma função que tenha como objetivo informar se uma pessoa é maior ou
menor de idade, recebendo como parâmetro a sua idade, o resultado seria:
<html>
<head>
function Idade (Anos) {
if(Anos>17)
{ alert ("Maior de Idade")}
else
{ alert ("menor de Idade")}
}
</script>
</head>
</html>
Página 108
Para acionar esta função, suponha uma caixa de texto, em um formulário, na qual seja
informada a idade e, a cada informação, a função seja acionada.
<form>
<input type="text" size="2" maxlength="2" name="Tempo"
onchange="ldade(Tempo.value)">
</form>
Observe-se que o parâmetro passado (quando ocorre o evento "onchange") foi o

conteúdo da caixa de texto "Tempo" (propriedade "value") e que, na função, chamamos
de "Anos". Ou seja, não existe co-relação entre o nome da variável passada e a variável
de recepção na função. Apenas o conteúdo é passado.
Veja a seguir o código completo
<html>
<head>
function Idade(Anos)
{
if(Anos> 17)
{alert ("Maior de Idade")}
else
{alert ("menor de Idade")}
}
</script>
</head>
<body>
<form>
Forneça a Idade:
<input type="text" size="2" maxlength="2" name="Tempo"
onchange="ldade(Tempo.value)">
</form>
</body>
</html>
9 - EXIBIÇÃO DE MENSAGENS
Existem basicamente três formas de comunicação com o usuário através de mensagens.

Elas são exibidas como caixas de diálogo na janela do navegador.
9.1 - Caixa de Diálogo Simples - Comando ALERT

Este comando exibe apenas uma observação em uma janela aberto dentro do próprio
navegador do visitante. Sintaxe:
Página 109
alert ( mensagem )
Exemplo:
alert ("Certifique-se de que as informações estão correias")
9.2 - Caixa de Diálogo Confirmação - Comando CONFIRM
Este comando exibe uma mensagem que retorna uma confirmação de OK ou CANCELAR
na janela do navegador do visitante. Sintaxe:
confirm (mensagem)
Exemplo:
<html>
<head>
<script language="javascript">if (confirm ("Algo está errado...devo continuar??"))
{alert("Continuando")}
else
{alert("Parando")}
</script>
</head>
</html>
9.3 - Caixa de Diálogo Entrada - Comando PROMPT
Este comando exibe uma caixa na janela do navegador onde é possível receber
mensagens para uso dentro do próprio JavaScript ou para que o visitante possa digitar
textos e mensagens. Sintaxe:
Variável = prompt ("Minha mensagem", "Meu texto")
Onde Variável é o nome do campo que vai receber a informação digitada pelo usuário,
"Minha mensagem" é a mensagem que vai aparecer como título da caixa de diálogo e
"Meu texto" é um texto que aparecerá na linha de digitação. Para que o campo seja
exibido vazio, deixe esse texto vazio. Exemplo:
Entrada = prompt("lnforme uma expressão matemática","")

Resultado = eval(Entrada)
document.write("0 resultado é = " + Resultado)
Página 110
10 - ESCREVENDO PARA UM DOCUMENTO - COMANDO WRITE
O JavaScript permite que o programador escreva linhas dentro de uma página

(documento), através do método write. As linhas escritas desta forma, podem conter
textos, expressões JavaScript e comandos HtmI. As linhas escritas através deste método
aparecerão no ponto da tela onde o comando for inserido.
<html>
<head>
valor = 30;
document.write ("Minha primeira linha")
document.write ("Nesta linha aparecerá o resultado de :" + (10 * 10 + valor))
</script>
</head>
</html>
A idéia do exemplo acima é escrever duas linhas. Entretanto o método write não insere
mudança de linha, o que provocará o aparecimento de apenas uma linha com os dois
textos emendados. Para evitar este tipo de ocorrência, existe o método writeln que
escreve uma linha e espaceja para a seguinte. Entretanto, este comando não surti efeito
na maioria dos casos, obtendo-se o mesmo resultado do método write. A solução
encontrada para este tipo de situação é a utilização do comando de mudança de
parágrafo da linguagem HTML.
<html>
<head>
valor = 30;
document.write ("<p>Minha primeira linha</p>")
document.write ("<p>Nesta linha aparecerá o resultado de :" + (10 * 10 + valor) + "</p>")
</script>
</head>
</html>
Isto resolve a questão da mudança de linha, porém, vai gerar uma linha em branco,
entre cada linha, por se tratar de mudança de parágrafo. Caso não seja desejado a
existência da linha em branco, a alternativa é utilizar o comando HTML <BR> que apenas
muda de linha.
Página 111
11 - FUNÇÕES PARA MANIPULAÇÃO E CONVERSÃO DE DADOS
Para utilizar uma variável em JavaScript não é necessário declarar o tipo, ou seja, em
momentos diferentes do código ela pode armazenar valores de tipos diferentes. Por
exemplo, uma variável pode inicialmente conter um valor inteiro e posteriormente ser
usada para armazenar uma string:
valor = 1000;
valor = "saldo";
Ao concatenarmos as variáveis por meio do operador"+", a conversão de tipo de dado

é automática.
Exemplo:
mensagem = "A idade do aluno é" + 28 + "anos";
A seguir veremos algumas funções para manipulação e conversão de dados.
11.1 - Conversão para Números Inteiros
parseint (): Converte uma string para número, levando em consideração a base. Caso a
string possua um caracter que não possa ser convertido, a operação para, retornando
um valor antes do erro.
Sintaxe : variável = parselnt("string");
Exemplos:
parselnt("10") // retorna 10
11.2 - Conversão para Números Reais
parseFloat(): Converte uma string que representa um número, para um número com
ponto flutuante. Caso a string não possa ser avaliada, a função retorna 0.
Sintaxe: variavel=parseFloat(valor);
Exemplo:
document.write(parseFloat("-10.46")
utam o desenho de forma diferente.
Página 112

Apostila Completa de Logica

Загружено:

Сведения о документе

Исходное описание:

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Apostila Completa de Logica

Загружено:

Авторское право:

Доступные форматы

Curso de Lógica de Programação

Exemplo 1 - Estrutura seqüencial.......................................................................................................20

Exemplo 14 - For ... Next...................................................................................................................84

Exemplo 22 - If ... Then.....................................................................................................................91

Neste curso o aluno aprenderá:

A Lógica nada mais é do que o ato de se pensar corretamente, de se usar corretamente as

a) Todo marciano é verde.

b) Paris é uma cidade da França.

Sempre que pensamos, usamos a Lógica ou a Ilógica. Como a palavra falada é a

1) Rubens é mais alto que Oscar.

2) A bolsa está fechada.

3) Silvia e Jorge tem somente dois filhos.

Transformando a Lógica em Algoritmo

(Ordem de Pensamento e, portanto, Lógica)

“Ação é um acontecimento que a partir de um estado inicial, após um período de tempo

“Estado é a situação atual de dado objeto”.

Portanto, podemos redefinir Algoritmo como:

“Algoritmo é a descrição de um conjunto de ações que, obedecidas, resultam numa

Descrevendo-a passo a passo:

A seqüenciação das ações tem o objetivo de reger o fluxo de execução, determinando a

Este algoritmo tornou-se infinito. As ações somente cessarão quando conseguirmos

O teste da chave é efetuado por uma determinada seqüência de ações:

se a chave for errada:

enquanto a chave for errada, faça:

Vamos supor que tivéssemos dez portas para abrir:

enquanto quantidade de portas abertas menor que dez, faça:

Quando um programa é rodado em um computador, informações são manipuladas por ele.

Existem vários tipos diferentes na programação. Quando aprendemos uma linguagem de

a) A pizza tem 8 pedaços.

a) O livro custa R$ 85,60.

3. Caractere: toda informação composta por um conjunto de caracteres alfanuméricos

a) A placa dizia: “Animal em extinção”.

4. Lógico: toda informação que só pode assumir dois estados (biestável).

a) O computador pode estar ligado ou desligado.

Uma informação é constante quando não é alterada no decorrer do tempo. No caso da

4, 567, -1,98, “R$ 67,00”, Verdadeiro, “Não Fume”.

1. Começar por um caracter alfabético;

Identificadores válidos: MÉDIA, Y, BK78, NOTAS, D2, SOMA.

Em um programa, sempre que usarmos informações variáveis, devemos declarar as

tipo : lista de variáveis ;

Operadores aritméticos são símbolos que representam as operações básicas da matemática.

operando operador aritmético operando

8+2, VALOR/5, SOMA+5, X-Y, 2**3, 4//16.

mod -> resto da divisão

div -> quociente da divisão inteira

sen(x) retorna o seno de x;

parênteses mais internos

Regra de formação de uma expressão lógica:

operando lógico operador lógico operando lógico

A B AeB A B A ou B A B A xou B A não A

Entre operadores lógicos, a resolução obedece a seguinte ordem de prioridade:

Entre todos os operadores, a ordem é a seguinte:

parênteses mais internos

1) Determine se a equação resultante é Verdadeira ou Falsa

2) Resolva a equação a seguir e diga se ela é Verdadeira ou Falsa:

Quando queremos atribuir um valor a uma determinada variável, utilizamos o comando de

Comandos de Entrada e Saída

Quando o usuário Quando o programa é Quando a soma é

Sintaxe da Entrada de Dados

Sintaxe da Saída de Dados

Para delimitar um bloco, são usados os delimitadores: início e fim.

início ação fim ;

início {início do bloco ( algoritmo ) }

Número: _ Fumante: ____

De: _ Para: _

Data: _/_/___ Horário: _:___

Poltrona: Distância: ______ Km