C - Pré-processadores

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 e instrui o compilador a fazer o pré-processamento necessário antes da compilação real. Vamos nos referir ao pré-processador C como CPP.

Todos os comandos do pré-processador começam com um símbolo de hash (#). Deve ser o primeiro caractere não em branco e, para facilitar a leitura, 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º Sr.	Diretiva e Descrição
1	#define Substitui uma macro de pré-processador.
2	#include Insere um cabeçalho específico de outro arquivo.
3	#undef Indefine uma macro de pré-processador.
4	#ifdef Retorna verdadeiro se esta macro estiver definida.
5	#ifndef Retorna verdadeiro se esta macro não estiver definida.
6	#if Testa se uma condição de tempo de compilação é verdadeira.
7	#senão A alternativa para #if.
8	#elif #else e #if em uma declaração.
9	#endif Encerra o pré-processador condicional.
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 exemplos a seguir para entender 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 constantes para aumentar a legibilidade.

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

Essas diretivas dizem ao CPP para obter stdio.h das Bibliotecas do Sistema e adicione o texto ao arquivo de origem atual. A próxima linha diz ao CPP para obter myheader.h do diretório local e adicione o conteúdo ao arquivo de origem atual.

#undef  FILE_SIZE
#define FILE_SIZE 42

Ele diz ao CPP para não definir FILE_SIZE existente e defini-lo como 42.

#ifndef MESSAGE
   #define MESSAGE "You wish!"
#endif

Ele diz ao CPP para definir MESSAGE somente se MESSAGE ainda não estiver definido.

#ifdef DEBUG
   /* Your debugging statements here */
#endif

Ele diz ao CPP para processar as instruções incluídas se DEBUG estiver definido. Isso é útil se você passar o -DDEBUG sinalizador para o compilador gcc no momento da compilação. Isso definirá DEBUG, para que você possa ativar e desativar a depuração durante a compilação.

Macros predefinidos

ANSI C 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º Sr.	Macro e descrição
1	__DATE__ A data atual como um caractere literal no formato "MMM DD AAAA".
2	__TIME__ A hora atual como um caractere literal no formato "HH:MM:SS".
3	__FILE__ Ele contém o nome do arquivo atual como um literal de string.
4	__LINE__ Ele contém o número da linha atual como uma constante decimal.
5	__STDC__ Definido como 1 quando o compilador está em conformidade com o padrão ANSI.

Vamos tentar o seguinte exemplo -
Demonstração ao vivo

#include <stdio.h>

int main() {

   printf("File :%s\n", __FILE__ );
   printf("Date :%s\n", __DATE__ );
   printf("Time :%s\n", __TIME__ );
   printf("Line :%d\n", __LINE__ );
   printf("ANSI :%d\n", __STDC__ );

}

Quando o código acima em um arquivo test.c é compilado e executado, ele produz o seguinte resultado -

File :test.c
Date :Jun 2 2012
Time :03:36:24
Line :8
ANSI :1

Operadores de pré-processador

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

O operador de continuação de macro (\)

Uma macro é normalmente confinada a uma única linha. O operador de continuação de macro (\) é usado para continuar uma macro que é muito longa para uma única linha. Por exemplo -

#define  message_for(a, b)  \
   printf(#a " and " #b ": We love you!\n")

O operador Stringize (#)

O operador stringize ou number-sign ( '#' ), quando usado em uma definição de macro, converte um parâmetro de macro em uma constante de string. Este operador só pode ser usado em uma macro que tenha um argumento ou lista de parâmetros especificados. Por exemplo -
Demonstração ao vivo

#include <stdio.h>

#define  message_for(a, b)  \
   printf(#a " and " #b ": We love you!\n")

int main(void) {
   message_for(Carole, Debra);
   return 0;
}

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

Carole and Debra: We love you!

O operador de colagem de token (##)

O operador de colagem de token (##) em uma definição de macro combina dois argumentos. Ele permite que dois tokens separados na definição de macro sejam unidos em um único token. Por exemplo -
Demonstração 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, ele 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 stringize e colagem de token .

O operador Defined()

O pré-processador definido operador é usado em expressões constantes para determinar se um identificador é definido usando #define. Se o identificador especificado for definido, o valor será verdadeiro (diferente de zero). Se o símbolo não estiver definido, o valor é falso (zero). O operador definido é especificado da seguinte forma -
Demonstração ao vivo

#include <stdio.h>

#if !defined (MESSAGE)
   #define MESSAGE "You wish!"
#endif

int main(void) {
   printf("Here is the message: %s\n", MESSAGE);  
   return 0;
}

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

Here is the message: You wish!

Macros parametrizados

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 ao quadrado um número da seguinte forma -

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

Podemos reescrever acima do código usando uma macro da seguinte forma -

#define square(x) ((x) * (x))

Macros com argumentos devem ser definidas usando o #define diretiva antes que eles possam ser usados. A lista de argumentos está entre parênteses e deve seguir imediatamente o nome da macro. Não são permitidos espaços entre o nome da macro e os parênteses abertos. Por exemplo -
Demonstração ao vivo

#include <stdio.h>

#define MAX(x,y) ((x) > (y) ? (x) : (y))

int main(void) {
   printf("Max between 20 and 10 is %d\n", MAX(10, 20));  
   return 0;
}

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

Max between 20 and 10 is 20