once pragma
Specifica che il compilatore include il file di intestazione una sola volta, durante la compilazione di un file di codice sorgente.
Sintassi
#pragma once
Osservazioni:
L'uso di può ridurre i tempi di #pragma once compilazione, perché il compilatore non si aprirà e leggerà di nuovo il file dopo il primo #include del file nell'unità di conversione. Si chiama ottimizzazione di inclusione multipla. Ha un effetto simile al linguaggio di inclusione guard , che usa le definizioni di macro del preprocessore per impedire più inclusioni del contenuto del file. Consente inoltre di evitare violazioni di una regola di definizione: il requisito che tutti i modelli, i tipi, le funzioni e gli oggetti non abbiano più di una definizione nel codice.
Ad esempio:
// header.h
#pragma once
// Code placed here is included only once per translation unit
È consigliabile usare la direttiva #pragma once per il nuovo codice, in quanto non inquina lo spazio dei nomi globale con un simbolo del preprocessore. Richiede meno tipizzazione, è meno distratto e non può causare conflitti di simboli. Le collisioni dei simboli sono errori causati da diversi file di intestazione che usano lo stesso simbolo del preprocessore del valore di protezione. Non fa parte dello standard C++, ma viene implementato in modo portabile da diversi compilatori comuni.
Non c'è alcun vantaggio da usare sia il linguaggio di protezione di inclusione che #pragma once nello stesso file. Il compilatore riconosce il linguaggio di inclusione guard e implementa l'ottimizzazione di inclusione multipla allo stesso modo della #pragma once direttiva se nessun codice non commento o direttiva del preprocessore viene prima o dopo la forma standard del linguaggio:
// header.h
// Demonstration of the #include guard idiom.
// Note that the defined symbol can be arbitrary.
#ifndef HEADER_H_ // equivalently, #if !defined HEADER_H_
#define HEADER_H_
// Code placed here is included only once per translation unit
#endif // HEADER_H_
È consigliabile usare il linguaggio include guard quando il codice deve essere portabile ai compilatori che non implementano la #pragma once direttiva, per mantenere la coerenza con il codice esistente o quando l'ottimizzazione di inclusione multipla è impossibile. Può verificarsi in progetti complessi quando gli alias del file system o i percorsi di inclusione con alias impediscono al compilatore di identificare file di inclusione identici per percorso canonico.
Prestare attenzione a non usare #pragma once o includere il linguaggio di protezione nei file di intestazione progettati per essere inclusi più volte, che usano simboli del preprocessore per controllare i relativi effetti. Per un esempio di questa progettazione, vedere il <file di intestazione assert.h> . Prestare attenzione anche a gestire i percorsi di inclusione per evitare di creare più percorsi per i file inclusi, che possono sconfiggere l'ottimizzazione a più inclusioni sia per le guardie #pragma onceche per .