Parâmetros e Argumentos: Passagem por Valor vs Referência

1. A Comunicação Entre Subprogramas: Como os Dados Entram nas Funções?

Na aula anterior, entendemos o poder de modularizar nossos programas em funções e procedimentos independentes. No entanto, para que uma função seja verdadeiramente útil, flexível e inteligente, ela raramente trabalha no vácuo: ela precisa receber informações do mundo exterior para processar.

Pense em uma função matemática como o cálculo da raiz quadrada ou da área de um triângulo: ela precisa receber a base e a altura para produzir uma resposta. A porta de entrada por onde esses dados fluem para o interior da função é o mecanismo de Parâmetros e Argumentos.

Contudo, a forma como o computador transporta esses dados pela memória RAM pode seguir dois caminhos drasticamente diferentes:

1. Cópia Segura (Passagem por Valor): O computador tira uma "fotocópia" do dado e entrega para a função. Se a função rabiscar a cópia, o documento original no chamador não sofre nenhum arranhão;
2. Acesso Direto (Passagem por Referência): O computador entrega para a função a chave da gaveta onde o documento original está guardado. Qualquer modificação feita pela função alterará o documento original imediatamente.

2. Parâmetros Formais vs Argumentos Reais (O Contrato da Sub-rotina)

Na literatura técnica, os termos "parâmetro" e "argumento" frequentemente são usados como sinônimos pelo jargão popular, mas possuem distinções semânticas precisas que todo desenvolvedor profissional deve dominar:

1. Parâmetro Formal (A Variável Receptora)

O Parâmetro Formal é o identificador declarado na assinatura (cabeçalho) da função. Ele atua como um espaço reservado (placeholder) com nome e tipo bem definidos:

funcao calcularIMC(peso: real, altura: real): real

Neste exemplo, peso e altura são os parâmetros formais. Eles só passam a existir na memória quando a função é invocada.

2. Argumento Real (O Dado Efetivo)

O Argumento Real (ou simplesmente argumento) é o valor concreto, variável preenchida ou expressão matemática que você fornece entre parênteses no momento exato em que faz a chamada da função:

meuIMC = calcularIMC(78.5, 1.75)

Aqui, os valores literais 78.5 e 1.75 são os argumentos reais passados para a função.

3. Passagem por Valor (Por Cópia): A Blindagem e Imutabilidade do Chamador

A passagem por valor (Pass by Value) é o comportamento padrão da maioria esmagadora das linguagens modernas (incluindo Portugol, C, Java, JavaScript, Python e C#).

Quando um argumento é passado por valor, o sistema operacional realiza uma operação de cópia binária de bits: o valor armazenado na variável original é duplicado em uma célula de memória inteiramente nova pertencente ao Stack Frame da função chamada.

Vamos verificar esse comportamento com um experimento prático em Portugol:

// Função com parâmetro primitivo (POR VALOR):
funcao tentarAumentarSaldo(moeda valorCopia) {
    valorCopia = valorCopia + 500.00;
    saida("[DENTRO DA FUNÇÃO] valorCopia modificado para: R$ " + valorCopia);
}

moeda saldoConta = 1000.00;
saida("[ANTES DA CHAMADA] saldoConta original: R$ " + saldoConta);

// Enviamos saldoConta por valor (uma cópia é criada):
tentarAumentarSaldo(saldoConta);

saida("[DEPOIS DA CHAMADA] saldoConta original: R$ " + saldoConta);

Se executarmos esse programa, a saída no console revelará a verdade inabalável:

[ANTES DA CHAMADA] saldoConta original: R$ 1000.00
[DENTRO DA FUNÇÃO] valorCopia modificado para: R$ 1500.00
[DEPOIS DA CHAMADA] saldoConta original: R$ 1000.00

Mesmo que a função tenha somado 500 reais na variável valorCopia, a variável saldoConta do bloco principal permaneceu rigorosamente intocada com 1.000 reais! Essa blindagem garante que uma função nunca estrague dados de outra parte do software sem permissão expressa.

4. Passagem por Referência: Manipulação Direta da Memória com Vetores e Registros

E se o objetivo do nosso algoritmo for justamente permitir que a sub-rotina modifique a variável do chamador?

Para essa finalidade existe a passagem por referência (Pass by Reference). Em vez de duplicar o valor, o chamador envia o endereço de memória da sua própria variável. O parâmetro formal torna-se um alias (um apelido alternativo) que aponta para a mesmíssima gaveta física de memória.

No Portugol tradicional (Visualg) isso é feito com a palavra reservada var no cabeçalho. No logicabr.dev a regra é mais simples: tipos simples (numero, moeda, texto, logico) vão sempre por valor, e estruturas compostas (vetor e registro) vão por referência:

// Estruturas compostas (vetores e objetos) são transmitidas por REFERÊNCIA:
funcao creditarBonus(vetor conta) {
    conta[0] = conta[0] + 500.00;
    saida("[DENTRO DA FUNÇÃO] Bônus creditado diretamente na memória!");
}

vetor saldoConta = [1000.00];
saida("[ANTES] saldoConta: R$ " + saldoConta[0]);

creditarBonus(saldoConta);  // Passa referência da estrutura na memória

saida("[DEPOIS] saldoConta: R$ " + saldoConta[0]);

Ao rodar esse código, o resultado é radicalmente diferente:

[ANTES] saldoConta: R$ 1000.00
[DENTRO DA FUNÇÃO] Bônus creditado diretamente na memória!
[DEPOIS] saldoConta: R$ 1500.00

Como o parâmetro recebido é um vetor (estrutura composta), a alteração refletiu instantaneamente na variável original do chamador!

5. O Clássico Algoritmo de Troca (swap): A Prova Cabal da Referência

Em toda entrevista de emprego ou prova acadêmica de algoritmos, existe um teste clássico que separa quem realmente compreende memória de quem apenas decora sintaxe: o procedimento de troca de valores entre duas variáveis (swap).

O objetivo é criar uma sub-rotina trocar(x, y) que faça o valor de x ir para y e o de y ir para x.

Se tentarmos implementar essa rotina com passagem por valor padrão:

// [ERRO] Tentativa ineficaz de troca por valor:
funcao trocarInutil(numero a, numero b) {
    numero temp = a;
    a = b;
    b = temp;
    // Os valores foram trocados apenas nas cópias locais!
    // Ao sair da função, as variáveis do chamador permanecem inalteradas.
}

Para que a troca funcione de verdade na memória real do usuário, a passagem por referência é estritamente obrigatória:

// Troca com estrutura mutável por referência:
funcao trocarVetor(vetor par) {
    numero auxiliar = par[0];
    par[0] = par[1];
    par[1] = auxiliar;
}

vetor valores = [10, 99];
saida("Antes da troca:  x = " + valores[0] + " | y = " + valores[1]);

trocarVetor(valores);  // O vetor é alterado diretamente na memória

saida("Depois da troca: x = " + valores[0] + " | y = " + valores[1]);

Antes da troca:  x = 10 | y = 99
Depois da troca: x = 99 | y = 10

6. Efeitos Colaterais (Side Effects): Quando Usar Referência e Quando Evitá-la

Chamamos de Efeito Colateral (Side Effect) qualquer modificação que uma função provoque no estado do programa além de devolver seu valor de retorno principal.

Embora a passagem por referência seja essencial em situações como ordenação de dados em memória e rotinas de baixo nível, o seu uso indiscriminado é uma das maiores fontes de bugs complexos no desenvolvimento de software comercial:

• O Bug Silencioso: Você passa uma variável para uma função acreditando que ela servirá apenas para leitura (ex: verificarLimite(cliente)), mas a função secretamente altera o saldo do cliente. Três horas depois, outra parte do sistema calcula juros errados e você não sabe de onde partiu o erro;
• A Regra de Ouro da Arquitetura: Prefira sempre funções puras que recebem dados por valor e devolvem novos valores calculados pelo comando retorno. Reserve a passagem por referência para cenários onde a performance de cópia de grandes blocos de memória for crítica ou para operações que exigem modificação coordenada no próprio local (in-place).

7. A Peculiaridade dos Tipos Primitivos vs Tipos Compostos

Nas linguagens comerciais modernas como JavaScript, Java, Python e C#, você descobrirá um comportamento fascinante:

• Tipos Primitivos (números, booleanos, caracteres): São sempre passados estritamente por valor. Modificar o parâmetro nunca altera a variável original externa;
• Tipos Compostos (Objetos, Dicionários, Listas e Vetores): A variável externa não armazena os dados diretamente, mas sim uma referência (um ponteiro para o objeto alocado na memória Heap). Quando você passa uma lista para uma função, o ponteiro é copiado por valor, o que significa que ambos os ponteiros apontam para o mesmíssimo objeto na memória!

Se a função fizer lista.adicionar(item), a lista externa será alterada! Aprenderemos a dominar essa dinâmica com perfeição nas Trilhas 5 e 6 dedicadas a Vetores e Registros.

8. Panorama Multi-Linguagem: Como Cada Linguagem Lida com Referência

// Em C++, o símbolo '&' indica passagem por referência:
void dobrar(int &n) {
    n = n * 2; // Altera a variável original diretamente
}

// Em C#, você deve declarar 'ref' na assinatura E na chamada:
void Dobrar(ref int n) {
    n *= 2;
}
// Chamada explícita: Dobrar(ref minhaVar);

// Em C puro, referência é feita explicitamente via ponteiros:
void dobrar(int *n) {
    *n = (*n) * 2; // Desreferenciação de memória
}
// Chamada enviando o endereço: dobrar(&minhaVar);

9. 5 Armadilhas Críticas com Parâmetros

Fique atento aos 5 deslizes mais frequentes cometidos em testes técnicos e projetos:

1. Confundir a Ordem dos Argumentos: Se a função espera calcularSalario(horasTrabalhadas, valorPorHora) e você passar calcularSalario(20.0, 160), os valores serão invertidos silenciosamente na matemática, gerando um salário completamente distorcido sem erro de compilação.
2. Passar Valores Literais Onde se Espera Referência: Se uma função espera um vetor par para trocar seus elementos e você tentar chamá-la com números literais como trocarVetor(10, 20), o programa quebrará! O número literal 10 não possui endereço físico modificável de memória para onde o ponteiro possa apontar (e em linguagens com var/ponteiros o compilador rejeita a chamada).
3. Mutação Acidental de Vetores em Sub-Rotinas: Em quase todas as linguagens, vetores passados para funções sofrem mutação direta. Se você não deseja alterar a lista original, você deve criar uma cópia defensiva (clone) antes de manipulá-la.
4. Quantidade Incompatível de Argumentos: Tentar chamar uma função que exige 3 parâmetros passando apenas 2 argumentos causará erro de assinatura (a menos que a linguagem suporte parâmetros opcionais com valores padrão).
5. Efeitos Colaterais Concorrentes: Em ambientes com múltiplas tarefas (threads), passar variáveis por referência para funções simultâneas causa condições de corrida (Race Conditions) e travamentos imprevisíveis.

10. Projeto Prático Resolvido: Sistema de Conversão e Ajuste Financeiro

Vamos aplicar os conceitos em um projeto integrador com propósitos mistos: uma sub-rotina que calcula coordenadas geométricas e um módulo bancário que demonstra com nitidez o contraste entre reajuste simulado (por valor) e reajuste homologado na folha (por referência):

// ========================================================
// FUNÇÃO 1: Simulação por VALOR (Imutável)
// Não altera o salário original da carteira
// ========================================================
funcao simularAumento(moeda salarioBase, numero perc) {
    retorno salarioBase + (salarioBase * (perc / 100.0));
}

// ========================================================
// FUNÇÃO 2: Aplicação Oficial com Atualização de Estado
// ========================================================
funcao homologarAumento(moeda salarioReal, numero perc) {
    saida("[SUCESSO] Reajuste homologado em carteira com sucesso!");
    retorno salarioReal + (salarioReal * (perc / 100.0));
}

// ========================================================
// FUNÇÃO 3: Modificação de Múltiplas Coordenadas por Referência
// ========================================================
funcao transladarPonto(vetor ponto, numero deltaX, numero deltaY) {
    ponto[0] = ponto[0] + deltaX;
    ponto[1] = ponto[1] + deltaY;
}

// ========================================================
// FLUXO PRINCIPAL
// ========================================================
saida("=== TESTE 1: MÓDULO FINANCEIRO ===");
moeda salarioFuncionario = 3000.00;
saida("Salário inicial registrado: R$ " + salarioFuncionario);

// 1. Simulação sem efeito colateral (POR VALOR):
saida("Projeção de aumento (10%):  R$ " + simularAumento(salarioFuncionario, 10.0));
saida("Salário após simulação:     R$ " + salarioFuncionario + " (Preservado!)");

// 2. Homologação oficial com retorno:
salarioFuncionario = homologarAumento(salarioFuncionario, 10.0);
saida("Salário após homologação:   R$ " + salarioFuncionario + " (Alterado de verdade!)");

saida("=== TESTE 2: MÓDULO GEOMÉTRICO (TRANSLADAÇÃO) ===");
vetor ponto = [5.0, 12.0];
saida("Coordenadas originais:  (X=" + ponto[0] + ", Y=" + ponto[1] + ")");

transladarPonto(ponto, 3.0, -2.0);
saida("Coordenadas transladadas: (X=" + ponto[0] + ", Y=" + ponto[1] + ")");

11. Perguntas Frequentes (FAQ)

A passagem por referência é mais rápida do que a passagem por valor?

Para tipos primitivos pequenos (como inteiros e booleanos de 4 ou 8 bytes), a diferença de velocidade é nula. No entanto, para estruturas de dados massivas (como uma imagem em matriz com 10 milhões de pixels ou uma tabela com milhares de registros), copiar os dados inteiros na memória consome tempo e RAM valiosos. Nesses casos, passar o endereço por referência é exponencialmente mais rápido.

O que é um parâmetro somente-leitura por referência (const reference)?

Em linguagens avançadas como C++ (const Tipo&) e C# (in), existe a passagem por referência somente-leitura. Ela combina o melhor dos dois mundos: aproveita a performance máxima da referência sem copiar dados na RAM, mas o compilador impede sumariamente que a função altere o valor original, garantindo 100% de segurança contra efeitos colaterais.

Posso misturar parâmetros por valor e por referência na mesma função?

Com certeza! Em uma função como funcao aplicarReajuste(vetor salarios, numero perc), o primeiro parâmetro (um vetor) é recebido por referência (mutável) e o segundo parâmetro (a porcentagem) é recebido por valor (cópia protegida).

O que são parâmetros com valor padrão (default parameters)?

Parâmetros com valor padrão são parâmetros que recebem um valor pré-definido no cabeçalho caso o chamador não forneça um argumento correspondente (ex: def calcular(taxa=0.05) em Python). O logicabr.dev não tem esse recurso: todos os argumentos precisam ser informados na chamada. Aprenderemos tudo sobre eles ao estudar outras linguagens.

O que vem a seguir na Aula 18?

Na Aula 18, exploraremos a fundo o mecanismo de Retorno de Valores em Funções (return): veremos como retornar dados compostos, encadeamento de funções em expressões matemáticas complexas e a técnica de saídas antecipadas (Early Return) para eliminação de aninhamentos de código.