Partilhar via

Macros predefinidas

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

O MSVC suporta as macros de pré-processador predefinidas exigidas pelos padrões ANSI/ISO C99, C11 e C17 e pelos padrões ISO C++14, C++17 e C++20. A implementação também suporta várias macros de pré-processador mais específicas da Microsoft.

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

Identificador padrão predefinido

O compilador suporta este identificador predefinido especificado pela ISO C99 e ISO C++11.

  • __func__ O nome não qualificado e não adornado da função de delimitação como uma matriz de const estática de função local de char.

    void example()
{
    printf("%s\n", __func__);
} // prints "example"

Macros predefinidas padrão

O compilador suporta essas macros predefinidas especificadas pelos padrões ISO C99, C11, C17 e ISO C++17.

  • __cplusplus Definido como um valor literal inteiro quando a unidade de tradução é compilada como C++. Caso contrário, indefinido.

  • __DATE__ A data de compilação do arquivo de origem atual. A data é uma cadeia de caracteres de comprimento constante literal da forma Mmm dd aa. O nome do mês Mmm é o mesmo que o nome abreviado do mês gerado pela função asctime C Runtime Library (CRT). O primeiro caractere de data dd é um espaço se o valor for menor que 10. Esta macro é sempre definida.

  • __FILE__ O nome do arquivo de origem atual. __FILE__ expande para uma cadeia de caracteres literal. Para garantir que o caminho completo para o arquivo seja exibido, use /FC (Caminho completo do arquivo de código-fonte no diagnóstico). Esta macro é sempre definida.

  • __LINE__ Definido 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 pode variar dependendo do __LINE__ contexto. Esta macro é sempre definida.

  • __STDC__ Definido como 1 quando compilado como C e se a opção do /Za compilador for especificada. A partir do Visual Studio 2022 versão 17.2, ele é definido como 1 quando compilado como C e se a opção do /Zc:__STDC__ compilador for especificada. Caso contrário, indefinido.

  • __STDC_HOSTED__ Definido como 1 se a implementação for uma implementação hospedada, que suporte toda a biblioteca padrão necessária. Caso contrário, definido como 0.

  • __STDC_NO_ATOMICS__ Definido como 1 se a implementação não suportar átomos padrão opcionais. A implementação MSVC define-o como 1 quando compilado como C e uma das /std opções C11 ou C17 é especificada.

  • __STDC_NO_COMPLEX__ Definido como 1 se a implementação não suportar números complexos padrão opcionais. A implementação MSVC define-o como 1 quando compilado como C e uma das /std opções C11 ou C17 é especificada.

  • __STDC_NO_THREADS__ Definido como 1 se a implementação não suportar threads padrão opcionais. A implementação MSVC define-o como 1 quando compilado como C e uma das /std opções C11 ou C17 é especificada.

  • __STDC_NO_VLA__ Definido como 1 se a implementação não suportar matrizes de comprimento variável padrão. A implementação MSVC define-o como 1 quando compilado como C e uma das /std opções C11 ou C17 é especificada.

  • __STDC_VERSION__ Definido quando compilado como C e uma das /std opções C11 ou C17 é especificada. Ele se expande para 201112L para /std:c11, e 201710L para /std:c17.

  • __STDCPP_DEFAULT_NEW_ALIGNMENT__ Quando /std:c17 ou mais tarde é especificado, essa macro se expande para um size_t literal que tem o valor do alinhamento garantido por uma chamada para alinhamento sem reconhecimento operator new. 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, consulte /Zc:alignedNew (C++17 over-aligned allocation).

  • __STDCPP_THREADS__ Definido como 1 se e somente se um programa pode 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. O tempo é uma cadeia de caracteres literal da forma hh:mm:ss, o mesmo que o tempo retornado pela função asctime CRT. Esta macro é sempre definida.

Macros predefinidas específicas da Microsoft

MSVC suporta outras macros predefinidas:

  • __ARM_ARCH Definido como um literal inteiro que representa a versão da arquitetura ARM. O valor é definido como 8 para a arquitetura Armv8-A. Para 8.1 e seguintes, o valor é dimensionado para versões secundárias, como X.Y, usando a fórmula X * 100 + Y, conforme definido pela extensão de linguagem ARM C. Por exemplo, para Armv8.1, __ARM_ARCH é 8 * 100 + 1 ou 801. Para definir a versão da arquitetura ARM, consulte /arch (ARM64). Esta macro foi introduzida no Visual Studio 2022 versão 17.10.

  • __ATOM__ Definido como 1 quando a opção do /favor:ATOM compilador é definida e o destino do compilador é x86 ou x64. Caso contrário, indefinido.

  • __AVX__Definido como 1 quando as opções , /arch:AVX/arch:AVX2, /arch:AVX512, /arch:AVX10.1, ou /arch:AVX10.2 compilador são definidas e o destino do compilador é x86 ou x64. Caso contrário, indefinido.

  • __AVX2__ Definido como 1 quando a /arch:AVX2opção , /arch:AVX512, /arch:AVX10.1, ou /arch:AVX10.2 compilador é definida e o destino do compilador é x86 ou x64. Caso contrário, indefinido.

  • __AVX512BW__ Definido como 1 quando a /arch:AVX512opção , /arch:AVX10.1ou /arch:AVX10.2 compilador é definida e o destino do compilador é x86 ou x64. Caso contrário, indefinido.

  • __AVX512CD__ Definido como 1 quando a /arch:AVX512opção , /arch:AVX10.1ou /arch:AVX10.2 compilador é definida e o destino do compilador é x86 ou x64. Caso contrário, indefinido.

  • __AVX512DQ__ Definido como 1 quando a /arch:AVX512opção , /arch:AVX10.1ou /arch:AVX10.2 compilador é definida e o destino do compilador é x86 ou x64. Caso contrário, indefinido.

  • __AVX512F__ Definido como 1 quando a /arch:AVX512opção , /arch:AVX10.1ou /arch:AVX10.2 compilador é definida e o destino do compilador é x86 ou x64. Caso contrário, indefinido.

  • __AVX512VL__ Definido como 1 quando a /arch:AVX512opção , /arch:AVX10.1ou /arch:AVX10.2 compilador é definida e o destino do compilador é x86 ou x64. Caso contrário, indefinido.

  • __AVX10_VER__ Definido como um inteiro que representa a versão do AVX10 quando a /arch:AVX10.1 opção ou /arch:AVX10.2 compilador é definida e o destino do compilador é x86 ou x64. Caso contrário, indefinido.

  • _CHAR_UNSIGNED Definido como 1 se o tipo padrão char não estiver assinado. Esse valor é definido quando a /J opção de compilador (Default char type is unsigned) é definida. Caso contrário, indefinido.

  • __CLR_VER Definido como um literal inteiro que representa a versão do Common Language Runtime (CLR) usado para compilar o aplicativo. O valor é codificado no formato Mmmbbbbb, onde M é a versão principal do tempo de execução, mm é a versão secundária do tempo de execução e bbbbb é o número da compilação. __CLR_VER é definido se a opção do /clr compilador estiver definida. Caso contrário, indefinido.

    // clr_ver.cpp
// compile with: /clr
using namespace System;
int main() {
   Console::WriteLine(__CLR_VER);
}

  • _CONTROL_FLOW_GUARD Definido como 1 quando a /guard:cf opção de compilador (Enable Control Flow Guard) é definida. Caso contrário, indefinido.

  • __COUNTER__ Expande para um literal inteiro que começa em 0. O valor aumenta em 1 sempre que é 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. Esta macro é sempre definida.

    Este exemplo usa __COUNTER__ para atribuir identificadores exclusivos a três objetos diferentes do mesmo tipo. O exampleClass construtor usa um inteiro como parâmetro. No main, o aplicativo declara três objetos do tipo exampleClass, usando __COUNTER__ como 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 Definido como o valor literal inteiro 200406 quando compilado como C++ e uma opção de /clr compilador é definida. Caso contrário, indefinido. Quando definido, __cplusplus_cli está em vigor 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_winrtDefinido como o valor literal inteiro 201009 quando compilado como C++ e a opção de compilador (Compilação do/ZW Tempo de Execução do Windows) é definida. Caso contrário, indefinido.

  • _CPPRTTI Definido como 1 se a /GR opção do compilador (Enable Run-Time Type Information) estiver definida. Caso contrário, indefinido.

  • _CPPUNWINDDefinido como 1 se uma ou mais opções de compilador (/GXEnable Exception Handling),/clr (Common Language Runtime Compilation) ou /EH (Exception Handling Model) estiverem definidas. Caso contrário, indefinido.

  • _DEBUG Definido como 1 quando a /LDdopção , /MDd, ou /MTd compilador é definida. Caso contrário, indefinido.

  • _DLL Definido como 1 quando a /MD opção de compilador ou /MDd (Multithreaded DLL) é definida. Caso contrário, indefinido.

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

    Este exemplo usa as __FUNCDNAME__macros , __FUNCSIG__e para __FUNCTION__ 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__ Definido como um literal de cadeia de caracteres que contém a assinatura da função de delimitação. A macro é definida apenas dentro de uma função. A __FUNCSIG__ macro não será expandida se você usar a /EP opção ou /P compilador. Quando compilada para um destino de 64 bits, a convenção de chamada é __cdecl por padrão. Para obter um exemplo de uso, consulte a __FUNCDNAME__ macro.

  • __FUNCTION__ Definido como um literal de cadeia de caracteres que contém o nome não decorado da função de delimitação. A macro é definida apenas dentro de uma função. A __FUNCTION__ macro não será expandida se você usar a /EP opção ou /P compilador. Para obter um exemplo de uso, consulte a __FUNCDNAME__ macro.

  • _INTEGRAL_MAX_BITS Definido como o valor literal inteiro 64, o tamanho máximo (em bits) para um tipo integral não vetorial. Esta macro é sempre definida.

    // integral_max_bits.cpp
#include <stdio.h>
int main() {
    printf("%d\n", _INTEGRAL_MAX_BITS);
}

  • __INTELLISENSE__ Definido como 1 durante uma passagem do compilador IntelliSense no IDE do Visual Studio. Caso contrário, indefinido. Você pode usar essa macro para proteger o código que o compilador IntelliSense não entende ou usá-lo para alternar entre a compilação e o compilador IntelliSense. Para obter mais informações, consulte Dicas de solução de problemas para lentidão do IntelliSense.

  • _ISO_VOLATILE Definido como 1 se a opção do /volatile:iso compilador estiver definida. Caso contrário, indefinido.

  • _KERNEL_MODE Definido como 1 se a /kernel opção de compilador (Create Kernel Mode Binary) estiver definida. Caso contrário, indefinido.

  • _M_AMD64 Definido como o valor literal inteiro 100 para compilações destinadas a processadores x64 ou ARM64EC. Caso contrário, indefinido.

  • _M_ARM Definido como o valor literal inteiro 7 para compilações destinadas a processadores ARM. Indefinido para ARM64, ARM64EC e outros destinos.

  • _M_ARM_ARMV7VE Definido como 1 quando a opção do /arch:ARMv7VE compilador é definida para compilações destinadas a processadores ARM. Caso contrário, indefinido.

  • _M_ARM_FP Definido como um valor literal inteiro que indica qual /arch opção do compilador foi definida para destinos de processador ARM. Caso contrário, indefinido.

    • Um valor no intervalo 30-39 se nenhuma /arch opção ARM foi especificada, indicando que a arquitetura padrão para ARM foi definida (VFPv3).

    • Um valor no intervalo 40-49 se /arch:VFPv4 foi definido.

    • Para obter mais informações, consulte /arch (ARM).

  • _M_ARM64 Definido como 1 para compilações que visam ARM64. Caso contrário, indefinido.

  • _M_ARM64EC Definido como 1 para compilações que visam ARM64EC. Caso contrário, indefinido.

  • _M_CEE Definido como 001 se qualquer /clr opção de compilador (Common Language Runtime Compilation) estiver definida. Caso contrário, indefinido.

  • _M_CEE_PURE Preterido a partir do Visual Studio 2015. Definido como 001 se a opção do /clr:pure compilador estiver definida. Caso contrário, indefinido.

  • _M_CEE_SAFE Preterido a partir do Visual Studio 2015. Definido como 001 se a opção do /clr:safe compilador estiver definida. Caso contrário, indefinido.

  • _M_FP_CONTRACT Disponível a partir do Visual Studio 2022. Definido como 1 se a /fp:contract opção ou /fp:fast compilador estiver definida. Caso contrário, indefinido.

  • _M_FP_EXCEPT Definido como 1 se a /fp:except opção ou /fp:strict compilador estiver definida. Caso contrário, indefinido.

  • _M_FP_FAST Definido como 1 se a opção do /fp:fast compilador estiver definida. Caso contrário, indefinido.

  • _M_FP_PRECISE Definido como 1 se a opção do /fp:precise compilador estiver definida. Caso contrário, indefinido.

  • _M_FP_STRICT Definido como 1 se a opção do /fp:strict compilador estiver definida. Caso contrário, indefinido.

  • _M_IX86 Definido como o valor literal inteiro 600 para compilações destinadas a processadores x86. Esta macro não está definida para destinos de compilação x64 ou ARM.

  • _M_IX86_FP Definido como um valor literal inteiro que indica a opção do /arch compilador que foi definida ou o padrão. Esta macro é sempre definida quando o destino da compilação é um processador x86. Caso contrário, indefinido. Quando definido, o valor é:

    • 0 se a opção do /arch:IA32 compilador foi definida.

    • 1 se a opção do /arch:SSE compilador foi definida.

    • 2 se a /arch:SSE2opção , /arch:AVX, /arch:AVX2, /arch:AVX512, /arch:AVX10.1, ou /arch:AVX10.2 compilador foi definida. Esse valor é o padrão se uma /arch opção de compilador não foi especificada. Quando /arch:AVX é especificada, a macro __AVX__ também é definida. Quando /arch:AVX2 é especificado, ambos __AVX__ e __AVX2__ também são definidos. Quando /arch:AVX512 é especificado, __AVX__, , __AVX2____AVX512BW__, __AVX512CD__, __AVX512DQ__, , __AVX512F__e __AVX512VL__ também são definidos. Quando /arch:AVX10.1 ou /arch:AVX10.2 é especificado, __AVX__, , __AVX512BW____AVX2__, __AVX512CD__, __AVX512DQ__, , __AVX512F__e __AVX10_VER____AVX512VL__ também são definidos.

    • Para obter mais informações, consulte /arch (x86).

  • _M_X64 Definido como o valor literal inteiro 100 para compilações destinadas a processadores x64 ou ARM64EC. Caso contrário, indefinido.

  • _MANAGED Definido como 1 quando a opção do /clr compilador é definida. Caso contrário, indefinido.

  • _MSC_BUILD Definido como um literal inteiro que contém o elemento de 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++ for 15.00.20706.01, a _MSC_BUILD macro será 1. Esta macro é sempre definida.

  • _MSC_EXTENSIONS Definido como 1 se a opção de compilador on-by-default /Ze (Enable Language Extensions) estiver definida. Caso contrário, indefinido.

  • _MSC_FULL_VER Definido como um literal inteiro que codifica os elementos major, minor e build number do número de versão do compilador. O número principal é o primeiro elemento do número de versão delimitado por período, o número menor é o segundo elemento e o número de compilação é o terceiro elemento.

    Por exemplo, se a versão do compilador Microsoft C/C++ for 19.39.33519, _MSC_FULL_VER será 193933519. Entre cl /? na linha de comando para visualizar o número da versão do compilador. Esta macro é 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 Definido como um literal inteiro que codifica os elementos numéricos principais e secundários do número de versão do compilador. O número maior é o primeiro elemento do número de versão delimitado por período e o número menor é o segundo elemento. Por exemplo, se o número de versão do compilador Microsoft C/C++ for 17.00.51106.1, o valor de _MSC_VER é 1700. Entre cl /? na linha de comando para visualizar o número da versão do compilador. Esta macro é sempre definida.

    Para testar versões ou atualizações do compilador 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 com essa versão conhecida. Se você tiver várias versões mutuamente exclusivas para comparar, ordene suas comparações em ordem decrescente do número da 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 após ele. 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 os 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++ Compiler Version no blog da equipe do Microsoft C++.

  • _MSVC_LANG Definido como um literal inteiro que especifica o padrão de linguagem C++ direcionado pelo compilador. Somente o código compilado como C++ o define. A macro é o valor 201402L literal inteiro por padrão ou quando a opção do /std:c++14 compilador é especificada. A macro é definida como 201703L se a opção do /std:c++17 compilador for especificada. A macro é definida como 202002L se a opção do /std:c++20 compilador for especificada. Ele é definido como um valor mais alto e não especificado quando a /std:c++latest opção é especificada. Caso contrário, a macro será indefinida. As _MSVC_LANG opções de macro e /std compilador (Especificar versão padrão de idioma) estão disponíveis a partir do Visual Studio 2015 Atualização 3.

  • __MSVC_RUNTIME_CHECKS Definido como 1 quando uma das opções do /RTC compilador é definida. Caso contrário, indefinido.

  • _MSVC_TRADITIONAL:

    • Disponível a partir do Visual Studio 2017 versão 15.8: definido como 0 quando a opção de compilador do modo /experimental:preprocessor de conformidade do pré-processador é definida. Definido como 1 por padrão, ou quando a opção do /experimental:preprocessor- compilador é definida, para indicar que o pré-processador tradicional está em uso.
    • Disponível a partir do Visual Studio 2019 versão 16.5: Definido como 0 quando a opção de compilador do modo /Zc:preprocessor de conformidade do pré-processador é definida. Definido como 1 por padrão, ou quando a opção do /Zc:preprocessor- compilador é definida, para indicar que o pré-processador tradicional está em uso (essencialmente, /Zc:preprocessor substitui o preterido /experimental:preprocessor).
    #if !defined(_MSVC_TRADITIONAL) || _MSVC_TRADITIONAL
// Logic using the traditional preprocessor
#else
// Logic using cross-platform compatible preprocessor
#endif

  • _MT Definido como 1 quando /MD ou /MDd (Multithreaded DLL) ou /MT/MTd ou (Multithreaded) é especificado. Caso contrário, indefinido.

  • _NATIVE_WCHAR_T_DEFINED Definido como 1 quando a opção do /Zc:wchar_t compilador é definida. Caso contrário, indefinido.

  • _OPENMP Definido como 200203 literal inteiro, se a /openmp opção de compilador (Enable OpenMP 2.0 Support) estiver definida. Este valor representa a data da especificação OpenMP implementada pelo MSVC. Caso contrário, indefinido.

    // _OPENMP_dir.cpp
// compile with: /openmp
#include <stdio.h>
int main() {
    printf("%d\n", _OPENMP);
}

  • _PREFAST_ Definido como 1 quando a opção do /analyze compilador é definida. Caso contrário, indefinido.

  • __SANITIZE_ADDRESS__ Disponível a partir do Visual Studio 2019 versão 16.9. Definido como 1 quando a opção do /fsanitize=address compilador é definida. Caso contrário, indefinido.

  • __TIMESTAMP__ Definido como um literal de cadeia de caracteres que contém a data e a hora da última modificação do arquivo de origem atual, na forma abreviada de comprimento constante retornada pela função CRT asctime , por exemplo, Fri 19 Aug 13:32:58 2016. Esta macro é sempre definida.

  • _VC_NODEFAULTLIB Definido como 1 quando a /Zl opção do compilador (Omit Default Library Name) é definida. Caso contrário, indefinido.

  • _WCHAR_T_DEFINED Definido como 1 quando a opção de compilador padrão /Zc:wchar_t é definida. A _WCHAR_T_DEFINED macro é definida, mas não tem valor se a /Zc:wchar_t- opção do compilador estiver definida e wchar_t for definida em um arquivo de cabeçalho do sistema incluído no seu projeto. Caso contrário, indefinido.

  • _WIN32 Definido como 1 quando o destino da compilação é ARM de 32 bits, ARM de 64 bits, x86, x64 ou ARM64EC. Caso contrário, indefinido.

  • _WIN64 Definido como 1 quando o destino da compilação é ARM de 64 bits, x64 ou ARM64EC. Caso contrário, indefinido.

  • _WINRT_DLL Definido como 1 quando compilado como C++ e ambas /ZW (Compilação do Tempo de Execução do Windows) e /LD /ou /LDd opções de compilador são definidas. Caso contrário, indefinido.

Nenhuma macro de pré-processador que identifique a versão da biblioteca ATL ou MFC é predefinida pelo compilador. Os cabeçalhos das bibliotecas ATL e MFC definem essas macros de versão internamente. Eles são indefinidos em diretivas de 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 de versão ATL.

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

Ver também

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

  • Last updated on