Directives pragma et les __pragma_Pragma mot clé

Les directives Pragma 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 macro. 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(string-literal) // 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++.

Les directives Pragma sont spécifiques à l’ordinateur ou au système d’exploitation spécifiques 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 :

alloc_text
auto_inline
bss_seg
check_stack
code_seg
comment
component
conform¹
const_seg
data_seg
deprecated

detect_mismatch
endregion
fenv_access
float_control
fp_contract
function
hdrstop
include_alias
init_seg¹
inline_depth
inline_recursion

intrinsic
loop¹
make_public
managed
message
omp
once
optimize
pack
pointers_to_members¹
pop_macro

push_macro
region
runtime_checks
section
setlocale
strict_gs_check
system_header
unmanaged
vtordisp¹
warning

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

Directives pragma 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 les mot clé spécifiques __pragma à Microsoft, qui disposent des mêmes fonctionnalités que la #pragma directive. La différence est que la __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 l’mot clé __pragma 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

_Pragmaest similaire à la 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 l’mot clé _Pragma peut être utilisée 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