Pragma directives et mots __pragma _Pragma clés

Pragma les directives spécifient des fonctionnalités de compilateur spécifiques au système d’exploitation ou spécifiques au système d’exploitation. Ligne qui commence par #pragma spécifier une pragma directive. Le mot clé spécifique à __pragma Microsoft vous permet de coder pragma des directives dans les définitions de macros. L’opérateur de préprocesseur standard _Pragma , introduit en C99 et adopté par C++11, est similaire.

Syntaxe

#pragmatoken-string
__pragma(token-string ) deux traits de soulignement principaux - Extension spécifique à Microsoft
_Pragma(littéral ) de chaîne C99

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 sur l’emplacement des données en mémoire, ou contrôler la façon dont certaines fonctions reçoivent des paramètres. Les #pragma directives offrent un moyen pour chaque compilateur d’offrir des fonctionnalités spécifiques aux ordinateurs et au système d’exploitation, tout en conservant la compatibilité globale avec les langages C et C++.

Pragma les directives sont spécifiques au système d’exploitation ou spécifiques au système d’exploitation par définition, et sont généralement différentes pour chaque compilateur. Un pragma peut être utilisé dans une directive conditionnelle pour fournir de nouvelles fonctionnalités de préprocesseur. Vous pouvez également en utiliser un pour fournir des informations définies par l’implémentation au compilateur.

La chaîne de jeton est une série de caractères représentant une instruction et des arguments de compilateur spécifiques, le cas échéant. Le signe numérique (#) doit être le premier caractère non blanc sur la ligne qui contient le pragma. Les caractères d’espace blanc peuvent séparer le signe numérique et le mot «pragma ». Ensuite #pragma, écrivez tout texte que le traducteur peut analyser en tant que jetons de prétraitement. L’argument à prendre en compte est soumis à #pragma l’expansion des macros.

Le littéral de chaîne est l’entrée à _Pragma. Les guillemets externes et les espaces blancs de début/fin sont supprimés. \" est remplacé par " et \\ est remplacé par \.

Le compilateur émet un avertissement lorsqu’il détecte qu’il pragma ne reconnaît pas et continue la compilation.

Les compilateurs Microsoft C et C++ reconnaissent les directives suivantes pragma :

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

Pragma directives et options du compilateur

Certaines pragma directives fournissent les mêmes fonctionnalités que les options du compilateur. Lorsqu’un pragma code source est atteint, 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 des sections spécifiques du code par 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
// ...

Le mot clé __pragma

Le compilateur prend également en charge le mot clé spécifique à __pragma Microsoft, qui a les mêmes fonctionnalités que la #pragma directive. La différence est que le __pragma mot clé est utilisable inline dans une définition de macro. La #pragma directive n’est pas utilisable dans une définition de macro, car le compilateur interprète le caractère de signe numérique ('#') dans la directive comme opérateur de chaîne (#).

L’exemple de code suivant montre comment le __pragma mot clé peut être utilisé dans une macro. Ce code est extrait de l’en-tête mfcdual.h dans l’exemple ACDUAL dans « Compiler COM Support Samples » :

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

Opérateur _Pragma de prétraitement

_Pragma est similaire au mot clé spécifique __pragma à Microsoft. Il a été introduit dans la norme C en C99 et la norme C++ en C++11. Il est disponible en C uniquement lorsque vous spécifiez l’option ou l’option/std:c11./std:c17 Pour C++, il est disponible dans tous les /std modes, y compris la valeur par défaut.

Contrairement #pragmaà , _Pragma vous pouvez placer pragma des directives dans une définition de macro. Le littéral de chaîne doit être ce que vous devez sinon placer à la suite d’une #pragma instruction. Par exemple :

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

Les guillemets et les barres obliques inverses doivent être placés dans une séquence d’échappement, comme indiqué ci-dessus. Une pragma chaîne qui n’est pas reconnue est ignorée.

L’exemple de code suivant montre comment le _Pragma mot clé peut être utilisé dans une macro de type assert. Il crée une pragma directive qui supprime un avertissement lorsque l’expression de condition est constante.

La définition de macro utilise l’idiome do ... while(0) pour les macros à plusieurs instructions afin qu’elle puisse être utilisée comme s’il s’agissait d’une instruction. Pour plus d’informations, consultez la macro multiligne C sur Stack Overflow. L’instruction _Pragma de l’exemple s’applique uniquement à la ligne de code qui la suit.

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

Voir aussi

Informations de référence sur le préprocesseur C/C++
Directives C pragma
Mots clés