Parece haver muita confusão em relação ao pré-processador.
O que o compilador faz quando vê #include
que substitui essa linha pelo conteúdo dos arquivos incluídos, sem perguntas.
Portanto, se você possui um arquivo a.h
com este conteúdo:
typedef int my_number;
e um arquivo b.c
com este conteúdo:
#include "a.h"
#include "a.h"
o arquivo b.c
será traduzido pelo pré-processador antes da compilação para
typedef int my_number;
typedef int my_number;
o que resultará em um erro do compilador, pois o tipo my_number
é definido duas vezes. Mesmo que a definição seja a mesma, isso não é permitido pela linguagem C.
Como um cabeçalho geralmente é usado em mais de um local, os protetores geralmente são usados em C. Isso se parece com isso:
#ifndef _a_h_included_
#define _a_h_included_
typedef int my_number;
#endif
O arquivo b.c
ainda teria todo o conteúdo do cabeçalho nele duas vezes depois de pré-processado. Mas a segunda instância seria ignorada, pois a macro _a_h_included_
já teria sido definida.
Isso funciona muito bem, mas tem duas desvantagens. Antes de tudo, os protetores de inclusão precisam ser escritos e o nome da macro deve ser diferente em cada cabeçalho. Em segundo lugar, o compilador ainda precisa procurar o arquivo de cabeçalho e lê-lo com a frequência incluída.
O Objective-C possui a #import
instrução de pré - processador (também pode ser usada para o código C e C ++ com alguns compiladores e opções). Isso faz quase o mesmo que #include
, mas também observa internamente qual arquivo já foi incluído. A #import
linha é substituída apenas pelo conteúdo do arquivo nomeado pela primeira vez. Toda vez depois disso é apenas ignorado.