^[1]Copyright © 2026 Alyce Suza.

O laço para e o laço faca-enquanto na prática estruturada

9.1 Os Três Tipos de Loop e Quando Usar Cada Ferramenta

O universo da programação estruturada oferece três vias distintas para aplicar a repetição de comandos, e o domínio dessa arquitetura exige saber exatamente qual ferramenta utilizar diante de cada problema algorítmico. O laço enquanto, que já exploramos detalhadamente, é classificado como pré-testado e se consolida como a escolha ideal para situações onde o ciclo pode executar zero ou mais vezes, dependendo de uma condição que talvez já nasça falsa. Em contrapartida, o laço faca-enquanto opera sob uma lógica pós-testada, garantindo categoricamente que o bloco de código interno execute no mínimo uma única vez antes de sofrer a primeira validação do sistema. Por fim, o laço para entra no cenário trazendo um contador nativo e embutido, assumindo o papel de ferramenta suprema para os casos matemáticos onde o programador sabe antecipadamente o número exato de iterações que o processador vai precisar rodar. É evidente para quem sente na pele o peso de sustentar sistemas em produção que escolher a estrutura errada gera códigos difíceis de ler e manter.

9.2 O Laço faca-enquanto: Mecânica Pós-Testada

No funcionamento estrutural do laço faca-enquanto, o bloco de instruções é lido e executado de forma compulsória na primeira passagem, e somente depois de processar todo o conteúdo interno o compilador verifica a condição de continuidade na base da estrutura. Esse comportamento arquitetural garante que a instrução contida ali rode pelo menos uma vez, sendo absolutamente independente do estado inicial da condição imposta.

faca
{
    // este bloco e executado ANTES de qualquer verificacao logica de seguranca
}
enquanto (condicao) // o sistema verifica DEPOIS e repete o fluxo caso seja verdadeiro

Um dos casos clássicos e mais vitais para a aplicação dessa estrutura ocorre quando precisamos forçar a validação de uma entrada digitada pelo usuário no console. É logicamente impossível o sistema verificar se um dado inserido atende aos requisitos numéricos antes mesmo do usuário ter a chance de digitar a informação. O laço força o pedido inicial e prende o indivíduo num ciclo restrito até que a exigência matemática seja plenamente satisfeita.

programa
{
    funcao inicio()
    {
        inteiro numero

        faca
        {
            escreva("Digite um numero restrito entre 1 e 10: ")
            leia(numero)

            se (numero < 1 ou numero > 10)
            {
                escreva("Aviso logico: O valor e invalido e deve estar entre 1 e 10.\n")
            }
        } enquanto (numero < 1 ou numero > 10)

        escreva("Validacao concluida. Voce digitou a quantia: ", numero, "\n")
    }
}

Nós vemos esse mesmo padrão se repetir de forma elegante na construção de menus interativos em terminais de texto. O menu precisa obrigatoriamente aparecer para o usuário avaliar as opções logo na abertura do aplicativo, repetindo a sua própria exibição após cada operação solicitada até que o gatilho específico de saída seja acionado no painel.

programa
{
    funcao inicio()
    {
        inteiro opcao

        faca
        {
            escreva("\n1-Ola  2-Data  3-Sair\nOpcao selecionada: ")
            leia(opcao)

            se (opcao == 1) { escreva("Saudacao logica: Ola, Mundo!\n") }
            senao se (opcao == 2) { escreva("Carimbo temporal: Ano 2026\n") }
            senao se (opcao == 3) { escreva("Encerramento do sistema. Ate logo!\n") }
            senao { escreva("Aviso: Opcao invalida e nao reconhecida!\n") }

        } enquanto (opcao != 3)
    }
}

9.3 O Laço para: Controle Estrito e Organizado

O laço para representa a estrutura mais compacta e indicada quando o número exato de iterações já é previamente conhecido pelas regras de negócio da aplicação. Me impressiona como esse comando amarra todas as pontas soltas, consolidando a inicialização do índice, o teste rigoroso da condição de fronteira e o passo de incremento progressivo em uma única linha declarativa, impedindo esquecimentos fatais que resultam em ciclos infinitos.

para (inteiro i = inicio; condicao; incremento)
{
    // bloco confinado repetido o numero N de vezes definido na declaracao
}

A anatomia dessa instrução se divide de forma cirúrgica. A inicialização é disparada uma única vez antes de qualquer outra ação, reservando a memória para o contador. A condição relacional é atestada repetidamente antes de abrir a porta para cada nova iteração. Finalmente, a engrenagem de incremento roda de forma silenciosa e automática sempre no fechamento do bloco, alterando o eixo numérico que empurra a rotina rumo à sua conclusão matemática.

programa
{
    funcao inicio()
    {
        inteiro n
        escreva("Preencha a base da Tabuada desejada: ") leia(n)

        para (inteiro i = 1; i <= 10; i++)
        {
            escreva(n, " x ", i, " = ", n * i, "\n")
        }
    }
}

A flexibilidade dos parâmetros alocados no cabeçalho do para permite desenhar variações algorítmicas muito ricas, alterando a contagem de rumos progressivos para contagens regressivas ou impondo saltos de casas decimais que aceleram o cursor pulando os valores ímpares no meio do caminho lógico.

// Rotina de contagem regressiva estrita rumo ao marco unitario
para (inteiro i = 10; i >= 1; i--)
    escreva(i, " ")
escreva("LANCAMENTO DE FOGUETE!\n")

// Movimentacao de cursor saltando amplamente de cinco em cinco casas num relogio
para (inteiro i = 0; i <= 100; i = i + 5)
    escreva(i, " ")

// Filtragem puramente estrutural focando unicamente nos indices de natureza par
para (inteiro i = 0; i < 10; i = i + 2)
    escreva(i, " ")

A aplicação prática do cálculo de fatorial demonstra o poder de acumulação controlada sob demanda. O limite numérico estabelecido pelo operador determina o fim exato da multiplicação sucessiva que decai vertiginosamente, provando que o laço engessa o volume de trabalho em limites muito bem desenhados e precisos.

programa
{
    funcao inicio()
    {
        inteiro n
        escreva("Solicite o calculo exato de fatorial para: ") leia(n)

        se (n < 0)
        {
            escreva("Erro logico fundamental: O Fatorial nao existe na faixa de negativos!\n")
        }
        senao
        {
            inteiro fatorial = 1    // O acumulador de produto comeca vitalmente em 1 e NAO em zero absoluto

            para (inteiro i = 2; i <= n; i++)
            {
                fatorial = fatorial * i
            }

            escreva("Resultado formal: ", n, "! = ", fatorial, "\n")
        }
    }
}

A complexidade salta de nível ao simularmos algoritmos históricos do mundo natural, como a lendária sequência de crescimento descrita por Fibonacci. O código manipula a memória viva transitando valores entre três variáveis pontuais a cada giro cronológico, simulando as gerações reprodutivas através de adições sucessivas.

programa
{
    funcao inicio()
    {
        inteiro n, anterior = 0, atual = 1, proximo

        escreva("Quantifique o volume de termos desejados da rede: ") leia(n)
        escreva("Cadeia cronologica de Fibonacci: ")

        para (inteiro i = 1; i <= n; i++)
        {
            se (i == 1) { escreva(anterior) }
            senao se (i == 2) { escreva(", ", atual) }
            senao
            {
                proximo = anterior + atual
                anterior = atual
                atual = proximo
                escreva(", ", atual)
            }
        }
        escreva("\n")
    }
}

9.4 Exercícios do Capítulo 9

Gabarito do Capítulo 9

programa
{
    funcao inicio()
    {
        inteiro n
        escreva("Deseja a tabuada matematica de qual numero central? ") leia(n)
        
        para (inteiro i = 1; i <= 10; i++)
        {
            escreva(n, " x ", i, " = ", n*i, "\n")
        }
    }
}

programa
{
    funcao inicio()
    {
        inteiro n
        escreva("Exigir a apuracao de Fatorial exato de: ") leia(n)
        
        se (n < 0) { escreva("Incompatibilidade: Logica invalida para a base inserida!\n") }
        senao
        {
            inteiro fat = 1
            para (inteiro i = 2; i <= n; i++) { fat = fat * i }
            escreva(n, "! processado equivale a marca de ", fat, "\n")
        }
    }
}

programa
{
    funcao inicio()
    {
        inteiro op, num
        real a, b
        
        faca
        {
            escreva("\nCentral do Sistema: 1-Calc  2-Par/Imp  3-Sair\nOpcao selecionada: ") leia(op)
            
            se (op == 1) 
            { 
                escreva("Variavel A:") leia(a) 
                escreva("Variavel B:") leia(b) 
                escreva("Produto logico atestado: ", a+b, "\n") 
            }
            senao se (op == 2)
            {
                escreva("Num isolado: ") leia(num)
                se (num%2==0) { escreva("Diagnostico Par\n") } senao { escreva("Diagnostico Impar\n") }
            }
            senao se (op == 3) { escreva("Encerrando as funcoes e desligando o fluxo. Ate logo!\n") }
            senao { escreva("Rejeicao: Entrada indevida inserida no terminal!\n") }
            
        } enquanto (op != 3)
    }
}

programa
{
    funcao inicio()
    {
        inteiro n, contImp = 0, num = 1
        real soma = 0
        
        escreva("Totalize quantos limites impares para captura? ") leia(n)
        escreva("Amostragem de Impares filtrados na ordem: ")
        
        enquanto (contImp < n)
        {
            se (num % 2 != 0)
            {
                escreva(num, " ")
                soma = soma + num
                contImp++
            }
            num++
        }
        escreva("\nCalculo de Soma global acumulada no saldo = ", soma, "\n")
    }
}