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 :
loop1 |
||
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