Guardie di inclusione

Gli header includono spesso altri header. È facile che un header finisca incluso due volte nello stesso file sorgente.

Quando accade, ogni dichiarazione al suo interno compare due volte. Per le definizioni di tipo come struct o typedef, questo causa un errore di compilazione: un tipo non può essere definito più di una volta.

Supponiamo che a.h e b.h includano entrambi types.h. Un file sorgente che li include entrambi si ritrova con types.h incollato due volte.

Il preprocessore copia ciecamente il testo degli header, quindi le definizioni di types.h vengono duplicate e provocano un errore di ridefinizione.

Una protezione dagli include è un piccolo accorgimento del preprocessore che rende sicuro includere un header molte volte.

Racchiude l'intero header in una condizione, così il corpo viene elaborato solo la prima volta. Le inclusioni successive vengono completamente ignorate.

La prima volta che l'header viene incontrato, TYPES_H non è definito, quindi #ifndef è vero e il corpo viene elaborato. In seguito #define imposta la macro.

In ogni inclusione successiva, TYPES_H esiste già, quindi #ifndef è falso e il preprocessore passa direttamente a #endif.

Ecco un header realistico con una protezione che tutela una definizione di tipo.

Anche se molti file includono point.h direttamente o indirettamente, la struct Point viene definita esattamente una volta per ogni unità di traduzione.

La macro di protezione deve essere unica nell'intero progetto, altrimenti due header potrebbero entrare in conflitto e nascondersi a vicenda senza segnalazioni.

Una convenzione comune ricava il nome dal nome del file, in maiuscolo: point.h diventa POINT_H, net/socket.h diventa NET_SOCKET_H.

Gli identificatori che iniziano con un underscore seguito da una lettera maiuscola, oppure contengono due underscore consecutivi, sono riservati al compilatore e alla libreria standard.

Eviti protezioni come __POINT_H__. Una forma semplice con underscore finale, come POINT_H, è sicura e chiara.

La maggior parte dei compilatori moderni supporta #pragma once, una singola riga all'inizio di un header che svolge lo stesso compito.

È più breve ed evita i conflitti tra nomi, ma non fa parte dello standard C. Le protezioni tradizionali con #ifndef funzionano ovunque.

Le protezioni con #ifndef sono completamente portabili e standard, ma richiedono una macro unica per ogni header.

#pragma once è compatto e non presenta conflitti tra nomi, ma dipende dal supporto del compilatore. Alcuni progetti usano entrambi: un pragma insieme a una protezione classica per la massima sicurezza.

Una protezione dagli include impedisce l'inclusione duplicata all'interno di un singolo file sorgente durante la compilazione.

Non impedisce che un header venga elaborato una volta in ciascun file .c separato. Ed è corretto così, perché ogni file sorgente è un'unità di traduzione distinta.

Aggiunga una protezione dagli include a ogni header che scrive, fin dalla prima riga. Richiede tre righe e previene un'intera categoria di errori difficili da comprendere.

Anche gli header semplici possono in seguito essere inclusi indirettamente tramite altri header, quindi proteggerli fin dall'inizio evita problemi.

Verifichi la Sua comprensione delle protezioni dagli include.

Ha imparato perché includere due volte un header causa errori di ridefinizione e come una protezione dagli include li previene.

Usi #ifndef/#define/#endif con una macro unica, oppure #pragma once. Ora vedremo come condividere variabili tra file con extern.