Capítulo 17: Procedimentos e Escopo de Variáveis (Modularização I)

🎯 Objetivo da Aula

Programas corporativos reais não possuem 20 ou 30 linhas: eles contêm milhares de linhas de código. Escrever tudo em um único bloco contínuo torna o software impossível de ler, testar e manter. A solução consagrada da Engenharia de Software é a Modularização.

Nesta aula, você aprenderá a:

1. Compreender o princípio DRY (Don’t Repeat Yourself) e a decomposição modular.
2. Dominar a sintaxe de procedimento Nome(parametros) no VisuAlg.
3. Diferenciar Variáveis Globais (acessíveis por todo o programa) de Variáveis Locais (exclusivas do procedimento).
4. Praticar a Passagem de Parâmetros por Valor.

🏢 O Cenário Prático (Seu Desafio)

Situação: O sistema de faturamento da FastLog possui mais de 10 telas diferentes (Cadastro de Clientes, Cotação de Frete, Emissão de CT-e, etc.). Em todas as telas, é obrigatório imprimir um Cabeçalho Visual Padronizado com o logotipo da empresa e desenhar molduras de mensagens. Toda vez que a empresa muda de slogan, o programador precisa alterar 10 partes diferentes do código manual.

Missão: Você deve criar o procedimento modular ImprimirCabecalho() e o procedimento ExibirAlerta(msg : caractere), centralizando a formatação visual e eliminando a duplicidade de código no sistema.

🧠 Fundamentos: A Teoria da Modularização

1. O que é um Procedimento?

Um Procedimento (Procedure / Sub-rotina) é um bloco independente de instruções que realiza uma tarefa específica quando é “chamado” pelo programa principal, mas não devolve nenhum valor de retorno diretamente para a variável:

graph TD
    A[Algoritmo Principal] -->|1. Chama: ImprimirCabecalho| B["Procedimento ImprimirCabecalho()"]
    B -->|2. Desenha moldura e slogan| B
    B -->|3. Retorna o controle| A
    A -->|4. Continua execução normal| C[Processar Pedido]
    
    style A fill:#2980b9,stroke:#fff,stroke-width:2px,color:#fff
    style B fill:#f39c12,stroke:#fff,stroke-width:2px,color:#fff
    style C fill:#217346,stroke:#fff,stroke-width:2px,color:#fff

2. Onde Declarar Procedimentos no VisuAlg?

Os procedimentos devem ser escritos na área de declarações, acima do inicio do algoritmo principal:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

algoritmo "Exemplo_Procedimento"
var
   // Variáveis Globais (Visíveis em qualquer lugar)
   empresa : caractere

// Declaração do Procedimento
procedimento ImprimirCabecalho()
var
   // Variáveis Locais (Existem APENAS dentro deste procedimento)
   i : inteiro
inicio
   escreval("==========================================")
   escreval("           FASTLOG TRANSPORTES            ")
   escreval("==========================================")
fimprocedimento

// Início do Algoritmo Principal
inicio
   ImprimirCabecalho() // Invocação / Chamada
   escreval("Sessão Iniciada.")
   ImprimirCabecalho() // Pode ser chamado quantas vezes quiser!
fimalgoritmo

3. Escopo de Variáveis: Global vs Local

📖 Exemplo Guiado: Sistema com Procedimentos Parametrizados

Código do Algoritmo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

algoritmo "Sistema_Modular_FastLog"
var
   cliente : caractere
   valorCarga : real

// Procedimento 1: Sem Parâmetros
procedimento DesenharLinha()
inicio
   escreval("------------------------------------------")
fimprocedimento

// Procedimento 2: Com Parâmetro de Entrada (Passagem por Valor)
procedimento NotificarStatus(mensagem : caractere)
inicio
   escreval("")
   escreval(">>> [NOTIFICAÇÃO DO SISTEMA]:")
   escreval("    ", mensagem)
   DesenharLinha()
fimprocedimento

inicio
   DesenharLinha()
   escreval("       FASTLOG - GESTÃO DE EXPEDIÇÃO      ")
   DesenharLinha()

   escreva("Nome do Cliente: ")
   leia(cliente)
   escreva("Valor da Carga (R$): ")
   leia(valorCarga)

   // Chamada de procedimento com argumento literal
   NotificarStatus("Nova carga registrada no sistema.")
   escreval("    Cliente: ", cliente, " | Valor: R$ ", valorCarga:8:2)
   NotificarStatus("Ordem de carregamento enviada para a doca 02.")
fimalgoritmo

🛠️ Prática Obrigatória 1: Procedimento de Menu Padronizado

Passo 1: O Desafio

Crie um algoritmo "Menu_Modular" que contenha o procedimento: procedimento ExibirMenuPrincipal() Esse procedimento deve desenhar na tela o menu com as opções:

• [1] Cadastrar Motorista
• [2] Consultar Frota
• [3] Relatório de Viagens
• [0] Sair do Sistema

No programa principal, chame esse procedimento dentro de um laço repita-ate (opcao = 0).

🛠️ Prática Obrigatória 2: Procedimento Calculador de ICMS Parametrizado

Crie um procedimento chamado CalcularICMS(valorFrete : real, aliquota : real) que receba o valor bruto do frete e a alíquota de imposto (ex: 0.12 para 12%), calculando e imprimindo o valor exato do tributo em moeda. Chame o procedimento 3 vezes no programa principal para fretes diferentes.

📤 Instruções de Entrega (Microsoft Teams)

1. Salve o arquivo como: Atividade_17_SeuNome_SeuSobrenome.alg.
2. Certifique-se de que os procedimentos foram declarados antes do inicio do algoritmo.
3. No Microsoft Teams, envie na tarefa “VisuAlg Cap 17 - Procedimentos”.
4. Clique em Entregar (Turn In).

💡 Checkpoint de Lógica & Engenharia de Software

Você acabou de aplicar o princípio DRY (Don’t Repeat Yourself). Em grandes corporações, a reutilização de código através de bibliotecas de procedimentos economiza milhares de horas de trabalho e reduz em até 80% o número de bugs em produção.

🔥 Desafio de Fixação: Procedimento de Moldura com Caractere Customizável

Crie um procedimento DesenharCaixa(texto : caractere, simbolo : caractere) que receba o texto da mensagem e o símbolo de borda (ex: "#" ou "*"), desenhando uma caixa personalizada ao redor da mensagem.

🔑 Gabarito de Código Completo

Prática 1:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

algoritmo "Menu_Modular"
var
   opcao : inteiro

procedimento ExibirMenuPrincipal()
inicio
   escreval("==========================================")
   escreval("         PAINEL DE CONTROLE FASTLOG       ")
   escreval("==========================================")
   escreval(" [1] Cadastrar Motorista")
   escreval(" [2] Consultar Frota")
   escreval(" [3] Relatório de Viagens")
   escreval(" [0] Sair do Sistema")
   escreval("==========================================")
   escreva("Digite a opção: ")
fimprocedimento

inicio
   repita
      ExibirMenuPrincipal()
      leia(opcao)
      
      escolha opcao
         caso 1: escreval(">> Módulo de Cadastro acionado.")
         caso 2: escreval(">> Módulo de Consulta acionado.")
         caso 3: escreval(">> Módulo de Relatórios acionado.")
         caso 0: escreval(">> Encerrando o sistema...")
         outrocaso: escreval(">> Opção inválida!")
      fimescolha
      escreval("")
   ate (opcao = 0)
fimalgoritmo

Prática 2:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

algoritmo "Calculo_ICMS_Modular"

procedimento CalcularICMS(valorFrete : real; aliquota : real)
var
   imposto : real
inicio
   imposto <- valorFrete * aliquota
   escreval("------------------------------------------")
   escreval("Frete Base : R$ ", valorFrete:8:2)
   escreval("Alíquota   : ", (aliquota * 100):4:1, "%")
   escreval("ICMS Devido: R$ ", imposto:8:2)
   escreval("------------------------------------------")
fimprocedimento

inicio
   escreval("=== APURAÇÃO FISCAL DE FRETES ===")
   CalcularICMS(1500.00, 0.12)
   CalcularICMS(3200.00, 0.18)
   CalcularICMS(850.00, 0.07)
fimalgoritmo

Desafio:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

algoritmo "Moldura_Customizada"

procedimento DesenharCaixa(msg : caractere; simbolo : caractere)
inicio
   escreval(simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo)
   escreval(simbolo, " ", msg)
   escreval(simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo, simbolo)
fimprocedimento

inicio
   DesenharCaixa("SISTEMA OK", "#")
   DesenharCaixa("ALERTA DOCA", "*")
fimalgoritmo

📝 Atividade Extra: Questionário de Fixação (Caderno)

Instruções: Responda no caderno, de próprio punho, as 10 perguntas abaixo com base no que foi estudado neste capítulo. Ao concluir, leve o caderno até o professor para correção e visto.

1. O que é um Procedimento, segundo a definição dos Fundamentos, e o que o diferencia quanto à devolução de valor para uma variável?
2. Em relação ao inicio do algoritmo principal, onde os procedimentos devem ser declarados no VisuAlg?
3. Segundo a tabela de escopo, em quais lugares uma Variável Global pode ser lida ou alterada, e em quais lugares uma Variável Local pode ser lida ou alterada?
4. Qual é o tempo de vida na memória RAM de uma variável local, segundo a tabela de escopo?
5. No Cenário Prático, quais dois procedimentos devem ser criados para o sistema de faturamento da FastLog, e que problema de duplicidade de código eles resolvem?
6. No Exemplo Guiado (Sistema_Modular_FastLog), qual procedimento é chamado de dentro de outro procedimento, e qual é esse outro procedimento chamado?
7. Qual é a diferença entre o procedimento DesenharLinha() e o procedimento NotificarStatus(mensagem : caractere) quanto ao uso de parâmetros?
8. Na Prática Obrigatória 1, dentro de qual estrutura de repetição o procedimento ExibirMenuPrincipal() deve ser chamado repetidamente?
9. Na Prática Obrigatória 2, quais dois parâmetros o procedimento CalcularICMS deve receber, e quantas vezes ele deve ser chamado no programa principal?
10. Segundo o Checkpoint de Lógica, a qual princípio de engenharia de software o uso de procedimentos está associado, e qual redução percentual de bugs em produção é mencionada?