Guardas de inclusão

Os cabeçalhos costumam incluir outros cabeçalhos. É fácil que um cabeçalho acabe sendo incluído duas vezes no mesmo arquivo-fonte.

Quando isso acontece, todas as declarações nele aparecem duas vezes. Para definições de tipos como struct ou typedef, isso é um erro de compilação: um tipo não pode ser definido mais de uma vez.

Suponha que a.h e b.h incluam types.h. Um arquivo-fonte que inclua ambos acabará com types.h copiado duas vezes.

O pré-processador copia cegamente o texto dos cabeçalhos, então as definições de types.h ficam duplicadas, provocando um erro de redefinição.

Uma guarda de inclusão é uma técnica simples do pré-processador que torna seguro incluir um cabeçalho várias vezes.

Ela envolve todo o cabeçalho em uma condicional, para que o corpo seja processado apenas na primeira vez. As inclusões posteriores são totalmente ignoradas.

Na primeira vez que o cabeçalho é encontrado, TYPES_H não está definido, então #ifndef é verdadeiro e o corpo é processado. Em seguida, #define define a macro.

Em qualquer inclusão posterior, TYPES_H já existe, então #ifndef é falso e o pré-processador avança até #endif.

Aqui está um cabeçalho realista com uma guarda protegendo uma definição de tipo.

Mesmo que muitos arquivos incluam point.h direta ou indiretamente, a estrutura Point é definida exatamente uma vez por unidade de tradução.

A macro da guarda precisa ser exclusiva em todo o projeto, ou dois cabeçalhos podem entrar em conflito e ocultar um ao outro silenciosamente.

Uma convenção comum deriva o nome do nome do arquivo em letras maiúsculas: point.h se torna POINT_H, e net/socket.h se torna NET_SOCKET_H.

Identificadores que começam com um sublinhado seguido de uma letra maiúscula ou que contêm sublinhados duplos são reservados para o compilador e a biblioteca padrão.

Evite guardas como __POINT_H__. Uma forma simples com o sufixo _H, como POINT_H, é segura e clara.

A maioria dos compiladores modernos oferece suporte a #pragma once, uma única linha no início de um cabeçalho que cumpre a mesma função.

Ela é mais curta e evita conflitos de nomes, mas não faz parte do padrão C. As guardas tradicionais com #ifndef funcionam em qualquer lugar.

As guardas com #ifndef são totalmente portáteis e padronizadas, mas exigem uma macro exclusiva para cada cabeçalho.

#pragma once é compacto e não causa conflitos, mas depende do suporte do compilador. Alguns projetos usam ambos: uma pragma junto com uma guarda clássica para obter a máxima segurança.

Uma guarda de inclusão impede inclusões duplicadas dentro de um único arquivo-fonte durante sua compilação.

Ela não impede que um cabeçalho seja processado uma vez em cada arquivo .c separado. Isso é adequado, porque cada arquivo-fonte é uma unidade de tradução distinta.

Adicione uma guarda de inclusão a cada cabeçalho que escrever, desde a primeira linha. Isso custa três linhas e evita toda uma categoria de erros confusos.

Até mesmo cabeçalhos simples podem ser incluídos indiretamente por outros mais tarde, então protegê-los desde o início evita problemas.

Verifique sua compreensão das guardas de inclusão.

Você aprendeu por que incluir um cabeçalho duas vezes causa erros de redefinição e como uma guarda de inclusão evita isso.

Use #ifndef/#define/#endif com uma macro exclusiva ou use #pragma once. Em seguida, veremos como compartilhar variáveis entre arquivos com extern.