Apostila de Técnicas de Programação
UNIFEI
Disciplina
Professor
UNIVERSIDADE FEDERAL DE ITAJUBÁ
Instituto de Engenharia de Sistemas e Tecnologias da Informação-IESTI
ECO002 – Técnicas de Programação
Dr.Enzo Seraphim, Dra.Thatyana de Faria Piola Seraphim
Notas de Aula de Algoritmos
Sumário
1INTRODUÇÃO .................................................................................................................................. 3
1.1LÓGICA ...................................................................................................................................................... 3
1.1.1Sequência Lógica ............................................................................................................................... 3
1.1.2Instruções ........................................................................................................................................... 3
1.2ALGORITMO ............................................................................................................................................... 4
1.2.1Pseudocódigo ..................................................................................................................................... 4
1.2.2Regras para construção de Algoritmos ............................................................................................. 4
1.2.3Fases para construção de Algoritmos ............................................................................................... 5
1.2.4Teste de Mesa ..................................................................................................................................... 5
1.3PROGRAMAS .............................................................................................................................................. 5
2PORTUGOL ....................................................................................................................................... 7
2.1ENTRADA, PROCESSAMENTO E SAÍDA ........................................................................................... 7
2.1.1Corpo Geral de um Programa ........................................................................................................... 7
2.1.2Linhas de comentário ......................................................................................................................... 8
2.1.3Identação............................................................................................................................................ 8
2.2VARIÁVEIS ................................................................................................................................................. 8
2.2.1Variáveis de entrada e saída .............................................................................................................. 8
2.2.2Constantes .......................................................................................................................................... 9
2.2.3Identificadores ................................................................................................................................... 9
2.2.4Tipos de dados.................................................................................................................................... 9
2.2.5Tipos primitivos de dados .................................................................................................................. 9
2.2.6Sinal de atribuição ........................................................................................................................... 10
2.3OPERADORES E EXPRESSÕES.................................................................................................................... 10
2.3.1Operadores Aritméticos ................................................................................................................... 10
2.3.2Operadores Relacionais ................................................................................................................... 10
2.3.3Operadores lógicos .......................................................................................................................... 10
2.3.4Expressões lógicas ........................................................................................................................... 11
2.3.5Prioridade de Expressões ................................................................................................................ 11
2.4COMANDOS DE I/O (INPUT/OUTPUT) ......................................................................................................... 12
2.5A TOMADA DE DECISÕES .......................................................................................................................... 12
2.5.1Desvio condicional........................................................................................................................... 12
2.5.2Desvios encadeados ......................................................................................................................... 13
2.5.3Estruturas de Decisão ...................................................................................................................... 14
2.6LAÇOS OU MALHAS DE REPETIÇÃO.......................................................................................................... 14
2.6.1Repetição com teste no Início do Looping ....................................................................................... 15
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
1
Apostila de Técnicas de Programação
2.6.2Repetição com teste lógico no fim do Looping ................................................................................ 15
2.6.3Repetição com variável de controle ................................................................................................. 16
2.7FUNÇÕES PRÉ-DEFINIDAS ........................................................................................................................ 17
2.8ESTRUTURA DE DADOS HOMOGÊNEAS .................................................................................................... 18
2.8.1Matrizes de uma Dimensão ou Vetores ............................................................................................ 18
2.8.2Operações Básicas com Matrizes do Tipo Vetor.............................................................................. 18
2.8.3Leitura dos Dados de uma Matriz ................................................................................................... 19
2.8.4Escrita dos Dados de uma Matriz .................................................................................................... 19
2.8.5Matrizes com mais de uma dimensão .............................................................................................. 20
2.8.6Leitura dos Dados de uma Matriz ................................................................................................... 20
2.8.7Escrita dos Dados de uma Matriz .................................................................................................... 21
2.9ESTRUTURA DE DADOS HETEROGÊNEAS .................................................................................................. 21
2.9.1Estrutura de um Registro ................................................................................................................. 21
2.9.2Atribuição de Registros .................................................................................................................... 21
2.9.3Leitura de Registros ......................................................................................................................... 22
2.9.4Escrita de Registros ......................................................................................................................... 23
2.10ESTRUTURA DE UM REGISTRO DE CONJUNTOS ....................................................................................... 23
2.10.1Leitura de Registro de Conjuntos .................................................................................................. 24
2.10.2Estrutura de um conjunto de Registros .......................................................................................... 24
2.10.3Leitura de Conjunto de Registros .................................................................................................. 25
2.10.4Escrita de Conjunto de Registros................................................................................................... 25
2.11PROGRAMAÇÃO MODULAR .................................................................................................................... 26
2.11.1Sub-Rotinas .................................................................................................................................... 26
2.11.2Procedimentos ................................................................................................................................ 26
2.11.3 Funções ......................................................................................................................................... 29
2.11.4 Utilização de Funções ................................................................................................................... 30
1 Introdução
Muitas pessoas gostam de falar ou julgar que possuem e sabem usar o raciocínio lógico, porém,
quando questionadas direta ou indiretamente, perdem esta linha de raciocínio, pois este depende de inúmeros
fatores para completá-lo, tais como: calma, conhecimento, vivência, versatilidade, experiência, criatividade,
ponderação, responsabilidade, entre outros.
A lógica é a ciência que estuda as leis e critérios de validade que regem o pensamento e a
demonstração, ou seja, ciência dos princípios formais do raciocínio.
Usar a lógica é um fator a ser considerado por todos, principalmente pelos profissionais de
informática (programadores, analistas de sistemas e suporte), pois seu dia-a-dia dentro das organizações é
solucionar problemas e atingir os objetivos apresentados por seus usuários com eficiência e eficácia,
utilizando recursos computacionais. Saber lidar com problemas, seja de ordem administrativa, de controle,
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
2
Apostila de Técnicas de Programação
de planejamento ou de estratégia requer atenção e bom uso do conhecimento. Nosso interesse é mostrar
como desenvolver e aperfeiçoar melhor esta técnica, lembrando que, para isto, você deverá ser persistente e
praticá-la constantemente, chegando à exaustão sempre que julgar necessário.
1.1 Lógica
Lógica representa todo raciocínio desenvolvido através de um sistema “razoável” de leis, preceitos
ou teoremas. Através da lógica é possível descrever, analisar e comparar fatos.
A lógica de programação é necessária para pessoas que desejam trabalhar com desenvolvimento de
sistemas e programas, pois permite definir uma sequência natural de atividades com a intenção de atingir um
objetivo.
Lógica de programação é a técnica de encadear pensamentos em uma sequência lógica para atingir
determinado objetivo.
1.1.1 Sequência Lógica
Estes pensamentos ou atividades podem ser descritos como uma sequência de instruções, que devem
ser seguidas para cumprir uma determinada tarefa.
Sequência Lógica são passos executados até atingir um objetivo ou a solução de um problema.
1.1.2 Instruções
Na linguagem comum, entende-se por instruções "um conjunto de regras ou normas definidas
para a realização ou emprego de algo".
Em informática instrução é a informação que indica a um computador qual a ação elementar ele deve
executar.
Convém ressaltar que uma única ordem isolada não permite realizar o processo completo, e para isso
é necessário um conjunto de instruções colocadas em ordem sequencial e lógica.
Por exemplo, se quisermos fazer uma omelete de batatas, precisaremos colocar em prática uma série
de instruções: descascar as batatas, bater os ovos, fritar as batatas, etc...
É evidente que essas instruções têm que ser executadas em uma ordem adequada – não se pode
descascar as batatas depois de fritá-las.
Uma instrução tomada em separado não tem sentido; para obtermos o resultado, precisamos colocar
em prática o conjunto de todas as instruções, na ordem correta.
Instruções são um conjunto de regras ou normas definidas para a realização ou emprego de algo. Em
informática, é o que indica a um computador uma ação elementar a executar.
1.2 Algoritmo
Um algoritmo é formalmente uma sequência finita de passos que levam a execução de uma tarefa.
Podemos pensar em algoritmo como uma receita, uma sequência de instruções que dão cabo de uma meta
específica. Estas tarefas não podem ser redundantes e nem subjetivas na sua definição, devem ser claras e
precisas.
Um Algoritmo é uma sequência de instruções ordenadas de forma lógica para a resolução de uma
determinada tarefa ou problema.
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
3
Apostila de Técnicas de Programação
Como exemplos, podemos citar os algoritmos das operações básicas (adição, multiplicação, divisão e
subtração) de números reais decimais. Outros exemplos seriam os manuais de aparelhos eletrônicos, como
um videocassete, que explicam passo-a-passo como, por exemplo, gravar um evento.
Até mesmo as coisas mais simples, podem ser descritas por sequências lógicas.
1.2.1 Pseudocódigo
Os algoritmos podem ser descritos em uma linguagem chamada pseudocódigo. Este nome é uma
referência à implementação que será realizada em uma linguagem de programação. Quando formos
programar em uma linguagem, por exemplo Pascal, estaremos gerando código em Pascal. Quando geramos
uma algoritmo independente de uma linguagem de programação estamos escrevendo em pseudocódigo. Por
isso os algoritmos são independentes das linguagens de programação. Ao contrário de uma linguagem de
programação, não existe um formalismo rígido de como deve ser escrito o algoritmo.
O algoritmo deve ser fácil de interpretar e fácil de codificar, ou seja, ele deve ser o intermediário
entre a linguagem falada e a linguagem de programação.
1.2.2 Regras para construção de Algoritmos
Para escrever um algoritmo precisamos descrever a sequência de instruções, de maneira simples e
objetiva. Para isso utilizaremos algumas técnicas:
● Use somente um verbo por frase
● Imagine que você está desenvolvendo um algoritmo para pessoas que não entendem do assunto
● Use frases curtas e simples
● Seja objetivo
● Procure usar palavras que não tenham sentido duplo
•
•
•
•
Exemplo de Algoritmo
O algoritmo descreve como "Chupar uma bala".
Pegar a bala
Retirar o papel
Chupar a bala
Jogar o papel no lixo
1.2.3 Fases para construção de Algoritmos
É importante ressaltar que qualquer tarefa que siga determinado padrão pode ser descrita por um
algoritmo, como por exemplo: como fazer arroz doce; calcular o saldo financeiro de um estoque, etc.
Entretanto, ao montar um algoritmo, precisamos primeiro dividir o problema apresentado em três
Entrada
Processamento
Saída
Realimentação
fases fundamentais:
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
4
Apostila de Técnicas de Programação
Imagine o seguinte problema: Calcular a média final dos alunos da 3ª série. Os alunos realizarão
quatro provas: P1, P2, P3 e P4.
P1 + P 2 + P3 + P 4
MédiaFinal =
4
Onde:
Para montar o algoritmo proposto, faremos três perguntas:
a) Quais são os dados de entrada?
R: Os dados de entrada são P1, P2, P3 e P4
b) Qual será o processamento a ser utilizado?
R: O procedimento será somar todos os dados de entrada e dividi-los por 4 (quatro)
P1 + P 2 + P3 + P 4
4
c) Quais serão os dados de saída?
R: O dado de saída será a média final
Algoritmo:
Receba a nota da prova1
Receba a nota de prova2
Receba a nota de prova3
Receba a nota da prova4
Some todas as notas e divida o resultado por 4
Mostre o resultado da divisão
1.2.4 Teste de Mesa
Após desenvolver um algoritmo, este deverá sempre ser testado. O teste é chamado de TESTE DE
MESA, que significa seguir as instruções do algoritmo de maneira precisa para verificar se o procedimento
utilizado está correto.
Veja o exemplo: Nota da Prova 1, Nota da Prova 2, Nota da Prova 3 , Nota da Prova 4 e Media.
P1 P2 P3 P4 Média
1.3 Programas
Os programas de computadores são algoritmos escritos numa linguagem de computador que são
interpretados e executados por uma máquina, no caso um computador. Notem que, dada esta interpretação
rigorosa, um programa é por natureza, muito específico e rígido em relação aos algoritmos da vida real.
Um programa é um algoritmo escrito em uma linguagem computacional.
2 Portugol
Durante o curso aprenderemos a desenvolver os Algoritmos em uma pseudo-linguagem conhecida
como "Portugol" ou Português Estruturado.
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
5
Apostila de Técnicas de Programação
"Portugol" é derivado da aglutinação de Português + Algol. Algol é o nome de uma linguagem de
programação estruturada usada no final da década de 50.
2.1 ENTRADA, PROCESSAMENTO E SAÍDA
Para se criar um programa que seja executável dentro de um computador, você deverá ter em mente
três pontos de trabalho: a entrada de dados, o seu processamento e a saída dos mesmos. Sendo assim, todo
programa estará trabalhando com estes três conceitos. Se os dados forem entrados de forma errada,
resultarão em respostas erradas.
As três fases do processo de execução de um programa são: a entrada de dados com a instrução
LEIA; saída dos mesmos com a instrução ESCREVA e o processamento que será uma consequência da
manipulação das variáveis de ação.
Uma entrada e uma saída poderão ocorrer dentro de um computador de diversas formas. Por
exemplo, uma entrada poderá ser feita via teclado, modem, leitores ópticos, disco, entre outras. Uma saída
poderá ser feita em vídeo, impressora, disco, entre outras formas. Devido a esta grande variedade, nossos
programas escritos em português estruturado farão menção às instruções LEIA e ESCREVA sem se
preocuparem com o meio de entrada e saída.
2.1.1 Corpo Geral de um Programa
PROGRAMA <<identificador>>
TIPO
<<identificador>> : <<tipo>>
CONST
<<identificador>> ← <<dado>>
VAR
<<identificador>> : <<tipo>>
início
{COMANDOS DE ENTRADA,PROCESSAMENTO E SAÍDA}
<<comando 1>>
<<comando N>>
fim
Exemplo 01 : Segue um Algoritmo que lê o nome e as 4 notas bimestrais de um aluno. Em seguida o
Algoritmo calcula e escreve a média obtida.
PROGRAMA MEDIA_FINAL
VAR
NOTA1, NOTA2, NOTA3, NOTA4, MEDIA: INTEIRO
início
LEIA (NOTA1, NOTA2, NOTA3, NOTA4)
MEDIA ← (NOTA1 + NOTA2 + NOTA3 + NOTA4) / 4
ESCREVER (MEDIA)
fim
2.1.2 Linhas de comentário
Podemos inserir em um Algoritmo um comentário para aumentar a compreensão do mesmo, para
isso basta que o texto fique entre Chaves "{}".
Exemplo:
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
6
Apostila de Técnicas de Programação
LEIA (NOTA1, NOTA2, NOTA3, NOTA4) {LEITURA DAS NOTAS DO ALUNO}
2.1.3 Identação
Para facilitar a leitura do algoritmo, no momento em que estamos desenvolvendo-o devemos tomar o
cuidado de identá-lo. A identação é a inserção de espaços antes da frase para facilitar a localização do
contexto. Estes espaços servem como os espaços antes dos parágrafos facilitando a localização do leitor.
2.2 Variáveis
Variáveis são espaços, como caixas vazias, destinados a armazenar informações temporariamente.
Estes valores são armazenados num local disponível na memória do computador.
A forma de declarar uma variável é:
VAR nome_da_variável : tipo_da_variável
* Todo Algoritmo ou programa deve possuir variável!
2.2.1 Variáveis de entrada e saída
Do ponto de vista do computador, as Variáveis de Entrada armazenam informações fornecidas por
um meio externo, normalmente usuários ou discos.
Já as Variáveis de Saída armazenam os resultados obtidos através do programa/algoritmo e que serão
apresentados para o usuário como resposta.
Exemplo ,dados dois valores calcular a soma de ambos:
C=A+B
A
2
B
5
7
De acordo com a figura acima A e B são Variáveis de Entrada e C é uma Variável de Saída. (inverter
a seta de A e B)
2.2.2 Constantes
Constantes armazenam informações fixas, inalteráveis durante a execução do programa. Estes
valores são armazenados em um local disponível na memória do computador. A grande diferença entre
constante e variável é que não é permitido alterar o valor da primeira.
Exemplo:
PI ← 3.1416
Empresa ← 'ACME L.T.D.A.'
V ← Verdadeiro
2.2.3 Identificadores
São os nomes dados às variáveis, constantes, Tipo de Dados, Registros e programas. Estes
indicadores servem para nos lembrar mais facilmente o que representa o conteúdo armazenado nas variáveis
e constantes ou para que servem os programas que iremos desenvolver.
Regras Para construção de Identificadores:
• Não podem ser nomes de palavras reservadas (comandos da linguagem);
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
7
Apostila de Técnicas de Programação
• Devem possuir como 1º caractere uma letra ou Underscore ( _ );
• Ter como demais caracteres letras, números ou Underscore;
• Ter no máximo 127 caracteres;
• Não possuir espaços em branco;
• A escolha de letras maiúsculas ou minúsculas é indiferente.
Exemplos:
NOME, nome, TELEFONE, IDADE_FILHO, IdadeFilho, NOTA1, SALARIO, PI,
UMNOMEMUITODIFICILDELER
2.2.4 Tipos de dados
Todas as Variáveis devem assumir um determinado tipo de informação. O tipo de dado indica que
tipo de informação podemos guardar dentro das variáveis.
O tipo de dado pode ser:
● Primitivo - Pré-definido pela linguagem;
● Sub-Faixa - É uma parte de um tipo já existente;
● Escalar - Definidos pelo programador.
2.2.5 Tipos primitivos de dados
●
●
●
●
Os tipos de dados primitivos são:
inteiro
− admite somente números inteiros. Geralmente é utilizado para representar uma
contagem (quantidade).
real
- admite números reais (com ou sem casas decimais). Geralmente é utilizado para
representar uma medição.
caracter - admite caracteres alfanuméricos. Os números quando declarados como caracteres se
tornam representativos e perdem a atribuição de valor.
lógico
- admite somente valores lógicos (verdadeiro/falso).
Exemplo:
var
idade : inteiro;
salario : real;
sexo : caracter;
2.2.6 Sinal de atribuição
Uma Variável nunca é eternamente igual a um valor, seu conteúdo pode ser alterado a qualquer
momento. Portanto para atribuir valores a variáveis devemos usar o sinal de atribuição: "←".
Exemplos:
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
8
Apostila de Técnicas de Programação
A ← 2
B ← 3
C ← A + B
2.3 Operadores e Expressões
2.3.1 Operadores Aritméticos
Tabela 1 - Operadores Aritméticos
Símbolo
+
*
/
MOD
Operador
Adição
Subtração
Multiplicação
Divisão
Resto da divisão entre 2 números inteiros.
2.3.2 Operadores Relacionais
Tabela 2 - Operadores Relacionais
Símbolo
>
<
>=
<=
=
<>
Operador
Maior que
Menor que
Maior ou Igual
Menor ou Igual
Igual
Diferente
2.3.3 Operadores lógicos
Atuam sobre expressões retornando sempre valores lógicos como Falso ou Verdadeiro.
• E
− retorna verdadeiro se ambas as partes forem verdadeiras.
• Ou − basta que uma parte seja verdadeira para retornar verdadeiro.
• Não − inverte o estado, de verdadeiro passa para falso e vice-versa.
A
V
V
F
F
B
V
F
V
F
TABELA VERDADE
AE B
A OU B
V
V
F
V
F
V
F
F
NÃO (A)
F
F
V
V
2.3.4 Expressões lógicas
As expressões compostas de operadores relacionais sempre retornam um valor lógico.
Exemplos:
2+5>4
3<>3
Verdadeiro
Falso
De acordo com a necessidade, as expressões podem ser unidas pelos operadores lógicos.
Exemplo:
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
9
Apostila de Técnicas de Programação
3>1 OU 3>5
3>1 E 3>5
Verdadeiro
Falso
2.3.5 Prioridade de Expressões
Na matemática existem prioridades na resolução de expressões, por exemplo, sempre se resolve a
multiplicação antes da soma. Em computação as prioridades são definidas de acordo com a linguagem
escolhida. Para o PORTUGOL adotamos a seguinte sequência, da maior para a menor:
Sinal
Tipo
NÃO
Negação
Operador lógico
/
MOD
Multiplicação, divisão e resto
Operador Aritmético
+
-
Soma e subtração
Operador Aritmético
<=
>
Menor, menor ou igual, maior, maior ou igual
Operador Relacional
=
<>
Igual, diferente
Operador Relacional
E
OU
E lógico, ou lógico
Operador lógico
*
<
Descrição
←
>=
Atribuição
Do mesmo modo que na matemática, nas expressões computacionais podemos usar parênteses "( )"
para priorizar expressões. É possível também ter parênteses dentro de parênteses.
Exemplos de prioridades:
(2+2)/2 = 2
2+2 /2 = 3
2.4 Comandos de i/o (input/output)
LER → Comando de entrada que permite a leitura de um valor e salva numa Variável de Entrada.
ESCREVER → Comando de saída que exibe uma informação na tela do monitor.
IMPRIMA → Comando de saída que envia uma informação para a impressora.
Exemplo 02 : Segue um Algoritmo que lê o raio de uma circunferência e calcula sua área.
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
10
Apostila de Técnicas de Programação
PROGRAMA AREA_CIRCUNFERENCIA
CONST
PI ← 3.1416
VAR
RAIO, AREA : REAL
início
LER (RAIO) {PROCESSAMENTO}
AREA ← PI * RAIO*RAIO {ENTRADA}
ESCREVER ("AREA =", AREA) {SAÍDA}
fim
2.5 A tomada de Decisões
Em algumas situações é necessário executar uma sequência de comandos diferentes de acordo com o
resultado de um teste. Por exemplo em um semáforo: Se estiver verde : continuar, senão : parar.
2.5.1 Desvio condicional
A estrutura de decisão pode ser Simples ou Composta, baseada em um resultado lógico.
Simples:
SE <<CONDIÇÃO>> ENTÃO
<<COMANDO1>>
Composta 1:
SE <<CONDIÇÃO>> ENTÃO
<<COMANDO1>>
SENÃO
<<COMANDO1>>
Composta 2:
SE <<CONDIÇÃO>> ENTÃO
início
<<COMANDO1>>
<<COMANDON>>
fim
SENÃO
início
<<COMANDO1>>
<<COMANDON>>
fim
Exemplo 01 : Segue um Algoritmo que lê 2 números e escreve o maior.
PROGRAMA ACHA_MAIOR
VAR
A, B : INTEIRO
início
LER (A, B)
SE A>B ENTÃO
ESCREVER (A)
SENÃO
ESCREVER (B)
fim
Exemplo 02 : Segue um Algoritmo que lê o nome e as 4 notas bimestrais de um aluno. Em seguida o
Algoritmo calcula e escreve a média obtida pelo aluno escrevendo também se o aluno foi aprovado ou
reprovado. Média para aprovação maior ou igual a 6.
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
11
Apostila de Técnicas de Programação
PROGRAMA MEDIA_FINAL
VAR
NOTA1, NOTA2, NOTA3, NOTA4, MEDIA: REAL
NOME : CARACTERE [35]
início
LER (NOME)
LER (NOTA1, NOTA2, NOTA3, NOTA4)
MEDIA ← (NOTA1 + NOTA2 + NOTA3 + NOTA4) / 4
SE MEDIA>=6 ENTÃO
ESCREVER ('APROVADO')
SENÃO
ESCREVER ('REPROVADO')
ESCREVER (NOME, MEDIA)
fim
2.5.2 Desvios encadeados
Usados para tomadas de decisões para mais de 2 opções. Forma Geral:
SE <<CONDIÇÃO>> ENTÃO
<<COMANDO1>>
SENÃO
SE <<CONDIÇÃO>> ENTÃO
<<COMANDO1>>
SENÃO
<<COMANDO1>>
Exemplo 01 : Segue um Algoritmo que lê 3 números e escreve o maior.
PROGRAMA ACHA_MAIOR
VAR
A, B, C : INTEIRO
início
LER (A, B, C)
SE ((A>B) E (A>C)) ENTÃO
ESCREVER (A)
SENÃO
SE ((B>A) E (B>C)) ENTÃO
ESCREVER (B)
SENÃO
ESCREVER (C)
fim
2.5.3 Estruturas de Decisão
A estrutura de decisão equivale a um conjunto de desvios encadeados.
Forma Geral:
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
12
Apostila de Técnicas de Programação
FACA CASO <<VARIAVEL>>
início
CASO <<VALOR1>>
<<COMANDO1>>
CASO <<VALORN>>
<<COMANDO1>>
OUTROS CASOS
<<COMANDO1>>
fim
Exemplo 01 : Segue um Algoritmo que lê uma opção e apresenta o resultado
PROGRAMA IMPRIME_SEXO
VAR
SEXO : INTEIRO
início
ESCREVER(“DIGITE 1 PARA SEXO MASCULINO E 2 PARA SEXO FEMININO:”)
LER (SEXO)
FACA CASO SEXO
início
CASO 1
ESCREVER (“HOMEM”)
CASO 2
ESCREVER (“MULHER”)
OUTROS CASOS
ESCREVER (“OPÇÃO INVALIDA”)
fim
fim
2.6 Laços ou Malhas de Repetição
Existem ocasiões onde é necessário efetuar a repetição de um trecho de programa um determinado
número de vezes. Neste caso, poderá ser criado uma estrutura de repetição que efetue o processamento de
um determinado trecho, tantas vezes quantas forem necessários. Estas estruturas são chamados de: laços de
repetição, malhas de repetição ou loopings.
Na programação estruturada existem comandos apropriados para efetuar a repetição de determinados
trechos dos programas, o número de vezes que for necessário. A principal vantagem deste recurso é que o
programa passa a ter um tamanho menor.
Todo looping deve possuir uma condição que indique quando deve terminar. É importante prestar
atenção nesta condição. Uma condição mal feita pode prender o programa dentro do loop. Esta é uma das
causas do “travamento” dos aplicativos.
2.6.1 Repetição com teste no Início do Looping
É usada para repetir N vezes uma ou mais instruções. Tendo como vantagem o fato de não ser
necessário o conhecimento prévio do número de repetições.
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
13
Apostila de Técnicas de Programação
Forma Geral 1:
ENQUANTO <<CONDIÇÃO>> FAÇA
<<COMANDO1>>
Forma Geral 2:
ENQUANTO <<CONDIÇÃO>> FAÇA
ínicio
<<COMANDO1>>
<<COMANDO2>>
...
<<COMANDON>>
fim
Exemplo 01 : Segue um algoritmo que calcula a soma dos salários dos funcionários de uma empresa.
O programa termina quando o usuário digitar um salário menor que 0.
PROGRAMA SOMA_SALARIOS
VAR
SOMA, SALARIO : REAL
início
SOMA←0
SALARIO←1
ENQUANTO (SALARIO>=0) FAÇA
início
LER (SALARIO)
SOMA←SOMA+SALARIO
fim
ESCREVER (SOMA)
fim
A estrutura ENQUANTO...FAÇA...FIM_ENQUANTO tem o seu funcionamento controlado por
decisão. Sendo assim poderá executar um determinado conjunto de instruções enquanto a condição
verificada for Verdadeira. No momento em que esta condição se torna falsa, o processamento da rotina é
desviado para fora do looping. Se a condição for Falsa logo de início, as instruções contidas no looping são
ignoradas.
2.6.2 Repetição com teste lógico no fim do Looping
Assim como a estrutura ENQUANTO...FAÇA...FIM_ENQUANTO, a estrutura REPITA...ATE é
usada para repetir N vezes uma ou mais instruções.
A diferença entre as duas é que a condição de continuidade é validada apenas no final fazendo com
que a repetição seja executada pelo menos uma vez. Forma Geral:
REPITA
<<COMANDO1>>
<<COMANDON>>
ATE <<CONDIÇÃO>>
Exemplo 01 : Segue um algoritmo que calcula a soma dos salários dos funcionários de uma empresa.
O programa termina quando o usuário digitar um salário menor que 0.
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
14
Apostila de Técnicas de Programação
PROGRAMA SOMA_SALARIOS
VAR
SOMA, SALARIO : REAL
início
SOMA←O
REPITA
LER (SALARIO)
SOMA←SOMA+SALARIO
ATE (SALARIO<0)
ESCREVER (SOMA)
fim
Notar que neste exemplo o primeiro valor lido de SALÁRIO é somado, mesmo que ele for negativo.
Exemplo 02 : Segue um algoritmo que escreve os 100 primeiros números pares.
PROGRAMA PARES_2
VAR
I, PAR, CONTADOR : INTEIRO
início
CONTADOR ← 0
PAR ← 0
REPITA
ESCREVER (PAR)
PAR ← PAR+2
CONTADOR ← CONTADOR+1
ATE (CONTADOR=100)
fim
A estrutura REPITA...ATÉ tem o seu funcionamento controlado por decisão. Porém, irá efetuar a
execução de um conjunto de instruções pelo menos uma vez antes de verificar a validade da condição
estabelecida. Diferente da estrutura ENQUANTO que executa somente um conjunto de instruções, enquanto
a condição é verdadeira.
Desta forma REPITA tem seu funcionamento em sentido contrário a ENQUANTO, pois sempre irá
processar um conjunto de instruções, no mínimo uma vez até que a condição se torne Falsa.
2.6.3 Repetição com variável de controle
Anteriormente, foram visto duas formas de elaborar um looping. Uma usando o conceito
ENQUANTO e a outra usando o conceito REPITA. Foi visto também como estabelecer rotinas que efetuam
a execução de um looping, um determinado número de vezes através da utilização de um contador (através
de uma variável de controle).
Porém, existe uma possibilidade de facilitar o uso de contadores finitos, sem fazer uso das estruturas
anteriores, deixando-as para a utilização de loopings onde não se conhece de antemão o número de vezes
que uma determinada sequência de instruções deverá ser executada. Os loopings que possuem um número
finito de execuções poderão ser processados através de estrutura de laços contados para, sendo conseguida
com a utilização do conjunto de instruções PARA..DE..ATÉ..PASSO..FAÇA..FIM_PARA.
A estrutura PARA..DE..ATÉ..PASSO..FAÇA..FIM_PARA tem seu funcionamento controlado por
uma variável denominada contador. Sendo assim, poderá executar um determinado conjunto de instruções
um determinado número de vezes. Forma Geral:
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
15
Apostila de Técnicas de Programação
Para <variável> de <valor inicial> até <valor final> passo <incremento> faça
início
<comando1>
fim
Exemplo 01 : Pedir a leitura de um valor para a variável X, multiplicar este valor por 3 e somá-lo à
variável de resposta R. Repetir esta sequência por cinco vezes e apresentar o valor obtido.
PROGRAMA Looping_Para
VAR
X, R ,CONT: Inteiro
início
Para CONT de 1 até 5 passo 1 faça
início
Leia (x)
R ← X * 3 + R
Escreva(R)
fim
fim
Será executado o conjunto de instruções entre a instrução PARA e a instrução FIM do para, sendo a
variável CONT (variável de controle) inicializada com valor 1 e incrementada de mais 1 através da instrução
passo até o valor 5. Este tipo de estrutura de repetição poderá ser utilizado todas as vezes que tiver a
necessidade de repetir trechos finitos, onde se conhece a quantidade de repetições.
2.7 Funções Pré-Definidas
Uma função é um instrumento (Sub–algoritmo) que tem como objetivo retornar um valor ou uma
informação.
A chamada de uma função é feita através da citação do seu nome seguido de seus argumentos iniciais
entre parênteses quando for necessário.
As funções podem ser pré-definidas pela linguagem ou criadas pelo programador de acordo com o
seu interesse.
A Tabela 3, mostra as funções mais comuns e importantes para o desenvolvimento, entretanto, cada
linguagem possui suas funções próprias. As funções podem ser aritméticas, temporais, de texto, etc.
Tabela 3 - Funções Pré-Definidas
Função
ABS( )
SQRT( )
SQR( )
TRUNC( )
DIV( )
Descrição
Valor absoluto
Raiz quadrada
Eleva ao quadrado
Valor truncado
Valor inteiro da divisão
Função
ROUND( )
LOG( )
SIN( )
COS( )
TAN( )
Descrição
Valor arredondado
Logaritmo
Seno
Coseno
Tangente
2.8 Estrutura de Dados Homogêneas
Durante os pontos estudados anteriormente, percebemos que o poder de programação se tornou
maior. Porém, tendo domínio das técnicas anteriores, ainda corre-se o risco de não conseguir resolver alguns
tipos de problemas, pois foram trabalhados até aqui apenas variáveis simples, variáveis que armazenam
somente um valor por vez.
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
16
Apostila de Técnicas de Programação
Neste e no próximo capítulo, serão apresentados técnicas de programação que permitirão trabalhar
com o agrupamento de várias informações dentro de uma mesma variável. Vale salientar que este
agrupamento ocorrerá obedecendo sempre ao mesmo tipo de dado, e por esta razão é chamado de estruturas
de dados homogêneas. Agrupamentos de tipo de dados diferentes serão estudados mais adiante quando for
abordado as estruturas de dados heterogêneas.
A utilização deste tipo de estrutura de dados recebe diversos nomes como: variáveis indexadas,
variáveis compostas, variáveis subscritas, arranjos, vetores, matrizes, tabelas em memória ou arrays (do
inglês). São vários os nomes encontrados na literatura voltado para o estudo de técnicas de programação que
envolvem a utilização das estruturas homogêneas de dados. Por nós, serão definidas como matrizes.
As matrizes (tabelas em memória) são tipos de dados que podem ser "constituídos" à medida que se
fazem necessários, pois não é sempre que os tipos básicos (real, inteiro, caractere ou lógico) e /ou variáveis
simples são suficientes para representar a estrutura de dados utilizada em um programa.
2.8.1 Matrizes de uma Dimensão ou Vetores
Este tipo de estrutura em particular é também denominado por alguns profissionais como matrizes
unidimensionais. Sua utilização mais comum está vinculada à criação de tabelas. Caracteriza-se por ser
definida uma única variável dimensionada com um determinado tamanho. A dimensão de uma matriz é
constituída por constantes inteiras e positivas. Os nomes dados às matrizes seguem as mesmas regras de
nomes utilizados para indicar as variáveis simples.
2.8.2 Operações Básicas com Matrizes do Tipo Vetor
Uma matriz de uma dimensão ou vetor será, neste trabalho, representada por seu nome e seu tamanho
(dimensão) entre colchetes, desta forma MD [1..N] seria uma matriz, onde MD é o seu nome e possue um
tamanho de 1 a N. Isto significa que poderão ser armazenados em MD até N valores definidos pelo
programador. Perceba que na utilização de variáveis simples existe uma regra: uma variável pode conter
apenas um valor por vez. As matrizes podem armazenar mais de um valor por vez. Desta forma poder-se-á
manipular uma quantidade maior de informação com pouco trabalho de processamento. Deve-se apenas
considerar que, com relação à manipulação dos elementos de uma matriz, eles ocorrerão de forma
individualizada, pois não é possível efetuar a manipulação de todos os elementos do conjunto ao mesmo
tempo. A instrução conjunto indicará em português estruturado a utilização de uma matriz, tendo como
forma geral:
Variável: conjunto [<dimensão>] de <tipo de dado>.
Onde <dimensão> será a indicação dos valores inicial e final do tamanho do vetor e <tipo de dado>
se o vetor em questão irá utilizar valores reais, inteiros, lógicos ou caracteres.
2.8.3 Leitura dos Dados de uma Matriz
A leitura de uma matriz é processada passo a passo, um elemento por vez. A instrução de leitura é
leia seguida da variável mais o índice. Abaixo, é apresentado a codificação em portugol da leitura de 8 notas
de 8 alunos, cálculo da média e a apresentação da mesma.
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
17
Apostila de Técnicas de Programação
PROGRAMA Media_Turma
VAR
Md : conjunto [1..8] de real
Soma, media : real
I : inteiro
início
Soma ← 0
Para I de 1 ate 8 faça
início
Leia (Md[I])
Soma ← Soma + MD[I]
fim
Média ← Soma / 8
Escreva (Media)
fim
2.8.4 Escrita dos Dados de uma Matriz
O processo de escrita de uma matriz é bastante parecido com o processo de leitura de seus elementos.
Para esta ocorrência deverá ser utilizada a instrução escreva seguida da indicação da variável e seu índice.
Supondo que após a leitura das 8 notas, houvesse a necessidade de apresentá-las antes da apresentação do
valor da média.
PROGRAMA Media_Turma
VAR Md : conjunto [1..8] de real
Soma, media : real
I : inteiro
início
Soma ← 0
Para I de 1 ate 8 faça
início
Leia (Md[I])
Soma ← Soma + MD[I]
fim
Para I de 1 ate 8 faça
início
Escreva (Md[I])
fim
Média ← Soma / 8
Escreva (Media)
fim
2.8.5 Matrizes com mais de uma dimensão
Um importante aspecto a ser considerado é que na manipulação de uma matriz é utilizado uma única
instrução de looping (enquanto, para ou repita). No caso de matrizes com mais dimensões, deverá ser
utilizado o número de loopings relativos ao tamanho de sua dimensão. Desta forma, uma matriz de duas
dimensões deverá ser controlada com dois loopings, sendo que de três dimensões deverá ser controlada por
três loopings e assim por diante.
Em matrizes de mais uma dimensão os seus elementos serão também manipulados de forma
individualizada, sendo a referência feita sempre através de dois índices: o primeiro para indicar a linha e o
segundo para indicar a coluna. Desta forma, TABELA[2,3], indica que está sendo feita uma referência ao
elemento armazenado na linha 2 coluna 3.
Uma matriz de duas dimensões está sempre fazendo menção a linhas e colunas e será representada
por seu nome e seu tamanho (dimensão) entre colchetes, desta forma seria uma matriz de duas dimensões
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
18
Apostila de Técnicas de Programação
TABELA[1..8, 1..5], onde TABELA é o seu nome, possuindo um tamanho de 8 linhas (de 1 a 8) e 5 colunas
(de 1 a 5), ou seja, é uma matriz de 8 por 5 (8X5). Isto significa que poderão ser armazenados em TABELA
até 40 elementos.
Uma matriz de duas dimensões será atribuída pelas instruções já utilizadas para definir o uso de uma
matriz de uma dimensão, sendo bastante parecidos em sua referência. A forma geral é :
VARIAVEL : conjunto
[<dimensão1, dimensão2>] de
<tipo de dado>
Onde <dimensão1> e <dimensão2> indicam o tamanho da tabela e <tipo de dado> o tipo da matriz,
que poderá ser formada por valores reais, inteiros, lógicos ou caracteres.
2.8.6 Leitura dos Dados de uma Matriz
A leitura de uma matriz de duas dimensões assim como as matrizes de uma dimensão é processada
passo a passo, ou seja, um elemento por vez, sendo utilizado a instrução leia seguida da variável mais os
seus índices. A seguir é apresentado a codificação em português estruturado da leitura das 4 notas bimestrais
de 8 alunos.
PROGRAMA Ler_Elementos
VAR
Notas : conjunto [1..8, 1..4] de real
I, J : inteiro
início
Para I de 1 até 8 faça
início
Para J de 1 até 4 faça
início
Leia(notas[I,J])
fim
fim
fim
2.8.7 Escrita dos Dados de uma Matriz
O processo de escrita será bastante parecido com o processo de leitura de seus elementos. Abaixo é
apresentado a codificação em português estruturado da escrita das 4 notas dos 8 alunos.
PROGRAMA Ler_Elementos
VAR Notas : conjunto [1..8, 1..4] de real
I, J, temp : inteiro
início
Para I de 1 até 8 faça
início
Para J de 1 até 4 faça
início
Leia (temp)
notas[I,J] ← temp
fim
fim
fim
2.9 Estrutura de Dados Heterogêneas
Nos tópicos anteriores, você teve um contato com técnicas de programação que envolveu o uso de
estruturas de dados homogêneas, através da utilização de matrizes de uma e duas dimensões. Observou que
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
19
Apostila de Técnicas de Programação
somente foi possível trabalhar com um tipo de dado por matriz. No momento em que se precisa trabalhar
com dois tipos de dados diferentes, é necessário a utilização também de duas matrizes, uma de cada tipo.
2.9.1 Estrutura de um Registro
Agora você terá contato com a utilização da principal estrutura de dados, o registro, que consiste em
trabalhar vários dados, ou campos, de tipos diferentes em uma mesma estrutura. Por esta razão, este tipo de
dado é considerado heterogêneo.
2.9.2 Atribuição de Registros
Os tipos registro devem ser declarados ou atribuídos antes das variáveis, pois poderá ocorrer a
necessidade de se declarar uma variável com o tipo registro.
Para se declarar um tipo registro em português estruturado deverá ser utilizada a instrução TIPO em
conjunto com a instrução REGISTRO...INICIO...FIM, conforme a sintaxe indicada abaixo.
TIPO
<identificador> : registro
início
<lista dos campos e seus tipos>
fim
VAR
<variável> : <identificador>
Onde <identificador> é o nome do tipo registro em caracteres maiúsculos, em itálico como as
variáveis, e lista dos campos e seus tipos é a relação de variáveis que serão usadas como campos, bem como
o seu tipo de estrutura de dados, podendo ser: real, inteiro, lógico ou caractere.
Após a instrução var, deverá ser indicada a variável tipo registro e a declaração do seu tipo de acordo
com um identificador definido anteriormente. Perceba que a instrução tipo deverá ser utilizada antes da
instrução var, pois ao definir um tipo de variável, pode-se fazer uso deste tipo definido.
Tomando como exemplo a proposta de se criar um registro denominado ALUNO, cujos campos são
NOME, NOTA1, NOTA2, NOTA3 e NOTA4, este seria assim declarado:
TIPO MEUTIPO : registro
início
NOME : caractere
NOTA1 : real
NOTA2 : real
NOTA3 : real
NOTA4 : real
fim
VAR ALUNO : MEUTIPO
Observe que é especificado um registro denominado CAD_ALUNO, o qual é um conjunto de dados
heterogêneos (um campo tipo caractere e quatro do tipo real). Desta forma é possível guardar em uma
mesma estrutura vários tipos diferentes de dados.
A título de comparação, pode-se dizer que um tipo registro é também um vetor (matriz de uma
dimensão) pois, se tem a variável ALUNO do tipo CAD_ALUNO como um vetor com os índices NOME,
NOTA1, NOTA2, NOTA3 e NOTA4.
2.9.3 Leitura de Registros
A leitura de um registro é efetuada com a instrução LEIA seguida do nome da variável registro e seu
campo correspondente separado por um caractere "." ponto.
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
20
Apostila de Técnicas de Programação
PROGRAMA Leitura
TIPO
MEUTIPO : registro
início
NOME : caractere
NOTA1 : real
NOTA2 : real
NOTA3 : real
NOTA4 : real
fim
VAR ALUNO : MEUTIPO
início
Leia
Leia
Leia
Leia
Leia
fim
(Aluno.Nome)
(Aluno.Nota1)
(Aluno.Nota2)
(Aluno.Nota3)
(Aluno.Nota4)
2.9.4 Escrita de Registros
O processo de escrita de um registro pode ser feito com a instrução escreva.
PROGRAMA Escrita
TIPO
CAD_ALUNO : registro
início
NOME : caractere
NOTA1 : real
NOTA2 : real
NOTA3 : real
NOTA4 : real
fim
VAR
ALUNO : CAD_ALUNO
início
Escreva
Escreva
Escreva
Escreva
Escreva
fim
(Aluno.Nome)
(Aluno.Nota1)
(Aluno.Nota2)
(Aluno.Nota3)
(Aluno.Nota4)
2.10 Estrutura de um Registro de Conjuntos
No tópico anterior, foi apresentado o conceito de se trabalhar com um registro. No ponto de
aprendizado em que estamos, podemos até jurar que você esteja perguntando: Será que não é possível definir
um vetor ou mesmo uma matriz dentro de um registro, para não ser necessário utilizar somente os tipos
primitivos de dados? Isto é realmente possível. Considere ainda o exemplo do registro ALUNO, onde temos
o campo NOME tipo caractere e mais quatro campos tipo real para o armazenamento de duas notas sendo,
NOTA1, NOTA2, NOTA3 e NOTA4. Veja que pode-se definir um vetor chamado NOTA com quatro
Índices, uma para cada nota.
Tomando como exemplo a proposta de se criar um registro denominado ALUNO, cujas notas serão
informadas em um vetor, este seria declarado:
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
21
Apostila de Técnicas de Programação
TIPO
CAD_ALUNO : registro
início
NOME : caractere
NOTA : conjunto[1..4] de real
fim
Observe que ao ser especificado o registro CAD_ALUNO, existe nele um campo chamado NOTA
do tipo bimestre, onde bimestre é a especificação de um tipo de conjunto matricial de um única dimensão
com capacidade para quatro elementos. Veja que o tipo de bimestre foi anteriormente definido, pois se
caracteriza por um tipo criado, assim como o tipo CAD_ALUNO atribuído à variável de registro ALUNO.
2.10.1 Leitura de Registro de Conjuntos
A leitura de um registro de conjunto é efetuada com a instrução leia, geralmente dentro de um laço de
repetição. Assim sendo, observe o código abaixo:
PROGRAMA Leitura
TIPO BIMESTRE : conjunto [1..4] de real
CAD_ALUNO : registro
início
NOME : caractere
NOTA : bimestre
fim
VAR
ALUNO : CAD_ALUNO
I : inteiro
início
Leia (ALUNO.NOME)
Para I de 1 ate 4 faça
início
Leia (ALUNO.NOTA[I])
fim
fim
2.10.2 Estrutura de um conjunto de Registros
Com as técnicas de programação anteriormente apresentadas, passou-se a ter uma mobilidade
bastante grande, podendo trabalhar de uma forma mais adequada com diversos problemas, principalmente os
que envolvem a utilização de dados heterogêneos, facilitando a construção de programas mais eficientes.
Porém, os programas apresentados até aqui com a utilização de registros, só fizeram menção à leitura e
escrita de um único registro.
Neste momento, você terá contato com o conjunto de registros que permite a construção de
programas, onde é possível fazer a entrada, processamento e saída de diversos registros.
Para declarar um conjunto de registros é necessário em primeiro lugar, possuir a definição de um
registro, ou seja, é necessário ter um formato de um único registro para então definir o número de registros
que será utilizado pelo programa. Para exemplificar o que está sendo exposto, considere que você deverá
fazer um programa que leia o nome e as quatro notas escolares de 8 alunos. Isto já e familiar. Veja a seguir a
codificação do conjunto de registros para os oito alunos:
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
22
Apostila de Técnicas de Programação
TIPO
BIMESTRE : conjunto [1..4] de real
CAD_ALUNO : registro
início
NOME : caractere
NOTA: BIMESTRE
fim
VAR
ALUNO: conjunto [1..70] de CAD_ALUNO
Observe que após a instrução var, é indicada a variável de registros ALUNO, sendo esta um conjunto
de 70 registros do tipo Cad_Aluno, que por sua vez Bimestre é um conjunto de quatro valores reais.
2.10.3 Leitura de Conjunto de Registros
A leitura é feita de forma semelhante às anteriores. No entanto, serão utilizados dois laços, pois além
de controlar a entrada das quatro notas de cada aluno, tem que controlar a entrada de 8 alunos. Esta estrutura
é bastante similar a uma matriz de duas dimensões. Assim sendo, observe o código em português
estruturado:
PROGRAMA LEITURA
TIPO
BIMESTRE : conjunto [1..4] de real
CAD_ALUNO : registro
início
NOME : caractere
NOTA: BIMESTRE
fim
VAR
ALUNO: conjunto [1..8] de CAD_ALUNO
I, J : inteiro
início
Para J de 1 até 8 faça
início
Leia (ALUNO[J].NOME)
Para I de 1 até 4 faça
início
Leia (ALUNO[J].NOta[I])
fim
fim
fim
Veja que o looping da variável J controla o número de alunos da turma, no caso 8, e o looping da
variável I controla o número de notas, até 4 por aluno. Para cada movimentação de mais uma variável J
existem quatro movimentações na variável I.
2.10.4 Escrita de Conjunto de Registros
O processo de escrita de um conjunto de registros é similar aos modos anteriores, já estudados.
Assim sendo, veja o código:
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
23
Apostila de Técnicas de Programação
PROGRAMA LEITURA
TIPO
BIMESTRE : conjunto [1..4] de real
CAD_ALUNO : registro
início
NOME : caractere
NOTA: BIMESTRE
fim
VAR
ALUNO: conjunto [1..8] de CAD_ALUNO
I, J : inteiro
início
Para J de 1 até 8 faça
início
Escreva (ALUNO[J].NOME)
Para I de 1 até 4 faça
início
Escreva (ALUNO[J].Nota[I])
fim
fim
fim
2.11 Programação Modular
Será estudada a partir deste ponto, a aplicação de subrotinas em algoritmos, também conhecidas pela
denominação módulo ou subalgoritmo. O importante é a forma como funcionam e como devem ser
aplicadas em um programa, e é isto que você aprenderá.
Neste capítulo, será introduzido o conceito da criação estruturada de programas, pois para escrever
um programa de computador necessita-se de estudo (levantamento de todas as necessidades e detalhes do
que deverá ser feito) e metodologia (regras básicas que deverão ser seguidas). Sem a aplicação de métodos
não será possível resolver grandes problemas, no máximo, pequenos problemas.
2.11.1 Sub-Rotinas
No geral, problemas complexos exigem algoritmos complexos. Mas sempre é possível dividir um
problema grande em problemas menores. Desta forma, cada parte menor tem um algoritmo mais simples, e é
este trecho menor é chamado de sub-rotina. Uma sub-rotina é na verdade, um programa, e sendo um
programa poderá efetuar diversas operações computacionais (entrada, processamento e saída) e deverá ser
tratado como foram os programas projetados até este momento. As sub-rotinas são utilizadas na divisão de
algoritmos complexos, permitindo assim, possuir a modularização de um determinado problema,
considerado grande e de difícil solução.
Ao se trabalhar com esta técnica, pode-se deparar com a necessidade de se dividir uma sub-rotina em
outras tantas quantas forem necessárias, buscando uma solução mais simples de uma parte do problema
maior. O processo de dividir sub-rotinas em outras é denominado Método de Refinamento Sucessivo.
2.11.2 Procedimentos
Um procedimento é um bloco de programa, contendo início e fim e será identificado por um nome,
através do qual será referenciado em qualquer parte do programa principal ou do programa que chama a
rotina. Quando uma sub-rotina é chamada por um programa, ela é executada e ao seu término o controle de
processamento retorna automaticamente para a primeira linha de instrução após a linha que efetuou a
chamada da sub-rotina.
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
24
Apostila de Técnicas de Programação
PROCEDIMENTO <nome do procedimento>
VAR
<variáveis>
início
<instruções>
fim
A melhor maneira de se entender como trabalhar com sub-rotinas é fazer a sua aplicação em um
programa mais complexo. Para tanto, imagine o seguinte problema:
Exemplo:
Um programa de calculadora que apresenta um menu de seleções no programa principal. Este menu
deverá dar ao usuário a possibilidade de escolher uma entre quatro operações aritméticas. Escolhida a opção
desejada, deverá ser solicitada a entrada de dois números, e processada a operação, o resultado deverá ser
exibido. Note que este programa deverá ser um conjunto de 5 rotinas, uma principal e 4 secundárias. A
rotina principal efetuará o controle sobre as 4 rotinas secundárias, que por sua vez pedirão a leitura de dois
valores, farão a operação e apresentarão o resultado obtido. Observe agora a codificação:
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
25
Apostila de Técnicas de Programação
PROGRAMA calculadora
VAR
Opcao : inteiro
PROCEDIMENTO ROTSOMA
VAR
r, a, b : real
início
Escreva ("Rotina de Soma")
Escreva ("Entre um valor para A: ")
Leia(A)
Escreva ("Entre um valor para B:")
Leia(B)
R ← A + B
Escreva ("A soma de A com B é = ", R)
fim
PROCEDIMENTO ROTSSUBTRACAO
VAR
r, a, b : real
início
Escreva ("Rotina de Subtração")
Escreva ("Entre um valor para A: ")
Leia(A)
Escreva ("Entre um valor para B:")
Leia(B)
R ← A – B
Escreva ("A subtração de A com B é = ", R)
fim
PROCEDIMENTO ROTMULTIPLICACAO
VAR
r, a, b : real
início
Escreva ("Rotina de Multiplicação")
Escreva ("Entre um valor para A: ")
Leia(A)
Escreva ("Entre um valor para B:")
Leia(B)
R ← A * B
Escreva ("A multiplicação de A com B é = ", R)
fim
PROCEDIMENTO ROTDIVISAO
VAR
r, a, b : real
início
Escreva ("Rotina de Divisão")
Escreva ("Entre um valor para A: ")
Leia(A)
Escreva ("Entre um valor para B:")
Leia(B)
R ← A / B
Escreva ("A Divisão de A com B é = ", R)
fim
{Programa Principal}
início
opcao ← 0
enquanto (opcao <> 5) faça
inicio
escreva ("1 – Adição")
escreva ("2 – Subtração")
escreva ("3 – Multiplicação")
escreva ("4 – Divisão")
escreva ("5 – Fim do Programa")
escreva ("Escolha uma opção")
leia (opcao)
se opcao = 1 então
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
26
Apostila de Técnicas de Programação
inicio
rotsoma
fim
se opcao = 2 então
inicio
rotsubtracao
fim
se opcao = 3 então
inicio
rotmultiplicacao
fim
se opcao = 4 então
inicio
rotdivisao
fim
fim
fim
Obs: Observe que cada sub-rotina possui suas próprias variáveis, estas porém só podem ser acessadas
dentro de cada procedimento, neste caso são chamadas de variáveis locais. A variável opcao é uma variável
global que pode ser acessada em qualquer local do programa, tanto nos procedimentos quanto no programa
principal.
2.11.3 Funções
Uma função também é um bloco de programa como são os procedimentos, contendo início e fim e
sendo identificado por um nome através do qual também será referenciada em qualquer parte do programa
principal. Uma sub-rotina de função é na verdade muito parecida com uma sub-rotina de procedimento. A
sintaxe em português estruturado será também idêntica ao estudo anterior. Observe a seguir, o código em
português estruturado de uma função.
FUNÇÂO <nome da função> (<VARIAVEL>:<TIPO DE DADO> ) : <TIPO DE DADO>
VAR
<variáveis>
início
<instruções>
fim
A sua principal diferença entre a função e a subrotina está no fato de que uma função retorna um
determinado valor, que é retornado no próprio nome da função. Quando se diz valor, devem ser levados em
consideração os valores numéricos, lógicos ou literais (caracteres).
Você deve ter observado a presença de um item na sintaxe da função, que são os parâmetros que
podem ser referenciados nos procedimentos.
Os parâmetros têm por finalidade servir como um ponto de comunicação bidirecional entre uma subrotina e o programa principal ou com uma outra sub-rotina hierarquicamente de nível mais alto. Desta
forma, é possível passar valores de uma sub-rotina ou rotina chamadora à outra sub-rotina e vice-versa,
através do uso de parâmetros que poderão ser formais ou reais.
Serão considerados parâmetros formais quando forem declarados através de variáveis juntamente
com a identificação do nome da sub-rotina, os quais serão tratados exatamente da mesma forma que são
tratadas as variáveis globais ou locais.
Serão considerados parâmetros Reais quando estes substituírem os parâmetros formais, quando a
utilização da sub-rotina por um programa principal ou por uma rotina chamadora.
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
27
Apostila de Técnicas de Programação
2.11.4 Utilização de Funções
Criaremos uma função que eleva ao cubo um determinado número inserido pelo usuário. Observe o
Programa:
PROGRAMA cubo
VAR
I : real
x : real
FUNÇÃO Cubo(N:Real) : Real
início
Cubo ← N * N * N
fim
início
Leia(I)
x ← Cubo(I)
fim
Observe que neste caso o parâmetro formal foi a variável "N", enquanto o parâmetro real foi a
variável "I".
Prof.Dr.Enzo Seraphim e Profa.Dra.Thatyana de Faria Piola Seraphim
28