Partager via


Directives pragma et mot clé _Pragma

Les directives pragma spécifient des fonctionnalités de compilateur spécifiques à l'ordinateur ou au système d'exploitation. Le mot clé __pragma, qui est spécifique au compilateur Microsoft, vous permet de coder des directives pragma dans des définitions de macros.

#pragma token-string
__pragma(token-string)

Notes

Chaque implémentation de C et C++ prend en charge des fonctionnalités spécifiques de son ordinateur hôte ou de son système d'exploitation. Certains programmes, par exemple, doivent exercer un contrôle précis des zones de mémoire où les données sont placées, ou contrôler la façon dont certaines fonctions reçoivent les paramètres. Les directives #pragma permettent à chaque compilateur d'offrir des fonctionnalités propres aux ordinateurs et aux systèmes d'exploitation tout en conservant une compatibilité globale avec les langages C et C++.

Les pragmas sont spécifiques à l'ordinateur ou au système d'exploitation, par définition, et sont généralement différents pour chaque compilateur. Les pragmas peuvent être utilisés dans les instructions conditionnelles pour fournir de nouvelles fonctionnalités de préprocesseur ou pour fournir des informations définies par l'implémentation au compilateur.

token-string est une série de caractères qui fournit à un compilateur spécifique l'instruction et les arguments, le cas échéant. Le signe dièse (#) doit être le premier caractère autre qu'un espace blanc sur la ligne contenant le pragma ; les espaces blancs peuvent séparer le signe dièse du mot "pragma". Après #pragma, saisissez un texte que le traducteur peut analyser en tant que jetons de prétraitement. L'argument de #pragma est soumis à une expansion macro.

Si le compilateur recherche un pragma qu'il ne reconnaît pas, il émet un avertissement et continue la compilation.

Les compilateurs Microsoft C et C++ reconnaissent les pragmas suivants :

alloc_text

auto_inline

bss_seg

check_stack

code_seg

comment

component

conform1

const_seg

data_seg

deprecated

detect_mismatch

fenv_access

float_control

fp_contract

function

hdrstop

include_alias

init_seg1

inline_depth

inline_recursion

intrinsic

loop1

make_public

managed

message

omp

once

optimize

pack

pointers_to_members1

pop_macro

push_macro

region, endregion

runtime_checks

section

setlocale

strict_gs_check

unmanaged

vtordisp1

warning

1. Pris en charge uniquement par le compilateur C++.

Pragmas et options du compilateur

Certains pragmas fournissent les mêmes fonctionnalités que les options du compilateur. Lorsqu'un pragma est rencontré dans le code source, il remplace le comportement spécifié par l'option du compilateur. Par exemple, si vous avez spécifié /Zp8, vous pouvez remplacer ce paramètre de compilateur pour les sections spécifiques de code par pack:

cl /Zp8 ...

<file> - packing is 8
// ...
#pragma pack(push, 1) - packing is now 1
// ...
#pragma pack(pop) - packing is 8
</file>

Mot clé __pragma()

Section spécifique à Microsoft

Le compilateur prend également en charge le mot clé __pragma, qui a les mêmes fonctionnalités que la directive #pragma, mais qui peut être utilisé inline dans une définition de macro. La directive #pragma ne peut pas être utilisée dans une définition de macro, car le compilateur interprète le signe dièse (#) de la directive en tant qu'opérateur de transformation en chaîne (#).

L'exemple de code suivant illustre l'utilisation du mot clé __pragma dans une macro. Ce code est extrait de l'en-tête mfcdual.h de l'exemple CDUAL dans « Exemples de prise en charge COM du compilateur » :

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

Fin de la section spécifique à Microsoft

Voir aussi

Référence

Pragmas C

Mots clés C++

Autres ressources

Référence du préprocesseur C/C++