Em C, tanto funções inline quanto macros de função podem ser usadas para evitar o overhead de chamada de função, mas possuem semânticas e riscos muito diferentes. Nesta aula, vamos explorar cada uma delas em profundidade, com exemplos práticos e boas práticas.

Entender a diferença entre esses dois mecanismos é crucial para escrever código eficiente e seguro. Enquanto as funções inline são uma sugestão ao compilador e preservam a verificação de tipos, as macros são substituições textuais que podem causar efeitos colaterais inesperados.

inline

O especificador inline é uma dica ao compilador para que ele tente substituir a chamada da função pelo próprio corpo da função, evitando o custo de uma chamada de função (empilhar argumentos, desvio, retorno). No entanto, o compilador pode ignorar essa sugestão se a função for muito grande ou se a inlining não for benéfica.

Uma função inline é definida com a palavra-chave inline antes do tipo de retorno. Ela deve ser definida em um arquivo de cabeçalho (header) para que esteja disponível em todas as unidades de compilação. Exemplo:

// max.h
#ifndef MAX_H
#define MAX_H

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

#endif

Para evitar múltiplas definições, geralmente se usa static inline ou se define em um único arquivo .c com declaração externa. A partir de C99, funções inline podem ser definidas em cabeçalhos sem static, desde que haja uma declaração externa em exatamente um arquivo .c.

Funções inline respeitam a verificação de tipos, avaliam seus argumentos apenas uma vez e não sofrem de problemas de precedência, ao contrário das macros. São preferíveis quando se deseja desempenho sem sacrificar a segurança de tipos.

Macros com argumentos

Macros de função são definidas com #define e podem receber argumentos. Elas realizam substituição textual antes da compilação (pré-processamento). Exemplo:

#define MAX(a, b) ((a) > (b) ? (a) : (b))

Observe os parênteses extras: eles são essenciais para garantir a precedência correta. Sem eles, expressões como MAX(x & 1, y) poderiam ser mal interpretadas. Além disso, cada argumento é colocado entre parênteses na expansão para evitar problemas com operadores de maior precedência.

Macros podem ser úteis para operações muito simples e para evitar overhead de chamada de função, mas têm várias desvantagens: não há verificação de tipos, os argumentos podem ser avaliados múltiplas vezes (causando efeitos colaterais), e podem gerar código maior se usadas repetidamente.

Riscos de macros

O principal risco das macros é a avaliação múltipla de argumentos. Considere:

#define SQUARE(x) ((x) * (x))

int a = 5;
int result = SQUARE(a++); // Expande para ((a++) * (a++)) - comportamento indefinido!

Nesse caso, a++ é incrementado duas vezes, resultando em comportamento indefinido. Outro risco é a falta de escopo: macros não respeitam blocos, podendo interferir com variáveis locais. Por exemplo:

#define SWAP(a, b) { int temp = a; a = b; b = temp; }

if (x > y)
    SWAP(x, y); // Problema: o ponto e vírgula após a macro quebra o if sem chaves!

Para evitar isso, usa-se o padrão do { ... } while(0):

#define SWAP(a, b) do { int temp = a; a = b; b = temp; } while(0)

Além disso, macros podem causar poluição do namespace e dificultar a depuração, pois o código expandido não aparece no código fonte original.

Quando usar cada um

Use funções inline quando precisar de segurança de tipos, avaliação única de argumentos e depuração fácil. São ideais para funções pequenas e frequentemente chamadas, como acessores e operações matemáticas simples. Exemplo:

static inline int clamp(int value, int min, int max) {
    if (value < min) return min;
    if (value > max) return max;
    return value;
}

Use macros apenas quando não for possível usar inline, como para gerar código genérico (ex.: offsetof, assert) ou para operações que dependem do contexto de pré-processamento (ex.: __LINE__). Evite macros para operações que avaliam argumentos mais de uma vez. Em código moderno, prefira funções inline sempre que possível.

Boas práticas e observações finais

Sempre que possível, use funções inline em vez de macros. Se precisar usar macros, coloque parênteses em torno de cada argumento e de toda a expressão, e use o padrão do { ... } while(0) para múltiplas instruções. Considere também o uso de _Generic (C11) para macros type-generic, mas ainda assim prefira funções inline com sobrecarga (C11 não tem sobrecarga, mas pode-se usar _Generic).

Referências

Exercícios

  1. Crie uma macro ABS(x) que retorna o valor absoluto de x. Use parênteses adequados.

    ✓ Resposta:
    #define ABS(x) ((x) < 0 ? -(x) : (x))

  2. Converta a macro do exercício anterior em uma função inline equivalente.

    ✓ Resposta:
    static inline int abs(int x) {
    return x < 0 ? -x : x;
}

  3. Explique por que a macro #define SOMA(a, b) a + b é problemática e como corrigi-la.

    ✓ Resposta:O problema é que, sem parênteses, a expansão pode causar erros de precedência. Por exemplo, SOMA(1, 2) * 3 expande para 1 + 2 * 3 que é 1 + 6 = 7, em vez de (1+2)*3=9. A correção é colocar parênteses em torno de toda a expressão: #define SOMA(a, b) ((a) + (b)).

  4. Escreva uma macro MAX3(a, b, c) que retorna o maior de três valores, usando a macro MAX definida anteriormente. Certifique-se de que cada argumento seja avaliado apenas uma vez.

    ✓ Resposta:
    #define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MAX3(a, b, c) MAX(MAX(a, b), c)
    No entanto, isso avalia a e b duas vezes. Para evitar avaliação múltipla, seria melhor usar uma função inline ou variáveis temporárias. Mas em macros, não há como garantir avaliação única sem usar extensões do GCC como expressões compostas.

  5. Qual a diferença fundamental entre uma função inline e uma macro de função em relação à avaliação de argumentos?

    ✓ Resposta:Em uma função inline, os argumentos são avaliados exatamente uma vez antes da chamada, como em qualquer função. Em uma macro, os argumentos são substituídos textualmente e podem ser avaliados múltiplas vezes se aparecerem mais de uma vez na expansão, causando possíveis efeitos colaterais.