📦 Funções · Modularização e Reuso · C/C++

📦 Funções

"Uma função é um bloco de código reutilizável que realiza uma tarefa específica. É a unidade fundamental de modularização em C/C++ e a base da programação estruturada."

Funções são os blocos de construção de qualquer programa C/C++. Elas permitem dividir um problema complexo em partes menores e gerenciáveis, promovem o reuso de código e tornam os programas mais fáceis de entender, testar e manter.

📌 Anatomia de uma Função

Uma função completa possui três partes: declaração (protótipo), definição (implementação) e chamada.

// 1. DECLARAÇÃO (protótipo) — informa ao compilador que a função existe
int somar(int a, int b);      // tipo_retorno nome(parametros);

// 2. DEFINIÇÃO — contém o código que será executado
int somar(int a, int b) {
    int resultado = a + b;
    return resultado;
}

int main() {
    // 3. CHAMADA — executa a função
    int x = somar(5, 3);
    cout << x << endl;   // 8
    return 0;
}
  

📋 Elementos da Definição de Função

Elemento	Descrição	Exemplo
Tipo de retorno	Tipo do valor que a função devolve. Pode ser `void` se não retornar nada.	`int`, `double`, `void`
Nome	Identificador único da função (regras de nomenclatura).	`somar`, `calcularMedia`
Parâmetros	Valores que a função recebe (opcionais).	`(int a, int b)`
Corpo	Bloco de código entre `{}` que contém as instruções.	`{ return a + b; }`

🔄 Funções com Retorno void

Funções que não retornam valor são declaradas com tipo void. Elas executam uma ação, mas não produzem um resultado.

void saudacao(const std::string& nome) {
    cout << "Olá, " << nome << "!" << endl;
    // Não precisa de return (ou pode usar return; para sair mais cedo)
}

int main() {
    saudacao("Maria");
    saudacao("João");
}
// Saída:
// Olá, Maria!
// Olá, João!
  

📤 Passagem de Parâmetros

C/C++ oferece três formas principais de passar argumentos para funções.

Por Valor (Padrão)

Uma cópia do argumento é passada. Alterações dentro da função não afetam a variável original.

void dobrar(int x) {
    x = x * 2;
    cout << "Dentro: " << x << endl;
}

int main() {
    int num = 5;
    dobrar(num);
    cout << "Fora: " << num << endl;   // 5 (não mudou)
}
  

Por Ponteiro (C e C++)

Passa o endereço da variável. A função pode modificar o valor original.

void dobrar(int* x) {
    *x = *x * 2;
}

int main() {
    int num = 5;
    dobrar(&num);
    cout << num << endl;   // 10 (mudou!)
}
  

Por Referência (Apenas C++)

Sintaxe mais limpa que ponteiros, com o mesmo efeito: a função pode modificar o original.

void dobrar(int& x) {
    x = x * 2;
}

int main() {
    int num = 5;
    dobrar(num);   // Sem & na chamada!
    cout << num << endl;   // 10
}
  

💡 Quando usar cada forma?

Por valor: Para tipos pequenos que não precisam ser modificados.
Por referência constante (const T&): Para objetos grandes que não serão modificados (evita cópia).
Por referência (T&): Quando a função precisa modificar o argumento.
Por ponteiro: Quando o argumento é opcional (pode ser nullptr) ou em código C.

📊 Passagem de Arrays para Funções

Arrays são sempre passados como ponteiros. O tamanho original é perdido.

// Estas três declarações são equivalentes
void imprimir1(int arr[], int tam);
void imprimir2(int arr[10], int tam);   // O 10 é IGNORADO!
void imprimir3(int* arr, int tam);

void imprimir(int* arr, int tam) {
    for (int i = 0; i < tam; i++) {
        cout << arr[i] << " ";
    }
}

int main() {
    int numeros[5] = {1, 2, 3, 4, 5};
    imprimir(numeros, 5);
}
  

🔁 Recursividade

Uma função pode chamar a si mesma. Útil para problemas que podem ser divididos em subproblemas idênticos.

// Fatorial recursivo
int fatorial(int n) {
    if (n <= 1) return 1;           // Caso base
    return n * fatorial(n - 1);   // Chamada recursiva
}

cout << fatorial(5) << endl;   // 120
  

📤 Retornando Múltiplos Valores

Funções retornam apenas um valor, mas é possível retornar múltiplos valores usando ponteiros, referências ou estruturas.

// Usando ponteiros para retornar múltiplos valores
void minMax(int arr[], int tam, int* min, int* max) {
    *min = *max = arr[0];
    for (int i = 1; i < tam; i++) {
        if (arr[i] < *min) *min = arr[i];
        if (arr[i] > *max) *max = arr[i];
    }
}

int main() {
    int numeros[5] = {3, 1, 4, 1, 5};
    int menor, maior;
    minMax(numeros, 5, &menor, &maior);
    cout << "Menor: " << menor << ", Maior: " << maior << endl;
}

// Em C++ moderno, std::pair ou std::tuple são alternativas mais elegantes
  

📏 Escopo de Variáveis em Funções

Tipo	Visibilidade	Tempo de Vida
Variável local	Apenas dentro da função	Enquanto a função executa
Parâmetro	Apenas dentro da função	Enquanto a função executa
`static` local	Apenas dentro da função	Durante toda a execução do programa
Variável global	Todas as funções	Durante toda a execução

int global = 100;   // Visível em todo o arquivo

void funcao() {
    int local = 10;              // Criada a cada chamada
    static int estatica = 0;      // Mantém o valor entre chamadas
    
    estatica++;
    cout << "Local: " << local << ", Estática: " << estatica << endl;
}

int main() {
    funcao();   // Local: 10, Estática: 1
    funcao();   // Local: 10, Estática: 2
}
  

💡 Boas Práticas

✅ Uma função, uma responsabilidade: Se a função faz mais de uma coisa, divida-a.
✅ Nomes significativos: Use verbos que indiquem a ação (calcularMedia, validarEmail).
✅ Tamanho adequado: Funções muito longas são difíceis de entender. Idealmente, até 20-30 linhas.
✅ Evite variáveis globais: Elas criam dependências ocultas e dificultam o teste.
✅ Use const em parâmetros que não serão modificados.
✅ Prefira retornar valores a modificar argumentos (exceto quando necessário).

🔗 Conclusão

Funções são a espinha dorsal da programação estruturada em C/C++. Elas permitem decompor problemas complexos, reutilizar código e criar abstrações poderosas. Dominar a criação e o uso de funções — incluindo passagem de parâmetros, retorno de valores e gerenciamento de escopo — é um passo fundamental para se tornar um programador proficiente.

⏭️ Próximo: Definindo funções...