Aula 19 — Protótipos, Header Files, static e inline

1. Protótipos de Função

Até agora você provavelmente colocou todas as funções antes de main() para que o compilador as conhecesse. Mas e quando o programa cresce e as funções precisam se chamar mutuamente? A solução é o protótipo.

Sintaxe

// Protótipo — apenas a assinatura, terminada com ;
float calcularMedia(float a, float b);

// Os nomes dos parâmetros são opcionais no protótipo:
float calcularMedia(float, float);   // equivalente

Exemplo prático: protótipos permitem chamar funções definidas depois

#include <stdio.h>

/* ── Protótipos ───────────────────────────────── */
float calcularMedia(float a, float b);
void classificarAluno(float media);

/* ── main ──────────────────────────────────────── */
int main() {
    float n1 = 7.5, n2 = 8.0;
    float media = calcularMedia(n1, n2);
    classificarAluno(media);
    return 0;
}

/* ── Definições (podem vir depois de main) ─────── */
float calcularMedia(float a, float b) {
    return (a + b) / 2.0;
}

void classificarAluno(float media) {
    if (media >= 7.0)
        printf("Aprovado (%.1f)\n", media);
    else
        printf("Reprovado (%.1f)\n", media);
}

2. Arquivos de Cabeçalho (.h)

Você já usa arquivos .h todo dia: #include <stdio.h> inclui o cabeçalho da biblioteca padrão de I/O. Agora você vai criar os seus próprios.

Estrutura de um arquivo .h bem feito

/* matematica.h — cabeçalho do módulo de matemática */

/* ── Inclusion guard: evita que o arquivo seja incluído duas vezes ── */
#ifndef MATEMATICA_H
#define MATEMATICA_H

/* Constantes */
#define PI 3.14159265358979

/* Protótipos das funções públicas */
float calcularMedia(float a, float b);
float areaCirculo(float raio);
int   ehPrimo(int n);

#endif /* MATEMATICA_H */

Inclusion guard — por que é obrigatório

Se dois arquivos .c incluírem o mesmo .h, e um deles incluir o outro, o conteúdo do .h seria inserido duas vezes no mesmo arquivo de compilação, causando erros de "redeclaração". O inclusion guard previne isso:

O par .h / .c — interface e implementação

/* ─── matematica.h ─── interface (o que o usuário precisa saber) ─── */
#ifndef MATEMATICA_H
#define MATEMATICA_H
#define PI 3.14159265358979
float calcularMedia(float a, float b);
float areaCirculo(float raio);
int   ehPrimo(int n);
#endif

/* ─── matematica.c ─── implementação (como funciona por dentro) ─── */
#include "matematica.h"   // aspas: arquivo local (não <> de sistema)
#include <math.h>

float calcularMedia(float a, float b) {
    return (a + b) / 2.0f;
}

float areaCirculo(float raio) {
    return PI * raio * raio;
}

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

3. Funções static — Encapsulamento por Arquivo

Por padrão, toda função em C tem ligação externa: qualquer outro arquivo .c pode acessá-la (desde que tenha o protótipo). Às vezes você quer o contrário — uma função que é um detalhe interno, invisível para o resto do programa.

/* ─── validacao.c ─── */
#include <stdio.h>

/* Função PRIVADA — auxiliar interna, não exportada */
static int ehValido(int valor) {
    return valor >= 0 && valor <= 100;
}

/* Função PÚBLICA — visível para outros arquivos */
float calcularMedia(int a, int b) {
    if (!ehValido(a) || !ehValido(b)) {
        printf("Valor fora do intervalo [0,100]!\n");
        return -1.0f;
    }
    return (a + b) / 2.0f;
}

Exemplo: validação privada em um módulo de cadastro

/* ─── cadastro.c ─── */
#include "cadastro.h"
#include <string.h>
#include <stdio.h>

/* Auxiliares estáticas — não aparecem no cadastro.h */
static int nomeValido(const char *nome) {
    return strlen(nome) >= 3 && strlen(nome) <= 50;
}

static int idadeValida(int idade) {
    return idade >= 0 && idade <= 130;
}

/* Função pública */
int cadastrarPessoa(const char *nome, int idade) {
    if (!nomeValido(nome)) {
        printf("Nome inválido: '%s'\n", nome);
        return 0;
    }
    if (!idadeValida(idade)) {
        printf("Idade inválida: %d\n", idade);
        return 0;
    }
    printf("Cadastrado: %s, %d anos\n", nome, idade);
    return 1;
}

4. Funções static inline — Otimização sem Perda de Clareza

Toda chamada de função tem um custo: o programa precisa salvar o estado atual, desviar para o código da função, executar, e retornar. Para funções muito pequenas e chamadas com alta frequência (dentro de loops), esse overhead pode ser significativo.

#include <stdio.h>

/* Função static inline — ideal para operações pequenas e frequentes */
static inline int quadrado(int x) {
    return x * x;
}

static inline float celsius_para_fahrenheit(float c) {
    return c * 9.0f / 5.0f + 32.0f;
}

static inline int max(int a, int b) {
    return (a > b) ? a : b;
}

int main() {
    int soma = 0;
    for (int i = 1; i <= 100; i++)
        soma += quadrado(i);   // O compilador pode expandir o código aqui

    printf("Soma dos quadrados de 1 a 100: %d\n", soma);
    printf("37°C = %.1f°F\n", celsius_para_fahrenheit(37.0f));
    printf("max(15, 23) = %d\n", max(15, 23));
    return 0;
}

Quando usar inline — e quando não usar

Comparação: #define vs static inline

Muita gente usa #define para mini-funções como #define QUAD(x) ((x)*(x)). Isso funciona, mas tem armadilhas. A versão static inline é mais segura:

/* ❌ Problema com #define — efeito colateral */
#define QUAD(x) ((x)*(x))
int i = 3;
int r = QUAD(i++);   // expande para (i++)*(i++) — incrementa i DUAS vezes!

/* ✅ Correto com static inline */
static inline int quadrado(int x) { return x * x; }
int r2 = quadrado(i++);   // i++ ocorre UMA vez, como esperado

5. Resumo: como as peças se encaixam