Aula 14b — Parâmetros e Retorno de Funções

1. Os Quatro Tipos de Função em C

Na Aula 13 você aprendeu a declarar, definir e chamar funções. Agora vamos entender como os dados entram e saem delas — que é onde C se diferencia radicalmente do Java.

1b. Nomenclatura Formal: Call by Value e Call by Reference

Antes de mergulhar nos exemplos, vale fixar os dois nomes que você verá em qualquer livro de C, livro de algoritmos ou entrevista técnica:

O exemplo mais direto: a mesma tarefa pelos dois mecanismos

#include <stdio.h>

/* Call by Value: recebe cópia, retorna novo valor */
int somarDez_valor(int numero) {
    return numero + 10;             // não altera o original
}

/* Call by Reference: recebe endereço, modifica diretamente */
void somarDez_referencia(int *numero) {
    *numero = *numero + 10;         // modifica no endereço apontado
}

int main() {
    int a = 5;

    printf("a = %d\n", a);                   // 5

    a = somarDez_valor(a);                   // precisa reatribuir o retorno
    printf("após valor:      a = %d\n", a);  // 15

    somarDez_referencia(&a);                // &a = endereço de a
    printf("após referência: a = %d\n", a);  // 25

    return 0;
}

2. Passagem por Valor — a Cópia Invisível

Quando você escreve f(x), C cria uma cópia de x na stack da função. A variável original fica completamente isolada.

#include <stdio.h>

void tentaDobrar(int n) {
    n = n * 2;                          // modifica apenas a cópia local
    printf("dentro: n = %d\n", n);      // imprime 10
}

int main() {
    int n = 5;
    tentaDobrar(n);
    printf("fora:   n = %d\n", n);      // ainda 5 — original intocado
    return 0;
}

O que acontece na memória

3. Passagem por Ponteiro (Call by Reference)

Para que uma função modifique a variável original, passamos seu endereço. A função recebe um ponteiro e usa * para acessar o valor naquele endereço.

Exemplo 1 — dobrar um valor

#include <stdio.h>

void dobrar(int *p) {
    *p = *p * 2;    // lê o valor em 0x100, multiplica por 2, salva de volta
}

int main() {
    int x = 5;
    dobrar(&x);     // passa o endereço 0x100
    printf("x = %d\n", x);   // 10
    return 0;
}

Exemplo 2 — trocar dois valores (o swap clássico)

O swap é impossível com passagem por valor. Com ponteiros, funciona perfeitamente:

#include <stdio.h>

/* ❌ Versão errada — por valor */
void trocar_errado(int a, int b) {
    int temp = a; a = b; b = temp;   // troca as cópias, não os originais
}

/* ✅ Versão correta — por ponteiro */
void trocar(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 10, y = 20;
    printf("antes:  x=%d  y=%d\n", x, y);

    trocar_errado(x, y);
    printf("errado: x=%d  y=%d\n", x, y);   // ainda 10 e 20

    trocar(&x, &y);
    printf("certo:  x=%d  y=%d\n", x, y);   // 20 e 10
    return 0;
}

Exemplo 3 — retornar dois resultados simultaneamente (minMax)

#include <stdio.h>

void minMax(int v[], int tam, int *minimo, int *maximo) {
    *minimo = *maximo = v[0];
    for (int i = 1; i < tam; i++) {
        if (v[i] < *minimo) *minimo = v[i];
        if (v[i] > *maximo) *maximo = v[i];
    }
}

int main() {
    int notas[] = {7, 3, 9, 5, 8};
    int min, max;

    minMax(notas, 5, &min, &max);
    printf("Mínimo: %d  Máximo: %d\n", min, max);
    return 0;
}

4. Arrays Sempre por Ponteiro

Arrays em C têm um comportamento especial: ao serem passados para uma função, decaem automaticamente para um ponteiro para o primeiro elemento. Você nunca precisa (nem consegue) passar um array por valor.

#include <stdio.h>

void dobrarTodos(int *v, int tam) {
    for (int i = 0; i < tam; i++)
        v[i] *= 2;   // modifica o array original — sem & necessário na chamada
}

int main() {
    int nums[] = {1, 2, 3, 4, 5};
    dobrarTodos(nums, 5);                       // nums já é o endereço do [0]
    for (int i = 0; i < 5; i++)
        printf("%d ", nums[i]);
    printf("\n");
    return 0;
}

Exemplo completo: imprimir e modificar um array via funções

Ao passar um array para uma função, o ponteiro permite tanto lê-lo quanto modificá-lo diretamente. Use const quando quiser garantir que a função não alterará os dados:

#include <stdio.h>

/* Apenas lê o array — const protege contra modificação acidental */
void printArray(const int *v, int tam) {
    int i;
    for (i = 0; i < tam; i++)
        printf("%d ", v[i]);
    printf("\n");
}

/* Modifica o array original — incrementa cada elemento */
void incrementarTodos(int *v, int tam) {
    int i;
    for (i = 0; i < tam; i++)
        v[i] = v[i] + 1;    // equivalente a *(v+i) = *(v+i) + 1
}

int main() {
    int notas[5] = {6, 7, 8, 5, 9};

    printf("Antes:  ");
    printArray(notas, 5);

    incrementarTodos(notas, 5);   // sem & — arrays já são ponteiros

    printf("Depois: ");
    printArray(notas, 5);

    return 0;
}

5. Tipos de Retorno

Múltiplos return e o padrão código-de-erro

#include <stdio.h>

int ehPrimo(int n) {
    if (n < 2) return 0;                  // saída antecipada
    for (int i = 2; i * i <= n; i++)
        if (n % i == 0) return 0;
    return 1;
}

/* Padrão código-de-erro: 0 = OK, -1 = falha */
int dividir(int a, int b, float *resultado) {
    if (b == 0) return -1;                // indica erro ao chamador
    *resultado = (float)a / b;
    return 0;                             // indica sucesso
}

int main() {
    printf("7 é primo? %s\n", ehPrimo(7) ? "Sim" : "Não");
    printf("4 é primo? %s\n", ehPrimo(4) ? "Sim" : "Não");

    float res;
    if (dividir(10, 3, &res) == 0)
        printf("10 / 3 = %.2f\n", res);
    else
        printf("Erro: divisão por zero!\n");

    dividir(5, 0, &res);   // retorna -1, res não é modificado
    return 0;
}

/* ❌ ERRADO — retorna endereço de variável local destruída */
int* funcaoErrada() {
    int x = 42;
    return &x;   // x deixa de existir após o return!
}

6. Exemplo Completo — Calculadora Modular

Reunindo os quatro tipos de função num único programa:

#include <stdio.h>
#include <math.h>

/* void sem parâmetros */
void imprimirSeparador(void) {
    printf("──────────────────────\n");
}

/* retorno simples */
double calcularHipotenusa(double a, double b) {
    return sqrt(a * a + b * b);
}

/* retorno como código: 1=acutangulo 2=retangulo 3=obtusangulo 0=invalido */
int classificarTriangulo(double a, double b, double c) {
    if (a <= 0 || b <= 0 || c <= 0) return 0;
    if (a + b <= c || a + c <= b || b + c <= a) return 0;
    double maior2 = (a>b && a>c) ? a*a : (b>c ? b*b : c*c);
    double somaQuad = a*a + b*b + c*c - maior2;
    if (maior2 < somaQuad) return 1;
    if (maior2 == somaQuad) return 2;
    return 3;
}

/* múltiplos resultados via ponteiro */
void estatisticasVetor(const float v[], int tam,
                       float *media, float *maximo, float *minimo) {
    *media = *maximo = *minimo = v[0];
    for (int i = 1; i < tam; i++) {
        *media += v[i];
        if (v[i] > *maximo) *maximo = v[i];
        if (v[i] < *minimo) *minimo = v[i];
    }
    *media /= tam;
}

int main() {
    imprimirSeparador();
    printf("Hipotenusa (3,4): %.2f\n", calcularHipotenusa(3, 4));

    imprimirSeparador();
    const char *tipos[] = {"Inválido","Acutângulo","Retângulo","Obtusângulo"};
    printf("Triângulo 3-4-5: %s\n", tipos[classificarTriangulo(3,4,5)]);
    printf("Triângulo 5-5-5: %s\n", tipos[classificarTriangulo(5,5,5)]);

    imprimirSeparador();
    float notas[] = {7.5f, 8.0f, 6.0f, 9.5f, 5.5f};
    float med, mx, mn;
    estatisticasVetor(notas, 5, &med, &mx, &mn);
    printf("Média: %.1f | Máx: %.1f | Mín: %.1f\n", med, mx, mn);

    return 0;
}

7. C vs. Java

O swap — impossível em Java, trivial em C com ponteiros

void trocar(int *a, int *b) {
    int t = *a;
    *a = *b;
    *b = t;
}
// uso:
trocar(&x, &y);

void trocar(int a, int b) {
    int t = a;
    a = b;
    b = t;
    // x e y fora do método
    // continuam inalterados
}