Entendendo o Pré-processador C (CPP): Como Ele Simplifica a Compilação

O pré-processador C não faz parte do compilador, mas é uma etapa separada no processo de compilação. Em termos simples, um pré-processador C é apenas uma ferramenta de substituição de texto que instrui o compilador a realizar o pré-processamento necessário antes da compilação propriamente dita. Referiremos ao pré-processador C como CPP.

Todos os comandos do pré-processador começam com o símbolo de hash (#). Ele deve ser o primeiro caractere não em branco e, para melhor legibilidade, uma diretiva de pré-processador deve começar na primeira coluna. A seção a seguir lista todas as diretivas importantes do pré-processador:

Nº	Diretiva & Descrição
1	#define Substitui um macro do pré-processador.
2	#include Insere um cabeçalho específico de outro arquivo.
3	#undef Indefine um macro do pré-processador.
4	#ifdef Retorna verdadeiro se este macro estiver definido.
5	#ifndef Retorna verdadeiro se este macro não estiver definido.
6	#if Testa se uma condição em tempo de compilação é verdadeira.
7	#else A alternativa para #if.
8	#elif #else e #if em uma única instrução.
9	#endif Finaliza condicional do pré-processador.
10	#error Imprime mensagem de erro no stderr.
11	#pragma Emite comandos especiais para o compilador, usando um método padronizado.

Exemplos de Pré-processadores

Analise os seguintes exemplos para entender as várias diretivas.

 #define MAX_ARRAY_LENGTH 20 

Esta diretiva diz ao CPP para substituir instâncias de MAX_ARRAY_LENGTH por 20. Use #define para constantes para aumentar a legibilidade.

 #include <stdio.h> #include "meuheader.h" 

Estas diretivas dizem ao CPP para obter stdio.h das Bibliotecas do Sistema e adicionar o texto ao arquivo fonte atual. A próxima linha diz ao CPP para obter meuheader.h do diretório local e adicionar o conteúdo ao arquivo fonte atual.

 #undef FILE_SIZE #define FILE_SIZE 42 

Diz ao CPP para indefinir FILE_SIZE existente e defini-lo como 42.

 #ifndef MESSAGE #define MESSAGE "Você deseja!" #endif 

Diz ao CPP para definir MESSAGE apenas se MESSAGE ainda não estiver definido.

 #ifdef DEBUG /* Suas instruções de depuração aqui */ #endif 

Diz ao CPP para processar as instruções contidas se DEBUG estiver definido. Isso é útil se você passar a flag -DDEBUG para o compilador gcc no momento da compilação. Isso definirá DEBUG, permitindo ativar e desativar a depuração dinamicamente durante a compilação.

Macros Predefinidas

O C ANSI define uma série de macros. Embora cada uma esteja disponível para uso na programação, as macros predefinidas não devem ser modificadas diretamente.

Nº	Macro & Descrição
1	__DATE__ A data atual como literal de caractere no formato "MMM DD AAAA".
2	__TIME__ A hora atual como literal de caractere no formato "HH:MM:SS".
3	__FILE__ Contém o nome do arquivo atual como literal de string.
4	__LINE__ Contém o número da linha atual como constante decimal.
5	__STDC__ Definido como 1 quando o compilador está em conformidade com o padrão ANSI.

Vamos testar o seguinte exemplo:

Demo ao vivo

 #include <stdio.h> int main() { printf("Arquivo :%s\n", __FILE__ ); printf("Data :%s\n", __DATE__ ); printf("Hora :%s\n", __TIME__ ); printf("Linha :%d\n", __LINE__ ); printf("ANSI :%d\n", __STDC__ ); } 

Quando o código acima em um arquivo teste.c é compilado e executado, produz o seguinte resultado:

 Arquivo :teste.c Data :Jun 2 2012 Hora :03:36:24 Linha :8 ANSI :1 

Operadores do Pré-processador

O pré-processador C oferece os seguintes operadores para ajudar a criar macros:

O Operador de Continuação de Macro (\)

Um macro normalmente fica confinado a uma única linha. O operador de continuação de macro (\) é usado para continuar um macro longo demais para uma única linha. Por exemplo:

 #define mensagem_para(a, b) \ printf(#a " e " #b ": Nós amamos você!\n") 

O Operador Stringize (#)

O operador stringize ou sustenido ( '#' ), quando usado dentro de uma definição de macro, converte um parâmetro de macro em uma constante de string. Este operador só pode ser usado em um macro que tenha uma lista de argumentos ou parâmetros especificada. Por exemplo:

Demo ao vivo

 #include <stdio.h> #define mensagem_para(a, b) \ printf(#a " e " #b ": Nós amamos você!\n") int main(void) { mensagem_para(Carole, Debra); return 0; } 

Quando o código acima é compilado e executado, produz o seguinte resultado:

 Carole e Debra: Nós amamos você! 

O Operador Token Pasting (##)

O operador token-pasting (##) dentro de uma definição de macro combina dois argumentos. Ele permite que dois tokens separados na definição do macro sejam unidos em um único token. Por exemplo:

Demo ao vivo

 #include <stdio.h> #define tokenpaster(n) printf ("token" #n " = %d", token##n) int main(void) { int token34 = 40; tokenpaster(34); return 0; } 

Quando o código acima é compilado e executado, produz o seguinte resultado:

 token34 = 40 

Isso aconteceu porque este exemplo resulta na seguinte saída real do pré-processador:

 printf ("token34 = %d", token34); 

Este exemplo mostra a concatenação de token##n em token34 e aqui usamos tanto stringize quanto token-pasting.

O Operador Defined()

O operador defined do pré-processador é usado em expressões constantes para determinar se um identificador foi definido usando #define. Se o identificador especificado estiver definido, o valor é verdadeiro (não-zero). Se o símbolo não estiver definido, o valor é falso (zero). O operador defined é especificado da seguinte forma:

Demo ao vivo

 #include <stdio.h> #if !defined (MESSAGE) #define MESSAGE "Você deseja!" #endif int main(void) { printf("Aqui está a mensagem: %s\n", MESSAGE); return 0; } 

Quando o código acima é compilado e executado, produz o seguinte resultado:

 Aqui está a mensagem: Você deseja! 

Macros Parametrizadas

Uma das funções poderosas do CPP é a capacidade de simular funções usando macros parametrizadas. Por exemplo, podemos ter algum código para elevar um número ao quadrado da seguinte forma:

 int quadrado(int x) { return x * x; } 

Podemos reescrever o código acima usando um macro da seguinte forma:

 #define quadrado(x) ((x) * (x)) 

Macros com argumentos devem ser definidos usando a diretiva #define antes de poderem ser usados. A lista de argumentos é colocada entre parênteses e deve seguir imediatamente o nome do macro. Espaços não são permitidos entre o nome do macro e o parêntese de abertura. Por exemplo:

Demo ao vivo

 #include <stdio.h> #define MAX(x,y) ((x) > (y) ? (x) : (y)) int main(void) { printf("Máximo entre 20 e 10 é %d\n", MAX(10, 20)); return 0; } 

Quando o código acima é compilado e executado, produz o seguinte resultado:

 Máximo entre 20 e 10 é 20