Directives pragma et le mot clé de __Pragma
Pragma spécifient les fonctionnalités du compilateur spécifique machine ou d'exploitation.Le __pragma mot clé, qui est spécifique au compilateur Microsoft, vous permet de code pragma directives au sein de définitions de macros.
#pragma token-string
__pragma(token-string)
Notes
Chaque implémentation de c et C++ prend en charge certaines fonctionnalités propres à son système d'exploitation ou la machine hôte.Certains programmes, doivent, par exemple, exercer un contrôle précis sur les zones de mémoire dans laquelle les données sont placées ou pour contrôler la façon dont certaine fonctions reçoivent des paramètres.Le #pragma directives offrent un moyen pour que chaque compilateur offrent des fonctionnalités spécifiques de machine et de système d'exploitation tout en conservant une compatibilité totale avec les langages c et C++.
Pragmas sont propre ordinateur ou système d'exploitation par définition et habituellement différentes pour chaque compilation.Pragmas utilisable dans des instructions conditionnelles, pour fournir de nouvelles fonctionnalités de préprocesseur, ou pour fournir des informations définies par l'implémentation du compilateur.
Le token-string est une série de caractères qui donne une instruction du compilateur spécifique 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 qui contient le pragma ; caractères d'espace blanc peuvent séparer le dièse et le mot « pragma ».Suite de #pragma, écrire du texte que le traducteur peut analyser que les jetons de prétraitement.L'argument de #pragma est soumis à une expansion macro.
Si le compilateur trouve 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.Prise 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 substitue le comportement spécifié par l'option du compilateur.Par exemple, si vous avez spécifié /Zp8, vous pouvez substituer ce paramètre du compilateur pour les sections spécifiques du code avec pack:
cl /Zp8 ...
<file> - packing is 8
// ...
#pragma pack(push, 1) - packing is now 1
// ...
#pragma pack(pop) - packing is 8
</file>
Le mot clé __pragma()
Microsoft spécifique
Le compilateur prend également en charge la __pragma mot clé, qui possède la même fonctionnalité que la #pragma la directive, mais peuvent être utilisé en ligne dans une définition de macro.Le #pragma directive ne peut pas être utilisée dans une définition de macro car le compilateur interprète le signe dièse ('#') dans la directive à la opérateur d'enchaînement (#).
L'exemple de code suivant montre comment les __pragma mot-clé peut être utilisé dans une macro.Ce code est extraite de l'en-tête de mfcdual.h dans l'exemple ACDUAL 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; \
Microsoft fin spécifique