Direttive Pragma e parole __pragma chiave e _Pragma

Le direttive Pragma specificano funzionalità del compilatore specifiche del computer o del sistema operativo. Riga che inizia con #pragma specifica una pragma direttiva . La parola chiave specifica di __pragma Microsoft consente di codificare pragma le direttive all'interno delle definizioni di macro. L'operatore del preprocessore standard _Pragma , introdotto in C99 e adottato da C++11, è simile.

Sintassi

#pragmatoken-string
__pragma(token-string) // due caratteri di sottolineatura iniziali - Estensione specifica di Microsoft
_Pragma(string-literal) // C99

Osservazioni:

Ogni implementazione di C e C++ supporta alcune funzionalità esclusive del computer host o del sistema operativo di utilizzo. Alcuni programmi, ad esempio, devono esercitare un controllo preciso sulla posizione dei dati in memoria o controllare il modo in cui determinate funzioni ricevono parametri. Le #pragma direttive offrono un modo per ogni compilatore di offrire funzionalità specifiche del computer e del sistema operativo, mantenendo al tempo stesso la compatibilità complessiva con i linguaggi C e C++.

Le direttive Pragma sono specifiche del computer o del sistema operativo per definizione e sono in genere diverse per ogni compilatore. Un pragma oggetto può essere usato in una direttiva condizionale per fornire nuove funzionalità del preprocessore. In alternativa, usarne uno per fornire informazioni definite dall'implementazione al compilatore.

La stringa token è una serie di caratteri che rappresentano un'istruzione e argomenti del compilatore specifici, se presenti. Il segno di numero (#) deve essere il primo carattere non vuoto nella riga che contiene l'oggetto pragma. Gli spazi vuoti possono separare il segno di numero e la parola "pragma". Dopo #pragma, scrivere qualsiasi testo che il traduttore possa analizzare come token di pre-elaborazione. L'argomento di #pragma è soggetto all'espansione di macro.

Il valore letterale stringa è l'input di _Pragma. Le virgolette esterne e gli spazi vuoti iniziali/finali vengono rimossi. \" viene sostituito con " e \\ viene sostituito con \.

Il compilatore genera un avviso quando trova un oggetto pragma che non riconosce e continua la compilazione.

I compilatori Microsoft C e C++ riconoscono le direttive seguenti pragma :

alloc_text
auto_inline
bss_seg
check_stack
code_seg
comment
component
conform¹
const_seg
data_seg
deprecated

detect_mismatch
endregion
fenv_access
float_control
fp_contract
function
hdrstop
include_alias
init_seg¹
inline_depth
inline_recursion

intrinsic
loop¹
make_public
managed
message
omp
once
optimize
pack
pointers_to_members¹
pop_macro

push_macro
region
runtime_checks
section
setlocale
strict_gs_check
system_header
unmanaged
vtordisp¹
warning

¹ Supportato solo dal compilatore C++.

Direttive Pragma e opzioni del compilatore

Alcune pragma direttive forniscono la stessa funzionalità delle opzioni del compilatore. Quando un pragma oggetto viene raggiunto nel codice sorgente, esegue l'override del comportamento specificato dall'opzione del compilatore. Ad esempio, se è stato specificato /Zp8, è possibile eseguire l'override di questa impostazione del compilatore per sezioni specifiche del codice con pack:

cl /Zp8 some_file.cpp

// some_file.cpp - packing is 8
// ...
#pragma pack(push, 1) - packing is now 1
// ...
#pragma pack(pop) - packing is 8 again
// ...

Parola chiave __pragma

Il compilatore supporta anche la parola chiave specifica di __pragma Microsoft, che ha la stessa funzionalità della #pragma direttiva . La differenza è che la __pragma parola chiave è utilizzabile inline in una definizione di macro. La #pragma direttiva non è utilizzabile in una definizione di macro, perché il compilatore interpreta il carattere di segno numerico ('#') nella direttiva come operatore di stringizzazione (#).

Nell'esempio di codice seguente viene illustrato come usare la __pragma parola chiave in una macro. Questo codice è estratto dall'intestazione mfcdual.h nell'esempio ACDUAL in "Compiler COM Support Samples":

#define CATCH_ALL_DUAL \
CATCH(COleException, e) \
{ \
_hr = e->m_sc; \
} \
AND_CATCH_ALL(e) \
{ \
__pragma(warning(push)) \
__pragma(warning(disable:6246)) /*disable _ctlState prefast warning*/ \
AFX_MANAGE_STATE(pThis->m_pModuleState); \
__pragma(warning(pop)) \
_hr = DualHandleException(_riidSource, e); \
} \
END_CATCH_ALL \
return _hr; \

_Pragma Operatore di pre-elaborazione

_Pragma è simile alla parola chiave specifica di __pragma Microsoft. È stato introdotto nello standard C in C99 e nello standard C++ in C++11. È disponibile in C solo quando si specifica l'opzione /std:c11 o /std:c17 . Per C++, è disponibile in tutte le /std modalità, incluso il valore predefinito.

A differenza di #pragma, _Pragma consente di inserire pragma direttive in una definizione di macro. Il valore letterale stringa deve essere quello che altrimenti si inserisce dopo un'istruzione #pragma . Ad esempio:

#pragma message("the #pragma way")
_Pragma ("message( \"the _Pragma way\")") 

Le virgolette e le barre rovesciate devono essere precedute da un carattere di escape, come illustrato in precedenza. Una pragma stringa non riconosciuta viene ignorata.

Nell'esempio di codice seguente viene illustrato come usare la _Pragma parola chiave in una macro simile a asserzione. Crea una pragma direttiva che elimina un avviso quando l'espressione della condizione diventa costante.

La definizione di macro usa il do ... while(0) linguaggio per le macro con più istruzioni in modo che possa essere usata come se fosse un'istruzione. Per altre informazioni, vedere Macro multilinea C in Stack Overflow. L'istruzione _Pragma nell'esempio si applica solo alla riga di codice che la segue.

// Compile with /W4

#include <stdio.h>
#include <stdlib.h>

#define MY_ASSERT(BOOL_EXPRESSION) \
    do { \
        _Pragma("warning(suppress: 4127)") /* C4127 conditional expression is constant */  \
        if (!(BOOL_EXPRESSION)) {   \
            printf("MY_ASSERT FAILED: \"" #BOOL_EXPRESSION "\" on %s(%d)", __FILE__, __LINE__); \
            exit(-1); \
        } \
    } while (0)

int main()
{
    MY_ASSERT(0 && "Note that there is no warning: C4127 conditional expression is constant");

    return 0;
}

Vedi anche

Informazioni di riferimento sul preprocessore C/C++
Direttive C pragma
Parole chiave