Pragmadiretivas e as __pragma palavras-chave e _Pragma

Pragma As diretivas especificam recursos do compilador específicos do computador ou do sistema operacional. 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

#pragmacadeia de caracteres de token
__pragma(cadeia de caracteres ) de token dois sublinhados principais - extensão específica da Microsoft
_Pragma(literal ) de cadeia de caracteres 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++.

Pragma As diretivas são específicas do computador ou do sistema operacional por definição e normalmente são diferentes para cada compilador. 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:

¹Com suporte apenas do compilador C++.

Pragma Diretivas 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