⚙️ Programação Imperativa

Controle direto do fluxo de execução - simule até mesmo assembly!

🔧

O que é programação imperativa?

Programação imperativa é sobre dar comandos diretos ao computador: "faça isso, depois aquilo". Você controla exatamente como o programa executa, passo a passo.

Características

Sequência de comandos
Mudança de estado (variáveis mutáveis)
Controle de fluxo explícito
Uso de loops e condicionais

Exemplo básico: Contador

-- Estado mutável
local contador = 0

-- Sequência de comandos
contador = contador + 1
exiba("Contador: " .. contador)

contador = contador + 1
exiba("Contador: " .. contador)

contador = contador + 1
exiba("Contador: " .. contador)

Simulando Assembly com execute

Com execute (goto) e rótulos, você pode simular programação em assembly, com saltos diretos e controle de fluxo de baixo nível.

Exemplo: Máquina de estados simples

-- Registradores (variáveis)
local reg_a = 0
local reg_b = 10
local resultado = 0

-- Programa em estilo assembly
::inicio::
    exiba("REG_A: " .. reg_a .. ", REG_B: " .. reg_b)

    -- ADD: resultado = reg_a + reg_b
    resultado = reg_a + reg_b

    -- INC: incrementa reg_a
    reg_a = reg_a + 1

    -- CMP e JMP: compara e pula
    se reg_a < 5 então
        execute ::inicio::  -- JMP inicio
    fim

::fim::
    exiba("Resultado final: " .. resultado)

Exemplo: Loop com saltos condicionais

local i = 0
local soma = 0

::loop_inicio::
    -- Condição de saída
    se i >= 10 então
        execute ::loop_fim::
    fim

    -- Corpo do loop
    soma = soma + i
    i = i + 1

    -- Volta ao início
    execute ::loop_inicio::

::loop_fim::
    exiba("Soma: " .. soma)  -- 45

Exemplo: Calculadora com "instruções"

local acumulador = 0
local operando = 0
local instrucao = ""

-- Programa
::programa::
    instrucao = "LOAD"
    operando = 10
    execute ::executar::

::adicionar::
    instrucao = "ADD"
    operando = 5
    execute ::executar::

::multiplicar::
    instrucao = "MUL"
    operando = 2
    execute ::executar::

::mostrar::
    instrucao = "PRINT"
    execute ::executar::

::parar::
    execute ::fim::

-- Interpretador de instruções
::executar::
    se instrucao == "LOAD" então
        acumulador = operando
        execute ::adicionar::
    fim

    se instrucao == "ADD" então
        acumulador = acumulador + operando
        execute ::multiplicar::
    fim

    se instrucao == "MUL" então
        acumulador = acumulador * operando
        execute ::mostrar::
    fim

    se instrucao == "PRINT" então
        exiba("Acumulador: " .. acumulador)
        execute ::parar::
    fim

::fim::
-- Resultado: 30 (10 + 5 = 15, 15 * 2 = 30)

Quando usar programação imperativa?

✅ Scripts simples e diretos
✅ Algoritmos que precisam de controle fino
✅ Manipulação direta de estado
✅ Prototipagem rápida
⚠️ Cuidado: código imperativo puro pode ficar difícil de manter

Dica: Use execute com moderação! É poderoso mas pode tornar o código difícil de seguir. Para a maioria dos casos, use estruturas de controle normais (se, para).

Programação imperativa em Sol é direta e poderosa. Com execute, você tem controle total do fluxo!

Próximo: Procedural