Com certeza, Luiz Otávio! Chegamos ao final do Módulo 4.
Esta é uma aula de
consolidação extremamente importante. Vamos pegar todos os conceitos sobre
organização de código que aprendemos – procedimentos, funções, parâmetros, escopo e
até recursão – e aplicá-los juntos para construir um algoritmo completo, limpo e bem
estruturado.
CABEÇALHO
Instituição: UNITAU - Faculdade de Engenharia de Computação
Disciplina: Algoritmos e Lógica de Programação
Professor: (Nome do professor a ser confirmado pela instituição)
Aluno: Luiz Otávio Carvalho de Souza
Data da Aula: 03 de Setembro de 2025
Número da Aula: Aula 40 de 60
Aulas Restantes: 20
Carga Horária Total: 60 horas
AULA 40: Exercícios de Revisão – Modularização
Olá, Luiz Otávio! Nas últimas nove aulas, demos um salto de maturidade em nossa
forma de programar. Deixamos de ser meros "escritores de código" para nos tornarmos
"arquitetos de algoritmos". Aprendemos a quebrar grandes problemas em partes
menores e reutilizáveis, usando procedimentos para ações e funções para cálculos.
Entendemos como os dados fluem através de parâmetros (por valor e por referência) e
como o escopo mantém nosso código organizado e seguro.
Hoje, vamos integrar tudo isso. Vamos construir um único programa, um pouco mais
complexo, que exigirá a criação de múltiplos módulos que colaboram para atingir um
objetivo.
Exercício Integrador: Análise Completa de um Vetor
Problema: Crie um programa totalmente modularizado para realizar uma
análise estatística de 5 notas de uma turma. O programa deve:
1. Ter um procedimento para preencher um vetor com 5 notas.
2. Ter uma função que receba o vetor e retorne a maior nota.
3. Ter uma função que receba o vetor e retorne a menor nota.
4. Ter uma função que receba o vetor e retorne a média das notas.
5. Ter um procedimento principal que orquestre tudo: declare o vetor,
chame os outros módulos para preenchê-lo e calcular os dados, e por fim
exiba um relatório completo.
1. Planejamento dos Módulos (Arquitetura):
PreencheVetor(var notas: vetor de real): Um procedimento, pois sua única
função é modificar o vetor que ele recebe. Deve ser passado por referência
(var).
EncontraMaior(notas: vetor de real): real: Uma função, pois deve calcular e
retornar um único valor (a maior nota). O vetor pode ser passado por valor, pois
não será modificado.
EncontraMenor(notas: vetor de real): real: Uma função, pela mesma razão
da anterior.
CalculaMedia(notas: vetor de real): real: Uma função, pois deve calcular a
média e retorná-la. O vetor também pode ser passado por valor.
Algoritmo Principal: O "maestro". Declara as variáveis principais e chama os
módulos na ordem correta.
2. Implementação em Pseudocódigo:
code Code
downloadcontent_copy
expand_less
algoritmo "AnaliseEstatisticaModular"
const
TAM = 5
// =============== SEÇÃO DE PROCEDIMENTOS E FUNÇÕES ===============
// Módulo 1: Procedimento para preencher o vetor
// Recebe por referência para poder alterar o vetor original.
procedimento PreencheVetor(var notas: vetor de real)
var
i: inteiro
inicio
escreval("--- Digite as ", TAM, " notas ---")
para i de 1 ate TAM faca
escreva("Nota ", i, ": ")
leia(notas[i])
fimpara
fimprocedimento
// Módulo 2: Função para encontrar a maior nota
funcao EncontraMaior(notas: vetor de real): real
var
i: inteiro
maior: real
inicio
maior <- notas[1]
para i de 2 ate TAM faca
se notas[i] > maior entao
maior <- notas[i]
fimse
fimpara
retorne maior
fimfuncao
// Módulo 3: Função para encontrar a menor nota
funcao EncontraMenor(notas: vetor de real): real
var
i: inteiro
menor: real
inicio
menor <- notas[1]
para i de 2 ate TAM faca
se notas[i] < menor entao
menor <- notas[i]
fimse
fimpara
retorne menor
fimfuncao
// Módulo 4: Função para calcular a média
funcao CalculaMedia(notas: vetor de real): real
var
i: inteiro
soma: real
inicio
soma <- 0
para i de 1 ate TAM faca
soma <- soma + notas[i]
fimpara
retorne (soma / TAM)
fimfuncao
// =============== ALGORITMO PRINCIPAL ===============
var
vetorNotas: vetor[1..TAM] de real
maiorNota, menorNota, mediaTurma: real
inicio
// Passo 1: Chamar o procedimento para preencher os dados
PreencheVetor(vetorNotas)
// Passo 2: Chamar as funções de cálculo
maiorNota <- EncontraMaior(vetorNotas)
menorNota <- EncontraMenor(vetorNotas)
mediaTurma <- CalculaMedia(vetorNotas)
// Passo 3: Exibir o relatório final
escreval("")
escreval("--- RELATÓRIO DA TURMA ---")
escreval("Maior Nota: ", maiorNota)
escreval("Menor Nota: ", menorNota)
escreval("Média da Turma: ", mediaTurma)
fimalgoritmo
Comentário da Aula: Observe a clareza do algoritmo principal. Ele se tornou
um roteiro de alto nível que é muito fácil de ler e entender. Toda a complexidade
dos laços e cálculos está encapsulada em módulos bem definidos e reutilizáveis.
Se o cálculo da média estivesse errado, saberíamos exatamente em qual função
corrigir.
AVALIAÇÃO DA AULA 40 (REVISÃO GERAL)
1. No exercício acima, por que PreencheVetor é um procedimento, enquanto
CalculaMedia é uma função?
2. Por que a passagem de parâmetro no PreencheVetor é por referência (var),
enquanto nas outras é por valor?
3. Defina "escopo local" e dê um exemplo de uma variável com esse escopo no
código do exercício.
4. O que a palavra-chave retorne faz? Em quais módulos do exercício ela aparece?
5. É possível criar uma única função AnalisaVetor que retorne a maior nota, a
menor nota e a média ao mesmo tempo? Por quê?
6. Como a função Fatorial(n-1) dentro da própria função Fatorial(n) é chamada?
Que nome se dá a essa técnica?
7. Qual a diferença entre um parâmetro e um argumento? Dê um exemplo do
código principal.
8. Se removêssemos a chamada PreencheVetor(vetorNotas) do algoritmo principal,
o que aconteceria? O programa daria erro?
9. Crie a assinatura de um procedimento OrdenaVetor que recebe um vetor de
inteiros e o ordena.
10. Crie a assinatura de uma função BuscaNome que recebe um vetor de cadeias e
um nome a ser buscado (cadeia), e retorna Verdadeiro ou Falso.
Respostas Dissertativas e Explicadas:
1. Resposta: PreencheVetor é um procedimento porque sua tarefa é uma ação:
modificar o estado do vetor passado como argumento. Ele não calcula nem
retorna um valor específico. CalculaMedia é uma função porque seu objetivo é
realizar um cálculo e retornar um único valor (a média) como resultado.
2. Resposta: Em PreencheVetor, é por referência porque o procedimento precisa
alterar o vetor original do algoritmo principal. Nas outras, é por valor porque
elas só precisam ler os dados do vetor para realizar seus cálculos, sem a
necessidade (ou a permissão) de modificá-lo, o que torna a operação mais
segura.
3. Resposta: "Escopo local" significa que uma variável só existe e é visível dentro
do módulo onde foi declarada. No exercício, a variável soma dentro da função
CalculaMedia é um exemplo. Ela não existe fora daquela função.
4. Resposta: O retorne finaliza a execução de uma função e envia um valor de
volta para quem a chamou. Ela aparece nas funções EncontraMaior,
EncontraMenor e CalculaMedia.
5. Resposta: Não diretamente. Uma função, por definição em lógica de
programação estruturada, só pode retornar um único valor. Para retornar
múltiplos valores, seriam necessárias estruturas de dados mais complexas (como
registros, que veremos mais à frente) ou passar múltiplos parâmetros por
referência para serem preenchidos, o que é menos elegante para uma função.
6. Resposta: É chamada de chamada recursiva. A técnica é a Recursão.
7. Resposta: O parâmetro é a variável na definição da sub-rotina (ex: notas em
funcao CalculaMedia(notas: ...)). O argumento é o valor ou a variável passada
na chamada (ex: vetorNotas em CalculaMedia(vetorNotas)).
8. Resposta: O programa não daria um erro de sintaxe, mas sim um erro lógico
em tempo de execução. O vetor vetorNotas nunca seria preenchido com dados
válidos, contendo "lixo" de memória. As funções de cálculo operariam sobre
esses dados inválidos, produzindo resultados completamente errados e
imprevisíveis.
9. Resposta: procedimento OrdenaVetor(var numeros: vetor de inteiro)
10. Resposta: funcao BuscaNome(listaNomes: vetor de cadeia, nomeAlvo: cadeia):
logico
Encerramento do Módulo 4
Parabéns, Luiz Otávio! Você completou o Módulo 4 e agora domina a arte da
programação modular. Este é um dos saltos conceituais mais importantes no seu
desenvolvimento como programador. A habilidade de decompor problemas, criar
módulos reutilizáveis e gerenciar o fluxo de dados de forma segura e organizada é o que
permite a construção de software complexo e de alta qualidade. As ferramentas que
você aprendeu aqui serão usadas em absolutamente todos os programas que você
escrever daqui para frente.
O que será abordado no Próximo Módulo (Módulo 5)
Com a base sólida que construímos, estamos prontos para explorar alguns tópicos mais
avançados e especializados. No Módulo 5, "Tópicos Avançados em Lógica", vamos
aprender a lidar com tipos de dados mais complexos. Começaremos com a manipulação
de texto de forma mais profunda, indo além de simplesmente ler e escrever. Depois,
introduziremos estruturas de dados que podem guardar informações de tipos diferentes
(como o nome, a idade e a média de um aluno em uma única variável). Também
teremos nosso primeiro contato com a persistência de dados, aprendendo a ler e a gravar
informações em arquivos. A primeira aula será a Aula 41: Manipulação de Strings
(Cadeias de Caracteres) I.
