Macros predefinidas

Artigo
02/17/2024

O compilador Microsoft C/C++ (MSVC) predefine determinadas macros de pré-processador dependendo da linguagem (C ou C++), o destino de compilação e as opções de compilador escolhidas.

O MSVC dá suporte às macros predefinidas do pré-processador exigidas pelas normas ANSI/ISO C99, C11 e C17 e as normas ISO C++14, C++17 e C++20. A implementação também dá suporte a várias outras macros de pré-processador específicas da Microsoft.

Algumas macros são definidas apenas para ambientes de compilação ou opções de compilador específicos. Exceto quando observado, as macros são definidas em uma unidade de tradução como se estivessem definidas como argumentos de opção do compilador /D. Quando definido, o pré-processador expande as macros seus valores especificados antes da compilação. As macros predefinidas não têm argumentos e não podem ser redefinidas.

Identificador predefinido padrão

O compilador dá suporte a esse identificador predefinido especificado pela ISO C99 e ISO C++11.

__func__ O nome não qualificado e não adornado da função de inclusão como uma matriz static const local de função de char.
```
void example(){
    printf("%s\n", __func__);
} // prints "example"
```

Macros predefinidas padrão

O compilador dá suporte a essas macros predefinidas especificadas pelas normas ISO C99, C11, C17 e ISO C++17.

__cplusplus Definida como um valor literal inteiro quando a unidade de tradução estiver compilada como C++. Caso contrário, é indefinido.
__DATE__ A data de compilação do arquivo de origem atual. A data é uma literal de cadeia de caracteres de tamanho constante no formato Mmm dd aaaa. O nome do mês Mmm é igual ao nome de mês abreviado gerado pela função de asctime da biblioteca do CRT (Runtime C). O primeiro caractere da data dd será um espaço se o valor for menor que 10. Essa macro está sempre definida.
__FILE__ O nome do arquivo de origem atual. __FILE__ expande para um literal de cadeia de caracteres. Para garantir que o caminho completo para o arquivo seja exibido, use /FC (Caminho completo do arquivo de código-fonte no diagnóstico). Essa macro está sempre definida.
__LINE__ Definida como o número de linha inteiro no arquivo de origem atual. O valor dessa macro pode ser alterado usando uma #line diretiva . O tipo integral do valor de __LINE__ pode variar dependendo do contexto. Essa macro está sempre definida.
__STDC__ Definida como 1 quando compilada como C e se a opção do compilador /Za estiver especificada. A partir do Visual Studio 2022 versão 17.2, ele é definido como 1 quando compilado como C e se a /std:c11 opção ou /std:c17 compilador for especificada. Caso contrário, é indefinido.
__STDC_HOSTED__ Definida como 1 se a implementação for uma implementação hospedada, a qual dê suporte a toda a biblioteca padrão necessária. Caso contrário, será definida como 0.
__STDC_NO_ATOMICS__ Definida como 1 se a implementação não der suporte à atômica padrão opcional. A implementação do MSVC define-a como 1 quando compilada como C e uma das opções /std C11 ou C17 estiver especificada.
__STDC_NO_COMPLEX__ Definida como 1 se a implementação não der suporte a números complexos padrão opcionais. A implementação do MSVC define-a como 1 quando compilada como C e uma das opções /std C11 ou C17 estiver especificada.
__STDC_NO_THREADS__ Definida como 1 se a implementação não der suporte a threads padrão opcionais. A implementação do MSVC define-a como 1 quando compilada como C e uma das opções /std C11 ou C17 estiver especificada.
__STDC_NO_VLA__ Definida como 1 se a implementação não der suporte a matrizes de comprimento variável padrão. A implementação do MSVC define-a como 1 quando compilada como C e uma das opções /std C11 ou C17 estiver especificada.
__STDC_VERSION__ Definida quando compilada como C e uma das opções /std C11 ou C17 estiver especificada. Ela se expande como 201112L para /std:c11 e como 201710L para /std:c17.
__STDCPP_DEFAULT_NEW_ALIGNMENT__ Quando /std:c17 ou mais recente for especificado, essa macro se expandirá para um literal size_t que tem o valor do alinhamento garantido por uma chamada para operator new sem reconhecimento de alinhamento. Alinhamentos maiores são passados para uma sobrecarga com reconhecimento de alinhamento, como operator new(std::size_t, std::align_val_t). Para obter mais informações, confira /Zc:alignedNew (alocação com excesso de alinhamento do C++17).
__STDCPP_THREADS__ Definida como 1 se e somente se um programa puder ter mais de um thread de execução e compilado como C++. Caso contrário, é indefinido.
__TIME__ O tempo de tradução da unidade de tradução pré-processada. A hora é um literal de cadeia de caracteres do formulário hh:mm:ss, o mesmo que o tempo retornado pela função asctime do CRT. Essa macro está sempre definida.

Macros predefinidas específicas da Microsoft

O MSVC suporta outras macros predefinidas:

__ATOM__ Definida como 1 quando a opção do compilador /favor:ATOM estiver definida e o destino do compilador for x86 ou x64. Caso contrário, é indefinido.
__AVX__ Definida como 1 quando as opções do compilador /arch:AVX, /arch:AVX2 ou /arch:AVX512 estiverem definidas e o destino do compilador for x86 ou x64. Caso contrário, é indefinido.
__AVX2__ Definida como 1 quando as opções do compilador /arch:AVX2 ou /arch:AVX512 estiverem definidas e o destino do compilador for x86 ou x64. Caso contrário, é indefinido.
__AVX512BW__ Definida como 1 quando a opção do compilador /arch:AVX512 estiver definida e o destino do compilador for x86 ou x64. Caso contrário, é indefinido.
__AVX512CD__ Definida como 1 quando a opção do compilador /arch:AVX512 estiver definida e o destino do compilador for x86 ou x64. Caso contrário, é indefinido.
__AVX512DQ__ Definida como 1 quando a opção do compilador /arch:AVX512 estiver definida e o destino do compilador for x86 ou x64. Caso contrário, é indefinido.
__AVX512F__ Definida como 1 quando a opção do compilador /arch:AVX512 estiver definida e o destino do compilador for x86 ou x64. Caso contrário, é indefinido.
__AVX512VL__ Definida como 1 quando a opção do compilador /arch:AVX512 estiver definida e o destino do compilador for x86 ou x64. Caso contrário, é indefinido.
_CHAR_UNSIGNED Definida como 1 se o tipo padrão char não estiver assinado. Esse valor será definido quando a opção do compilador /J (tipo de caractere padrão não assinado) estiver definida. Caso contrário, é indefinido.
__CLR_VER Definida como um literal inteiro que representa a versão do CLR (Common Language Runtime) usado para compilar o aplicativo. O valor é codificado no formulário Mmmbbbbb, em que M é a versão principal do runtime, mm é a versão secundária do runtime, e bbbbb é o número de build. __CLR_VER será definida se a opção do compilador /clrestiver definida. Caso contrário, é indefinido.
```
// clr_ver.cpp
// compile with: /clr
using namespace System;
int main() {
   Console::WriteLine(__CLR_VER);
}
```
_CONTROL_FLOW_GUARD Definida como 1 quando a opção do compilador /guard:cf (Habilitar a proteção do fluxo de controle) estiver definida. Caso contrário, é indefinido.

__COUNTER__ Expande para um literal inteiro que começa em 0. O valor será incrementado por 1 sempre que for usado em um arquivo de origem ou em cabeçalhos incluídos do arquivo de origem. __COUNTER__ lembra seu estado quando você usa cabeçalhos pré-compilados. Essa macro está sempre definida.

Este exemplo usa __COUNTER__ para atribuir identificadores exclusivos para três objetos diferentes do mesmo tipo. O construtor exampleClass aceita um inteiro como um parâmetro. Em main, o aplicativo declara três objetos do tipo exampleClass, usando __COUNTER__ como o parâmetro identificador exclusivo:

// macro__COUNTER__.cpp
// Demonstration of __COUNTER__, assigns unique identifiers to
// different objects of the same type.
// Compile by using: cl /EHsc /W4 macro__COUNTER__.cpp
#include <stdio.h>

class exampleClass {
    int m_nID;
public:
    // initialize object with a read-only unique ID
    exampleClass(int nID) : m_nID(nID) {}
    int GetID(void) { return m_nID; }
};

int main()
{
    // __COUNTER__ is initially defined as 0
    exampleClass e1(__COUNTER__);

    // On the second reference, __COUNTER__ is now defined as 1
    exampleClass e2(__COUNTER__);

    // __COUNTER__ is now defined as 2
    exampleClass e3(__COUNTER__);

    printf("e1 ID: %i\n", e1.GetID());
    printf("e2 ID: %i\n", e2.GetID());
    printf("e3 ID: %i\n", e3.GetID());

    // Output
    // ------------------------------
    // e1 ID: 0
    // e2 ID: 1
    // e3 ID: 2

    return 0;
}

__cplusplus_cli Definida como o valor literal inteiro 200406 quando compilada como C++ e uma opção do compilador /clr estiver definida. Caso contrário, é indefinido. Quando definido, o __cplusplus_cli é aplicado em toda a unidade de tradução.
```
// cplusplus_cli.cpp
// compile by using /clr
#include "stdio.h"
int main() {
   #ifdef __cplusplus_cli
      printf("%d\n", __cplusplus_cli);
   #else
      printf("not defined\n");
   #endif
}
```
__cplusplus_winrtDefinida como o valor literal inteiro 201009 quando compilada como C++ e a opção do compilador /ZW (Compilação do Windows Runtime) estiver definida. Caso contrário, é indefinido.
_CPPRTTI Definida como 1 se a opção do compilador /GR (Habilitar informações do tipo em tempo de execução) estiver definida. Caso contrário, é indefinido.
_CPPUNWINDDefinida como 1 se uma ou mais opções do compilador /GX (Habilitar tratamento de exceções), /clr (Compilação Common Language Runtime) ou /EH (Modelo de Tratamento de Exceção) estiverem definidas. Caso contrário, é indefinido.
_DEBUG Definida como 1 quando a opção do compilador /LDd, /MDd ou /MTd estiver definida. Caso contrário, é indefinido.
_DLL Definida como 1 quando a opção do compilador /MD ou /MDd (DLL com multithreaded) estiver definida. Caso contrário, é indefinido.

__FUNCDNAME__ Definida como um literal de cadeia de caracteres que contém o nome decorado da função de delimitação. A macro só é definida dentro de uma função. A macro __FUNCDNAME__ não será expandida se você usar a opção do compilador /EP ou /P.

Este exemplo usa as macros __FUNCDNAME__, __FUNCSIG__ e __FUNCTION__ para exibir informações de função.

// Demonstrates functionality of __FUNCTION__, __FUNCDNAME__, and __FUNCSIG__ macros
void exampleFunction()
{
    printf("Function name: %s\n", __FUNCTION__);
    printf("Decorated function name: %s\n", __FUNCDNAME__);
    printf("Function signature: %s\n", __FUNCSIG__);

    // Sample Output
    // -------------------------------------------------
    // Function name: exampleFunction
    // Decorated function name: ?exampleFunction@@YAXXZ
    // Function signature: void __cdecl exampleFunction(void)
}

__FUNCSIG__ Definida como um literal de cadeia de caracteres que contém a assinatura da função de delimitação. A macro só é definida dentro de uma função. A macro __FUNCSIG__ não será expandida se você usar a opção do compilador /EP ou /P. Quando compilada para um destino de 64 bits, a convenção de chamada é __cdecl por padrão. Para obter um exemplo de uso, confira a macro __FUNCDNAME__.
__FUNCTION__ Definida como um literal de cadeia de caracteres que contém o nome não decorado da função de delimitação. A macro só é definida dentro de uma função. A macro __FUNCTION__ não será expandida se você usar a opção do compilador /EP ou /P. Para obter um exemplo de uso, confira a macro __FUNCDNAME__.
_INTEGRAL_MAX_BITS Definida como o valor literal inteiro 64, o tamanho máximo (em bits) para um tipo integral não vetor. Essa macro está sempre definida.
```
// integral_max_bits.cpp
#include <stdio.h>
int main() {
    printf("%d\n", _INTEGRAL_MAX_BITS);
}
```
__INTELLISENSE__ Definida como 1 durante uma passagem do compilador do IntelliSense no IDE do Visual Studio. Caso contrário, é indefinido. Você pode usar essa macro para proteger o código que o compilador do IntelliSense não entender ou usá-la para alternar entre a compilação e o compilador do IntelliSense. Para obter mais informações, confira Dicas de solução de problemas para a lentidão do IntelliSense.
_ISO_VOLATILE Definida como 1 se a opção do compilador /volatile:iso estiver definida. Caso contrário, é indefinido.
_KERNEL_MODE Definida como 1 se a opção do compilador /kernel (Criar binário do modo Kernel) estiver definida. Caso contrário, é indefinido.
_M_AMD64 Definido como o valor literal inteiro 100 para compilações direcionadas a processadores x64 ou ARM64EC. Caso contrário, é indefinido.
_M_ARM Definida como o valor literal inteiro 7 para compilações direcionadas a processadores ARM. Indefinido para ARM64, ARM64EC e outros destinos.
_M_ARM_ARMV7VE Definida como 1 quando a opção do compilador /arch:ARMv7VE estiver definida para compilações direcionadas a processadores ARM. Caso contrário, é indefinido.
_M_ARM_FP Definida como um valor literal inteiro que indica qual opção do compilador /arch foi definida para destinos de processador ARM. Caso contrário, é indefinido.
- Um valor no intervalo 30-39, se nenhuma opção ARM /arch tiver sido especificada, indicando que a arquitetura padrão para ARM foi definida (VFPv3).
- Um valor no intervalo de 40 a 49 se /arch:VFPv4 estiver definido.
- Para obter mais informações, confira /arch(ARM).
_M_ARM64 Definido como 1 para compilações direcionadas ao ARM64. Caso contrário, é indefinido.
_M_ARM64EC Definido como 1 para compilações direcionadas ao ARM64EC. Caso contrário, é indefinido.
_M_CEE Definida como 001 se alguma opção do compilador /clr (Compilação Common Language Runtime) estiver definida. Caso contrário, é indefinido.
_M_CEE_PURE Preterida a partir do Visual Studio 2015. Definida como 001 se a opção do compilador /clr:pure estiver definida. Caso contrário, é indefinido.
_M_CEE_SAFE Preterida a partir do Visual Studio 2015. Definida como 001 se a opção do compilador /clr:safe estiver definida. Caso contrário, é indefinido.
_M_FP_CONTRACT Disponível a partir do Visual Studio 2022. Definida como 1 se a opção do compilador /fp:contract ou /fp:fast estiver definida. Caso contrário, é indefinido.
_M_FP_EXCEPT Definida como 1 se a opção do compilador /fp:except ou /fp:strict estiver definida. Caso contrário, é indefinido.
_M_FP_FAST Definida como 1 se a opção do compilador /fp:fast estiver definida. Caso contrário, é indefinido.
_M_FP_PRECISE Definida como 1 se a opção do compilador /fp:precise estiver definida. Caso contrário, é indefinido.
_M_FP_STRICT Definida como 1 se a opção do compilador /fp:strict estiver definida. Caso contrário, é indefinido.
_M_IX86 Definida como o valor literal inteiro 600 para compilações direcionadas a processadores x86. Essa macro não está definida para destinos de compilação x64 ou ARM.
_M_IX86_FP Definida como um valor literal inteiro que indica a opção do compilador /arch que foi definida ou o padrão. Essa macro está sempre definida quando o destino da compilação for um processador x86. Caso contrário, é indefinido. Quando definido, o valor é:
- 0 se a opção do compilador /arch:IA32 estiver definida.
- 1 se a opção do compilador /arch:SSE estiver definida.
- 2 se a opção do compilador /arch:SSE2, /arch:AVX, /arch:AVX2 ou /arch:AVX512 estiver definida. Esse valor será o padrão se uma opção do compilador /arch não tiver sido especificada. Quando /arch:AVX for especificada, a macro __AVX__ também será definida. Quando /arch:AVX2 for especificada, tanto __AVX__ quanto __AVX2__ também serão definidas. Quando /arch:AVX512 for especificada, __AVX__, __AVX2__, __AVX512BW__, __AVX512CD__, __AVX512DQ__, __AVX512F__ e __AVX512VL__ também serão definidas.
- Para obter mais informações, confira /arch (x86).
_M_X64 Definido como o valor literal inteiro 100 para compilações direcionadas a processadores x64 ou ARM64EC. Caso contrário, é indefinido.
_MANAGED Definida como 1 quando a opção do compilador /clr estiver definida. Caso contrário, é indefinido.
_MSC_BUILD Definida como um literal inteiro que contém o elemento do número de revisão do número de versão do compilador. O número de revisão é o último elemento do número de versão delimitado por período. Por exemplo, se o número de versão do compilador Microsoft C/C++ é 15.00.20706.01, a _MSC_BUILD macro é 1. Essa macro está sempre definida.
_MSC_EXTENSIONS Definida como 1 se a opção do compilador habilitada por padrão /Ze (Habilitar extensões de linguagem) estiver definida. Caso contrário, é indefinido.
_MSC_FULL_VER Definida como um literal inteiro que codifica os elementos principais, secundários e de número de build do número de versão do compilador. O número principal é o primeiro elemento do número de versão delimitado por ponto, o número secundário é o segundo elemento, e o número de compilação é o terceiro elemento.

Por exemplo, se a versão do compilador Microsoft C/C++ é 19.39.33519, _MSC_FULL_VER é 193933519. Insira cl /? na linha de comando para exibir o número de versão do compilador. Essa macro está sempre definida. Para obter mais informações sobre o controle de versão do compilador, consulte Controle de versão do compilador C++ e especificamente Versões de serviço começando com o Visual Studio 2017 para obter mais informações sobre o Visual Studio 2019 16.8, 16.9, 16.10 e 16.11, que exigem _MSC_FULL_VER diferenciá-los.
_MSC_VER Definida como um literal inteiro que codifica os elementos principais e secundários do número de versão do compilador. O número principal é o primeiro elemento do número de versão delimitado por ponto e o número secundário é o segundo elemento. Por exemplo, se o número de versão do compilador Microsoft C/C++ é 17.00.51106.1, o valor de _MSC_VER é 1700. Insira cl /? na linha de comando para exibir o número de versão do compilador. Essa macro está sempre definida.

Para testar versões do compilador ou atualizações em uma determinada versão do Visual Studio ou posterior, use o >= operador. Você pode usá-lo em uma diretiva condicional para comparar _MSC_VER a essa versão conhecida. Caso tenha várias versões mutuamente exclusivas a serem comparadas, solicite suas comparações na ordem decrescente do número de versão. Por exemplo, esse código verifica se há compiladores lançados no Visual Studio 2017 e posterior. Em seguida, ele verifica se há compiladores lançados no Visual Studio 2015 ou depois. Em seguida, ele verifica todos os compiladores lançados antes do Visual Studio 2015:
```
#if _MSC_VER >= 1910
// . . .
#elif _MSC_VER >= 1900
// . . .
#else
// . . .
#endif
```
Para obter mais informações sobre o Visual Studio 2019 16.8 e 16.9 e 16.10 e 16.11, que compartilham as mesmas versões principais e secundárias (e, portanto, têm o mesmo valor para _MSC_VER), consulte Versões de serviço começando com o Visual Studio 2017.

Para obter mais informações sobre o histórico de controle de versão do compilador e números de versão do compilador e as versões do Visual Studio às quais eles correspondem, consulte Controle de versão do compilador C++. Além disso, Visual C++ versão do compilador no blog da equipe Microsoft C++.
_MSVC_LANG Definida como um literal inteiro que especifica o padrão de linguagem C++ direcionado pelo compilador. Ela é definida apenas no código compilado como C++. A macro é o valor literal inteiro 201402L por padrão ou quando a opção do compilador /std:c++14 for especificada. A macro será definida como 201703L se a opção do compilador /std:c++17 for especificada. A macro será definida como 202002L se a opção do compilador /std:c++20 for especificada. Ela é definida como um valor mais alto e não especificado quando a opção /std:c++latest estiver especificada. Caso contrário, a macro será indefinida. A macro _MSVC_LANG e as opções do compilador /std (Especificar versão padrão do idioma) estão disponíveis a partir da do Visual Studio 2015 atualização 3.
__MSVC_RUNTIME_CHECKS Definida como 1 quando uma das opções do compilador /RTC estiver definida. Caso contrário, é indefinido.
_MSVC_TRADITIONAL:
- Disponível a partir do Visual Studio 2017 versão 15.8: definida como 0 quando a opção do compilador /experimental:preprocessor do modo de conformidade do pré-processador estiver definida. Definida como 1 por padrão ou quando a opção do compilador /experimental:preprocessor- estiver definida, para indicar que o pré-processador tradicional está em uso.
- Disponível a partir do Visual Studio 2019 versão 16.5: definida como 0 quando a opção do compilador /Zc:preprocessor do modo de conformidade do pré-processador estiver definida. Definida como 1 por padrão ou quando a opção do compilador /Zc:preprocessor- estiver definida, para indicar que o pré-processador tradicional está em uso (basicamente, /Zc:preprocessor substitui a /experimental:preprocessor preterida).
```
#if !defined(_MSVC_TRADITIONAL) || _MSVC_TRADITIONAL
// Logic using the traditional preprocessor
#else
// Logic using cross-platform compatible preprocessor
#endif
```
_MT Definida como 1 quando /MD ou /MDd (DLL com multithreaded) ou /MT ou /MTd (com multithreaded) estiver especificada. Caso contrário, é indefinido.
_NATIVE_WCHAR_T_DEFINED Definida como 1 quando a opção do compilador /Zc:wchar_t estiver definida. Caso contrário, é indefinido.
_OPENMP Definida como literal inteiro 200203, se a opção do compilador /openmp (Habilitar Suporte ao OpenMP 2.0) estiver definida. Esse valor representa a data da especificação de OpenMP implementada pelo MSVC. Caso contrário, é indefinido.
```
// _OPENMP_dir.cpp
// compile with: /openmp
#include <stdio.h>
int main() {
    printf("%d\n", _OPENMP);
}
```
_PREFAST_ Definida como 1 quando a opção do compilador /analyze estiver definida. Caso contrário, é indefinido.
__SANITIZE_ADDRESS__ Disponível a partir do Visual Studio 2019 versão 16.9. Definida como 1 quando a opção do compilador /fsanitize=address estiver definida. Caso contrário, é indefinido.
__TIMESTAMP__ Definida como um literal de cadeia de caracteres que contém a data e a hora da última modificação do arquivo de origem atual, no formulário abreviado de comprimento constante retornado pela função CRT asctime, por exemplo, Fri 19 Aug 13:32:58 2016. Essa macro está sempre definida.
_VC_NODEFAULTLIB Definida como 1 quando a opção do compilador /Zl (Omitir nome da biblioteca padrão) estiver definida. Caso contrário, é indefinido.
_WCHAR_T_DEFINED Definida como 1 quando a opção do compilador /Zc:wchar_t padrão estiver definida. A macro _WCHAR_T_DEFINED é definida, mas não tem valor se a opção do compilador /Zc:wchar_t- estiver definida e wchar_t for definida em um arquivo de cabeçalho do sistema incluído no projeto. Caso contrário, é indefinido.
_WIN32 Definida como 1 quando o destino de compilação for ARM de 32 bits, ARM de 64 bits, x86 ou x64. Caso contrário, é indefinido.
_WIN64 Definida como 1 quando o destino de compilação for ARM de 64 bits ou x64. Caso contrário, é indefinido.
_WINRT_DLLDefinida como 1 quando compilada como C++ e ambas as opções do compilador /ZW (compilação do Windows Runtime) e /LD ou /LDd estiverem definidas. Caso contrário, é indefinido.

Nenhuma macro de pré-processador que identifique a versão da biblioteca ATL ou MFC está predefinida pelo compilador. Os cabeçalhos da biblioteca ATL e MFC definem essas macros de versão internamente. Eles ficam indefinidos nas diretivas do pré-processador feitas antes que o cabeçalho necessário seja incluído.

_ATL_VER Definido como <atldef.h> um literal inteiro que codifica o número da versão ATL.
_MFC_VER Definido como <afxver_.h> um literal inteiro que codifica o número de versão do MFC.

Confira também

Macros (C/C++)
Operadores de pré-processador
Diretivas de pré-processador