Pragma direktivy a __pragma _Pragma klíčová slova

Pragma direktivy určují funkce kompilátoru specifické pro konkrétní počítač nebo operační systém. Řádek, který začíná #pragma specifikovat direktivu pragma . Klíčové slovo specifické pro __pragma Microsoft umožňuje kódovat pragma direktivy v rámci definic maker. Standardní _Pragma operátor preprocesoru zavedený v jazyce C99 a přijatý jazykem C++11 je podobný.

Syntaxe

#pragmatoken-string
__pragma(token-string ) dvě úvodní podtržítka – rozšíření specifické pro Microsoft
_Pragma(řetězcový literál ) C99

Poznámky

Každá implementace jazyka C a C++ podporuje některé funkce jedinečné pro hostitelský počítač nebo operační systém. Některé programy například musí vykonávat přesnou kontrolu nad umístěním dat v paměti nebo řídit způsob, jakým určité funkce přijímají parametry. Direktivy #pragma nabízejí každému kompilátoru způsob, jak nabídnout funkce specifické pro počítač a operační systém a současně zachovat celkovou kompatibilitu s jazyky C a C++.

Pragma direktivy jsou specifické pro počítač nebo operační systém podle definice a obvykle se pro každý kompilátor liší. Pomocí pragma podmíněné direktivy lze poskytovat nové funkce preprocesoru. Nebo ho použijte k poskytnutí informací definovaných implementací kompilátoru.

Řetězec tokenu je řada znaků představujících konkrétní instrukce kompilátoru a argumenty, pokud existuje. Znak čísla (#) musí být prvním neprázdným znakem na řádku, který obsahuje pragmaznak . Prázdné znaky mohou oddělit znak čísla a slovo "pragma". Zapište #pragmalibovolný text, který může translator analyzovat jako tokeny předběžného zpracování. Argument, který má #pragma být předmětem rozšíření makra.

Řetězcový literál je vstupem do _Pragma. Vnější uvozovky a úvodní/koncové prázdné znaky se odeberou. \" je nahrazena " a \\ je nahrazena znakem \.

Kompilátor vydá upozornění, když zjistí pragma , že nerozpozná a pokračuje v kompilaci.

Kompilátory jazyka Microsoft C a C++ rozpoznávají následující pragma direktivy:

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

¹ Podporováno pouze kompilátorem jazyka C++.

Pragma direktivy a možnosti kompilátoru

Některé pragma direktivy poskytují stejné funkce jako možnosti kompilátoru. Při dosažení ve zdrojovém pragma kódu přepíše chování určené možností kompilátoru. Pokud jste například zadali /Zp8, můžete toto nastavení kompilátoru přepsat pro konkrétní části kódu pomocí 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
// ...

Klíčové slovo __pragma

Kompilátor také podporuje klíčové slovo specifické pro __pragma Microsoft, které má stejné funkce jako direktiva #pragma . Rozdíl je, že __pragma klíčové slovo je použitelné v definici makra. Direktiva #pragma není použitelná v definici makra, protože kompilátor interpretuje znak znaku čísla ('#') v direktivě jako operátor pro řetězcovou změnu (#).

Následující příklad kódu ukazuje, jak __pragma lze klíčové slovo použít v makrech. Tento kód je z hlavičky mfcdual.h v ukázce ACDUAL v části "Ukázky podpory kompilátoru modelu COM":

#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; \

Operátor _Pragma předběžného zpracování

_Pragma je podobný klíčovému slovu specifickému pro __pragma Microsoft. Byl zaveden do standardu C v jazyce C99 a standard C++ v jazyce C++11. Je k dispozici v jazyce C pouze v případech, kdy zadáte /std:c11 možnost nebo /std:c17 možnost. Pro jazyk C++ je k dispozici ve všech /std režimech, včetně výchozího nastavení.

Na rozdíl od #pragma, _Pragma umožňuje vložit pragma direktivy do definice makra. Řetězcový literál by měl být to, co byste jinak umístili za příkazem #pragma . Příklad:

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

Uvozovky a zpětné lomítka by měly být uvozovky, jak je znázorněno výše. Řetězec pragma , který není rozpoznán, se ignoruje.

Následující příklad kódu ukazuje, jak _Pragma lze klíčové slovo použít v makre podobném výrazu. Vytvoří direktivu pragma , která potlačí upozornění, když se výraz podmínky stane konstantní.

Definice makra používá do ... while(0) idiom pro makra s více příkazy, aby ji bylo možné použít jako jeden příkaz. Další informace najdete v tématu Víceřádkové makro jazyka C ve službě Stack Overflow. Příkaz _Pragma v příkladu se vztahuje pouze na řádek kódu, který následuje za ním.

// 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;
}

Viz také

Referenční dokumentace preprocesoru C/C++
Direktivy jazyka C pragma
Klíčová slova