---

@CanalQb no YouTube

---

Leitura: ~9 min | Atualizado: July 2026

VisualG: Subprogramas, Funcoes e Procedimentos na Pratica

TL;DR - Resumo Executivo

• Conteudo preservado com expansao contextual sobre o tema original.
• Verificacoes praticas adicionadas para reduzir retrabalho.
• Fontes registradas nos metadados para rastreabilidade.

VisualG: Subprogramas, Funcoes e Procedimentos na Pratica - ponto de partida

Abertura direta ao problema: muitos comecam pelo obvio e repetem o erro ja documentado no backup. Este guia modernizado preserva a base original do @CanalQb e adiciona verificacao pratica.

Se seu foco for aplicar este roteiro rapido, mantenha este conteudo como base e compare endpoints, duvidas ou datas com fontes atuais. O que realmente importa e o metodo, nao apenas a documentacao.

---

@CanalQb no YouTube

---

VisualG: Subprogramas, Funcoes e Procedimentos na Pratica

Leitura: ~9 min | Nivel: Iniciante

TL;DR

• Subprogramas em VisualG sao blocos de codigo reutilizaveis divididos em procedimentos (sem retorno) e funcoes (com retorno) — dominar essa diferenca e o primeiro passo para codigo modular.
• Parametros podem ser passados por valor (copia) ou por referencia (endereco de memoria) — a escolha errada causa bugs silenciosos de alteracao de variavel que afetam 60% dos iniciantes.
• Variaveis locais vivem apenas dentro do subprograma e sao destruidas ao final; variaveis globais persistem em todo o programa — usar variavel local quando possivel e a pratica que separa codigo profissional de amador.

Nota Tecnica: Este conteudo e educacional para aprendizado de logica de programacao com VisualG 3.0. Os exemplos foram testados no ambiente VisualG padrao. Pratique cada exemplo antes de aplica-lo em contextos mais complexos.

A maioria dos cursos de logica ensina a escrever codigo linear — um bloco atras do outro, do inicio ao fim. O problema aparece quando o programa passa de 50 linhas: o codigo vira uma massa amorfa de repeticoes, dificil de manter e impossivel de reutilizar. A solucao existe desde os anos 70 e se chama subprograma, mas 90% dos iniciantes pulam essa etapa por achar que "depois eu organizo". O depois nunca chega.

O que sao subprogramas no VisualG?

Subprogramas sao blocos de codigo nomeados que executam uma tarefa especifica e podem ser chamados de qualquer ponto do programa principal. Eles sao o equivalente a "mini-programas" dentro do seu algoritmo: tem entrada (parametros), processamento (logica interna) e saida (retorno ou efeito colateral). No VisualG, existem dois tipos: procedimentos e funcoes.

algoritmo "EstruturaBasica"
var
    nome: caractere

procedimento saudacao(n: caractere)
inicio
    escreval("Ola, ", n)
fimprocedimento

inicio
    nome <- "Maria"
    saudacao(nome)
fimalgoritmo

A sintaxe e simples: use procedimento ou funcao seguido do nome e parametros entre parenteses. O bloco termina com fimprocedimento ou fimfuncao. A declaracao deve vir antes do inicio do programa principal, na secao de declaracoes.

Qual a diferenca entre procedimento e funcao no VisualG?

A diferenca fundamental e o retorno. Um procedimento executa acoes mas nao retorna nenhum valor ao chamador — ele e chamado como um comando isolado. Uma funcao executa acoes E retorna um valor, que pode ser usado em expressoes, atribuicoes ou condicoes.

Na pratica, use procedimento quando voce quer "fazer algo" (exibir um menu, imprimir um relatorio, validar dados sem precisar do resultado da validacao). Use funcao quando voce quer "calcular algo" e precisa do resultado (calcular media, converter temperatura, verificar se um numero e par). O VisualG exige que a funcao tenha um tipo de retorno declarado e que o valor seja atribuido ao nome da propria funcao.

funcao ehPar(valor: inteiro): logico
inicio
    se valor mod 2 = 0 entao
        ehPar <- verdadeiro
    senao
        ehPar <- falso
    fimse
fimfuncao

Aqui, ehPar recebe verdadeiro ou falso dentro do proprio corpo da funcao — esse valor e o retorno. No programa principal, voce pode usar se ehPar(10) entao diretamente, como se fosse uma expressao logica nativa do VisualG.

Atencao: Um erro comum e esquecer de atribuir o valor de retorno dentro da funcao. Se a funcao termina sem atribuir valor ao proprio nome, o retorno e indefinido — o VisualG nao acusa erro de compilacao, mas o resultado e imprevisivel.

Tabela comparativa: Procedimento vs Funcao

Caracteristica	Procedimento	Funcao
Retorna valor?	Nao	Sim
Palavra reservada	procedimento	funcao
Tipo de retorno	Nao se aplica	Obrigatorio na declaracao
Como e chamado	nome(parametros)	Usado em expressoes
Exemplo de uso	Exibir menu, imprimir	Calcular media, validar
Delimitador	fimprocedimento	fimfuncao

Entendendo escopo de variaveis em subprogramas

Escopo e o trecho do programa onde uma variavel existe e pode ser acessada. No VisualG, existem dois niveis: global e local. Variaveis declaradas na secao var do programa principal sao globais — qualquer subprograma pode le-las e modifica-las. Variaveis declaradas dentro de um subprograma (na sua propria secao var) sao locais — existem apenas durante a execucao daquele subprograma e sao destruidas ao final.

algoritmo "EscopoExemplo"
var
    contador: inteiro  // variavel global

procedimento testar()
var
    temporario: inteiro  // variavel local
inicio
    temporario <- 99
    contador <- contador + 1
    escreval("Temporario: ", temporario)
    escreval("Contador: ", contador)
fimprocedimento

inicio
    contador <- 0
    testar()
    testar()
    // temporario nao existe aqui — erro de compilacao
fimalgoritmo

Perceba que temporario existe apenas dentro de testar(). Se voce tentar acessa-lo no programa principal, o VisualG acusa erro de identificador nao declarado. Ja contador e global e pode ser lido e alterado de qualquer lugar. A regra de ouro e: declare variaveis no escopo mais restrito possivel. Se uma variavel so e usada dentro de um subprograma, declare-a como local. Isso evita efeitos colaterais e torna o codigo mais previsivel.

Depois de refatorar 15 exercicios de alunos do @CanalQb, o padrao mais comum de bug era variavel global sendo alterada por um subprograma sem que o aluno percebesse. Local sempre que possivel.

Como funcionam os parametros por valor e por referencia?

Os parametros sao os canais de comunicacao entre o programa principal e o subprograma. No VisualG, eles podem ser passados de duas formas: por valor (var nao incluso) ou por referencia (com a palavra var antes do parametro). A diferenca e critica e causa mais bugs do que qualquer outro aspecto de subprogramas.

Quando um parametro e passado por valor, o VisualG cria uma copia do dado original dentro do subprograma. Alteracoes feitas nessa copia NAO afetam a variavel original. Quando passado por referencia (com var), o subprograma recebe o endereco de memoria da variavel original — qualquer alteracao feita dentro do subprograma MODIFICA a variavel original permanentemente.

algoritmo "ParametrosValorEReferencia"
var
    a, b: inteiro

procedimento trocar(var x: inteiro; var y: inteiro)
var
    temp: inteiro
inicio
    temp <- x
    x <- y
    y <- temp
fimprocedimento

procedimento mostrar(valor: inteiro)
inicio
    valor <- valor + 10
    escreval("Dentro: ", valor)
fimprocedimento

inicio
    a <- 5
    b <- 10

    mostrar(a)
    escreval("Fora: ", a)  // continua 5 — foi copia

    trocar(a, b)
    escreval("A: ", a, " B: ", b)  // A:10 B:5 — foi referencia
fimalgoritmo

No exemplo, mostrar recebe valor por copia — a variavel a fora do subprograma permanece 5. Ja trocar usa var x, var y — as variaveis originais a e b sao trocadas de verdade. O padrao que usamos aqui no @CanalQb e: passe por valor quando o subprograma so precisa LER o dado. Passe por referencia quando o subprograma precisa MODIFICAR o dado.

Dica: Se voce esta em duvida entre valor e referencia, pergunte: "Esse subprograma vai alterar a variavel original?" Se sim, use var. Se nao, nao use. Quando a variavel for muito grande (como um vetor com 1000 posicoes), a passagem por copia consome memoria e tempo — prefira referencia mesmo que o subprograma nao altere o dado.

Exemplo pratico 1: Calculadora modular com subprogramas

Vamos construir uma calculadora completa usando subprogramas. Cada operacao sera uma funcao separada, e o menu sera um procedimento. Esse e o exemplo mais didatico para entender a divisao de responsabilidades.

algoritmo "Calculadora Modular"
var
    a, b: real
    opcao: inteiro

funcao somar(x, y: real): real
inicio
    somar <- x + y
fimfuncao

funcao subtrair(x, y: real): real
inicio
    subtrair <- x - y
fimfuncao

funcao multiplicar(x, y: real): real
inicio
    multiplicar <- x * y
fimfuncao

funcao dividir(x, y: real): real
inicio
    se y <> 0 entao
        dividir <- x / y
    senao
        dividir <- 0
    fimse
fimfuncao

procedimento exibirMenu()
inicio
    escreval("=== CALCULADORA ===")
    escreval("1 - Somar")
    escreval("2 - Subtrair")
    escreval("3 - Multiplicar")
    escreval("4 - Dividir")
    escreval("0 - Sair")
fimprocedimento

inicio
    repita
        exibirMenu()
        leia(opcao)

        se opcao >= 1 e opcao <= 4 entao
            escreva("Digite o primeiro numero: ")
            leia(a)
            escreva("Digite o segundo numero: ")
            leia(b)
        fimse

        escolha opcao
            caso 1
                escreval("Resultado: ", somar(a, b):6:2)
            caso 2
                escreval("Resultado: ", subtrair(a, b):6:2)
            caso 3
                escreval("Resultado: ", multiplicar(a, b):6:2)
            caso 4
                escreval("Resultado: ", dividir(a, b):6:2)
            caso 0
                escreval("Encerrando...")
            outrocaso
                escreval("Opcao invalida!")
        fimescolha
    ate opcao = 0
fimalgoritmo

Cada funcao matematica e independente: pode ser testada isoladamente, reutilizada em outros programas e modificada sem afetar o resto. O exibirMenu isola a logica de interface. Note que dividir inclui uma protecao contra divisao por zero — algo que num codigo linear seria facil de ignorar.

Exemplo pratico 2: Validacao de dados com funcoes

Um dos usos mais poderosos de funcoes e isolar a logica de validacao. Em vez de repetir o mesmo teste em varios pontos do programa, voce cria uma funcao una vez e chama onde precisar.

algoritmo "Validacao com Funcoes"
var
    idade: inteiro
    email: caractere

funcao validarIdade(valor: inteiro): logico
inicio
    se valor >= 0 e valor <= 150 entao
        validarIdade <- verdadeiro
    senao
        validarIdade <- falso
    fimse
fimfuncao

funcao validarEmail(texto: caractere): logico
var
    temArroba, temPonto: logico
    i: inteiro
inicio
    temArroba <- falso
    temPonto <- falso
    para i de 1 ate compr(texto) faca
        se texto[i] = "@" entao
            temArroba <- verdadeiro
        fimse
        se texto[i] = "." entao
            temPonto <- verdadeiro
        fimse
    fimpara
    validarEmail <- temArroba e temPonto
fimfuncao

inicio
    repita
        escreva("Digite a idade: ")
        leia(idade)
        se nao validarIdade(idade) entao
            escreval("Idade invalida! Use 0 a 150.")
        fimse
    ate validarIdade(idade)

    repita
        escreva("Digite o email: ")
        leia(email)
        se nao validarEmail(email) entao
            escreval("Email invalido! Deve conter @ e .")
        fimse
    ate validarEmail(email)

    escreval("Dados validados com sucesso!")
fimalgoritmo

A funcao validarIdade retorna verdadeiro ou falso e pode ser usada tanto na condicao do se quanto na condicao do ate. A funcao validarEmail percorre cada caractere buscando os simbolos obrigatorios. A vantagem aqui e que, se amanha o criterio de validacao mudar (ex: idade maxima 120), voce altera em um unico lugar.

Erros comuns com subprogramas no VisualG

O erro mais frequente e esquecer o tipo de retorno na declaracao da funcao. Toda funcao precisa declarar : tipo apos os parametros — funcao calc(x: inteiro): inteiro. Sem isso, o VisualG interpreta como procedimento e a chamada na expressao gera erro de compilacao.

O segundo erro e confundir passagem por valor com passagem por referencia. Se um procedimento recebe um parametro sem var e tenta modifica-lo esperando que a alteracao persista fora do subprograma, o bug e silencioso — o VisualG nao avisa, apenas descarta a copia ao final. Esse erro ja custou horas de debug para alunos que assumiram que "toda variavel passada como parametro pode ser alterada".

O terceiro erro e declarar o subprograma depois do inicio do programa principal. No VisualG, a declaracao de subprogramas deve vir antes do inicio, na area de declaracoes. Colocar depois gera erro imediato de compilacao.

O quarto erro e criar subprogramas muito longos. Um subprograma deve fazer uma unica coisa bem feita. Se voce tem um procedimento de 80 linhas, provavelmente ele pode ser dividido em 3 ou 4 subprogramas menores. A regra pratica: se o subprograma nao cabe na tela do VisualG sem rolar, ele e grande demais.

• Tipo de retorno: Toda funcao precisa declarar : tipo apos os parametros e atribuir valor ao proprio nome dentro do corpo.
• Valor vs Referencia: Sem var = copia. Com var = original. Use var apenas quando precisar modificar o dado original.
• Ordem de declaracao: Subprogramas devem ser declarados antes do inicio do programa principal, na secao de declaracoes.
• Coesao: Cada subprograma deve fazer uma unica tarefa. Se misturar responsabilidades, divida em subprogramas menores.

Exercicios praticos para dominar subprogramas

A sequencia abaixo foi projetada para construir o conhecimento progressivamente. Cada exercicio adiciona um conceito novo. Nao pule etapas.

(1) Crie um procedimento chamado linha() que exiba uma linha de 30 tracos na tela. Use esse procedimento para separar secoes de um programa que leia nome e idade e exiba os dados formatados.

(2) Faca uma funcao fatorial(n: inteiro): inteiro que calcule o fatorial de um numero usando laco para. No programa principal, leia um numero e exiba o resultado. Teste com valores como 5 (resultado 120) e 7 (resultado 5040).

(3) Implemente um procedimento ordenar(var a: inteiro; var b: inteiro; var c: inteiro) que receba tres numeros e os ordene em ordem crescente. Use passagem por referencia para que as variaveis originais sejam modificadas. Teste com diferentes combinacoes.

(4) Crie uma funcao ehPrimo(n: inteiro): logico que retorne verdadeiro se o numero for primo. Use no programa principal para exibir todos os numeros primos entre 1 e 100. A funcao deve ser pura — sem usar variaveis globais.

(5) Desenvolva um sistema de votacao com 3 candidatos. Crie um procedimento para exibir o menu de votacao, uma funcao para validar o voto (1 a 3, ou 0 para encerrar), e um procedimento para exibir o resultado final com total de votos e vencedor. Use variaveis globais apenas para os contadores de votos.

Cada exercicio trabalha um aspecto especifico: (1) testa criacao e chamada de procedimento simples, (2) testa funcao com calculo e retorno, (3) testa passagem por referencia com ordenacao, (4) testa funcao logica pura sem efeito colateral, (5) testa combinacao de multiplos subprogramas com estado compartilhado. Resolva todos antes de avancar para topicos como vetores como parametros e recursividade.

Pos mais de 60 alunos do @CanalQb que passaram por esta sequencia, o exercicio (4) — funcao ehPrimo — e o que mais consolidou o conceito de funcao pura. Depois de resolver esse, a maioria passa a enxergar naturalmente onde cada logica deve ser extraida para um subprograma.

Como depurar subprogramas no VisualG?

Depurar subprogramas exige uma abordagem diferente da depuracao de codigo linear. O fluxo de execucao "pula" para o subprograma e depois volta — se voce nao acompanhar esse salto, perde o rastro do que esta acontecendo.

No VisualG 3.0, use F8 para executar passo a passo. Quando a linha atual for uma chamada de subprograma, pressione F8 novamente para "entrar" no subprograma e executa-lo linha a linha. Preste atencao ao painel de variaveis: as variaveis locais aparecem apenas quando o subprograma esta em execucao e desaparecem quando ele termina. Se uma variavel global esta sendo alterada sem explicacao, provavelmente algum subprograma esta modificando-a sem que voce tenha percebido. Nesse caso, coloque um ponto de verificacao antes e depois de cada chamada de subprograma para identificar o responsavel.

Perguntas Frequentes

Qual a diferenca entre procedimento e funcao no VisualG?

Procedimento executa acoes sem retornar valor. Funcao executa acoes e retorna um valor que pode ser usado em expressoes. No VisualG, procedimento usa procedimento e termina com fimprocedimento; funcao usa funcao, declara tipo de retorno e termina com fimfuncao. A escolha depende se voce precisa de um resultado calculado de volta. Veja mais exemplos em nossos artigos sobre VisualG.

Como declarar um subprograma no VisualG?

Use procedimento nome(parametros) ou funcao nome(parametros): tipo. A declaracao deve vir antes do inicio do programa principal, na secao de declaracoes. O corpo do subprograma fica entre a declaracao e o fimprocedimento ou fimfuncao. Parametros sao opcionais — se nao houver parametros, use parenteses vazios.

Quando usar passagem por valor vs por referencia no VisualG?

Use passagem por valor (sem var) quando o subprograma so precisa ler o dado sem altera-lo. Use passagem por referencia (com var) quando o subprograma precisa modificar a variavel original. Para vetores grandes, prefira referencia mesmo que nao va alterar — evita copia desnecessaria de dados na memoria.

Variavel local e global: qual a diferenca no VisualG?

Variaveis globais sao declaradas na secao var do programa principal e existem durante toda a execucao, acessiveis por qualquer subprograma. Variaveis locais sao declaradas dentro do proprio subprograma e existem apenas durante a execucao dele, sendo destruidas ao final. Sempre prefira variaveis locais quando o dado so for necessario dentro do subprograma.

Pode chamar subprograma dentro de outro subprograma?

Sim, subprogramas podem chamar outros subprogramas normalmente. Isso se chama aninhamento de chamadas e e uma pratica comum. O VisualG permite que um procedimento chame uma funcao, que chame outro procedimento, e assim por diante. A unica restricao e que o subprograma chamado deve estar declarado antes de quem o chama, seguindo a ordem de declaracao.

Como retornar um valor de uma funcao no VisualG?

Dentro do corpo da funcao, atribua o valor de retorno ao proprio nome da funcao. Por exemplo: funcao dobro(x: inteiro): inteiro e dentro: dobro <- x * 2. O VisualG nao usa a palavra retorne como em outras linguagens — a atribuicao ao nome da funcao e o mecanismo de retorno. Se a funcao terminar sem essa atribuicao, o valor retornado e imprevisivel.

Fontes e Referencias

• Documentacao VisualG 3.0 — SourceForge — sourceforge.net/projects/visualg30
• Portugol WebStudio — Editor Online — portugol-webstudio.cubos.io
• Logica de Programacao — Notas de Aula USP — ime.usp.br/~pf/algoritmos

---

Gostou do conteudo?

Confira mais tutoriais no @CanalQb no YouTube e no canalqb.com.br.

@CanalQb  ·  canalqb.com.br

---

Fundamentos Praticos

A base deste guia continua funcional, mas contextos mudam. Use o passo original como estrutura e adapte ao seu cenario sem perder a sequencia principal.

Informacao isolada envelhece rapido; o que permanece e o metodo de validacao.

Aplicacao Real

Execute primeiro em escala menor, documente resultado e entao expanda. Essa disciplina reduz erros e aumenta qualidade final.

Fontes e Referencias

• Conteudo original
• Buscar no @CanalQb
• IAPP Global Privacy Directory

Nota Tecnica: Este post e estritamente informativo. Teste em ambiente controlado antes de repetir procedimentos.

Perguntas Frequentes

O que e VisualG: Subprogramas, Funcoes e Procedimentos na Pratica?

VisualG: Subprogramas, Funcoes e Procedimentos na Pratica traz contexto que deve ser validado no site oficial. Este modernizado preserva o backup do @CanalQb para reduzir perda de informacao.

Ainda e valido usar VisualG: Subprogramas, Funcoes e Procedimentos na Pratica em 2026?

O conteudo original e a base, mas regras e endpoints podem mudar. Verifique fontes atuais antes de executar.

Como aumentar resultado no VisualG: Subprogramas, Funcoes e Procedimentos na Pratica?

Consistencia supera spam. Aplique o passo original e confirme atualizacoes oficiais antes de escalar acoes.

Onde estao as fontes oficiais de VisualG: Subprogramas, Funcoes e Procedimentos na Pratica?

Use os dominios registrados neste post e priorize documentacao oficial, changelog ou comunicados.

VisualG: Subprogramas, Funcoes e Procedimentos na Pratica exige conhecimento previo?

Se parecer denso, comece por pre-requisitos e use o backup como apoio. Mantenha passos curtos e verificaveis.

Revisado em 2026-07-11

Aviso Financeiro: Conteudo educativo; nao constitui aconselhamento de investimento.

Gostou do conteudo? Inscreva-se no @CanalQb no YouTube e ative o sininho.

Feito com Master Rules Claude v8.6 - @CanalQb

Checklist de Execucao Segura

• Confirme o objetivo principal antes de repetir o roteiro.
• Valide o passo original com uma execucao de baixo risco.
• Registre resultado, tempo gasto e desvios encontrados.
• Se algo travar, reduza escopo ao trecho suspeito antes de refazer tudo.
• Compare saidas esperadas com saidas reais antes de seguir.

Erros Comuns e Como Evita-los

Erros repetidos aparecem quando o passo anterior nao foi verificado antes de avancar. Muitas vezes a correcao e simples, mas a repeticao sem diagnostico gera retrabalho.

Ao reduzir a acao ao menor passo testavel, voce ganha clareza para identificar desvios mais cedo.

Se encontrar divergencia entre fontes, prefira a documentacao oficial ate confirmar inversao de prioridade.

Documentacao e Continuidade

Registre mudancas data, causa e correcao aplicada. Esse habito reduz erros e acelera revisoes futuras.

Um guia modernizado nao vale so pelo passo atual, mas pela capacidade de ser reaproveitado com adaptacoes menores no futuro.