Direktivy Pragma a klíčová slova `__pragma` a `_Pragma`

Direktivy Pragma určují funkce kompilátoru specifické pro 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

#pragma token-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++.

Direktivy Pragma 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:

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

Direktivy Pragma 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

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-11-07

Sdílet prostřednictvím

Direktivy Pragma a klíčová slova __pragma a _Pragma