Diretivas Pragma e a palavra-chave __Pragma
As políticas de pragma especificam recursos de compilador específicos do computador ou da operação. A palavra-chave __pragma, que é específica do compilador da Microsoft, permite codificar políticas de pragma dentro de definições de macro.
#pragma token-string
__pragma(token-string)
Comentários
Cada implementação de C e C++ oferece suporte a alguns recursos exclusivos para seu computador host ou sistema operacional. Alguns programas, por exemplo, devem exercitar o controle preciso sobre as áreas de memória onde os dados são colocados ou para controlar a maneira como determinadas funções recebem parâmetros. As políticas #pragma proporcionam uma maneira para que cada compilador ofereça recursos específicos de máquinas e sistemas operacionais enquanto mantém a compatibilidade geral com as linguagens C e C++.
Os pragmas são específicos do computador ou do sistema operacional por definição e normalmente são diferentes para todos os compiladores. Os pragmas podem ser usados em instruções condicionais para fornecerem nova funcionalidade de pré-processador ou para fornecerem informações definidas pela implementação ao compilador.
token-string é uma série de caracteres que oferece uma instrução de compilador específica e argumentos, se houver. A tecla de cerquilha (#) deve ser o primeiro caractere que não seja espaço em branco na linha que contém o pragma; os caracteres de espaço em branco podem separar a tecla de cerquilha da palavra “pragma”. Depois de #pragma, escreva qualquer texto que o conversor possa analisar, como tokens de pré-processamento. O argumento para #pragma está sujeito a uma expansão de macro.
Se o compilador encontrar um pragma que não reconhecer, ele emitirá um aviso e continuará a compilação.
Os compiladores C e C++ da Microsoft reconhecem os seguintes pragmas:
loop1 |
||
1. Com suporte apenas do compilador C++.
Pragmas e opções do compilador
Alguns pragmas oferecem a mesma funcionalidade que as opções de compilador. Quando um pragma está localizado no código-fonte, ele substitui o comportamento especificado pela opção do compilador. Por exemplo, se você especificou /Zp8, pode substituir essa configuração do compilador para seções específicas do código com pack:
cl /Zp8 ...
<file> - packing is 8
// ...
#pragma pack(push, 1) - packing is now 1
// ...
#pragma pack(pop) - packing is 8
</file>
A palavra-chave __pragma()
específica da Microsoft
O compilador também oferece suporte à palavra-chave __pragma, que tem a mesma funcionalidade que a política #pragma, mas que pode ser usada integrada a uma definição de macro. A política #pragma não pode ser usada em uma definição de macro porque o compilador interpreta o caractere de tecla de cerquilha ("#") na política para ser o operador stringizing (#).
O exemplo de código a seguir demonstra como a palavra-chave __pragma pode ser usada em uma macro. Esse código foi retirado do cabeçalho mfcdual.h no exemplo ACDUAL em "Exemplos de suporte a COM de compilador":
#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; \
Fim de específico da Microsoft