Diretivas do Pragma e as palavras-chave do __pragma e _Pragma
As diretivas de pragma especificam recursos de compilador específicos do computador ou do sistema. Uma linha que começa com #pragma especifica uma diretiva pragma. A palavra-chave __pragma específica da Microsoft permite que você codifique as diretivas pragma nas definições de macro. O operador de pré-processador padrão _Pragma, introduzido em C99 e adotado pelo C++11, é semelhante.
Sintaxe
#pragmatoken-string
__pragma(token-string)// dois sublinhados principais - extensão específica da Microsoft
_Pragma(string-literal)// C99
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 executar o controle preciso no local de dados na memória ou controlar a forma como determinadas funções recebem parâmetros. As diretivas #pragma oferecem uma forma para que cada compilador disponibilize recursos específicos de máquinas e sistemas operacionais enquanto mantém a compatibilidade geral com as linguagens C e C++.
As diretivas pragmas são específicas do computador ou do sistema operacional por definição e normalmente são diferentes para todos os compiladores. Um pragma pode ser usado em uma diretiva condicional para fornecer uma nova funcionalidade de pré-processador. Ou use uma para fornecer informações definidas pela implementação ao compilador.
O token-string é uma série de caracteres que representam uma instrução de compilador específica e argumentos, se houver. O sinal de número (#) deve ser o primeiro caractere de espaço não em branco na linha que contém pragma. Caracteres de espaço em branco podem separar o sinal de número e a palavra "pragma". Depois de #pragma, escreva qualquer texto que o tradutor possa analisar, como tokens de pré-processamento. O argumento para #pragma está sujeito a uma expansão de macro.
O string-literal é a entrada para _Pragma. Aspas externas e o espaço em branco à esquerda/à direita são removidos. \" é substituído por " e \\ é substituído por \.
O compilador emite um aviso quando encontra um pragma que não reconhece e continua a compilação.
Os compiladores C e C++ da Microsoft reconhecem as seguintes diretivas pragma:
alloc_text
auto_inline
bss_seg
check_stack
code_seg
comment
component
conform1
const_seg
data_seg
deprecated
1Com suporte apenas do compilador C++.
Diretivas pragma e opções do compilador
Algumas diretivas pragma oferecem a mesma funcionalidade que as opções de compilador. Quando um pragma é atingido 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 some_file.cpp
// some_file.cpp - packing is 8
// ...
#pragma pack(push, 1) - packing is now 1
// ...
#pragma pack(pop) - packing is 8 again
// ...
A palavra-chave __pragma
O compilador também é compatível com a palavra-chave __pragma específica da Microsoft,, que tem a mesma funcionalidade que a diretiva #pragma. A diferença é que a palavra-chave __pragma é utilizada embutida em uma definição de macro. A diretiva #pragma não pode ser usada em uma definição de macro porque o compilador interpreta o caractere de sinal de número ("#") na diretiva como operador stringizing (#).
O exemplo de código a seguir demonstra como a palavra-chave __pragma pode ser usada em uma macro. Esse código é 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; \
O operador de pré-processamento _Pragma
_Pragma é semelhante à palavra-chave __pragma específica da Microsoft. Foi introduzido no padrão C em C99 e no padrão C++ no C++11. Ele está disponível em C somente quando você especifica a opção /std:c11 ou /std:c17. Para C++, ele está disponível em todos os modos /std, incluindo o padrão.
Ao contrário #pragma, _Pragma permite que você coloque as diretivas pragma em uma definição de macro. O literal de cadeia de caracteres deve ser o que você colocaria após uma instrução #pragma. Por exemplo:
#pragma message("the #pragma way")
_Pragma ("message( \"the _Pragma way\")")
Aspas e barras invertidas devem ser escapadas, conforme mostrado acima. Uma string pragma que não é reconhecida é ignorada.
O exemplo de código a seguir demonstra como a palavra-chave _Pragma poderia ser usada em uma macro como assert. Ele cria uma diretiva pragma que suprime um aviso quando a expressão de condição é constante.
A definição de macro usa o idioma do ... while(0) para macros de várias instruções para que possa ser usada como se fosse uma instrução. Para obter mais informações, consulte a macro de várias linhas C no Stack Overflow. A instrução _Pragmano exemplo só se aplica à linha de código seguinte.
// 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;
}
Confira também
Referência de pré-processador C/C++
Diretivas C pragma
Palavras-chave
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de