Determinando 32 vs 64 bits em C ++

Eu estou procurando uma maneira de determinar com segurança se o código C ++ está sendo compilado em 32 vs 64 bits. Chegamos ao que pensamos ser uma solução razoável usando macros, mas estávamos curiosos para saber se as pessoas poderiam pensar em casos em que isso pode falhar ou se há uma maneira melhor de fazer isso. Observe que estamos tentando fazer isso em um ambiente compilador de múltiplas plataformas.

#if ((ULONG_MAX) == (UINT_MAX))
# define IS32BIT
#else
# define IS64BIT
#endif

#ifdef IS64BIT
DoMy64BitOperation()
#else
DoMy32BitOperation()
#endif

Obrigado.

Infelizmente, não há macro de plataforma cruzada que defina 32/64 bits nos principais compiladores. Eu descobri que a maneira mais eficaz de fazer isso é o seguinte.

Primeiro eu escolho minha própria representação. Prefiro AMBIENTE64 / AMBIENTE32. Depois, descubro o que todos os principais compiladores usam para determinar se é um ambiente de 64 bits ou não e o uso para definir minhas variáveis.

// Check windows
#if _WIN32 || _WIN64
#if _WIN64
#define ENVIRONMENT64
#else
#define ENVIRONMENT32
#endif
#endif

// Check GCC
#if __GNUC__
#if __x86_64__ || __ppc64__
#define ENVIRONMENT64
#else
#define ENVIRONMENT32
#endif
#endif

Outra rota mais fácil é simplesmente definir essas variáveis ​​na linha de comando do compilador.

template<int> void DoMyOperationHelper();

template<> void DoMyOperationHelper<4>() 
{
  // do 32-bits operations
}

template<> void DoMyOperationHelper<8>() 
{
  // do 64-bits operations
}

// helper function just to hide clumsy syntax
inline void DoMyOperation() { DoMyOperationHelper<sizeof(size_t)>(); }

int main()
{
  // appropriate function will be selected at compile time 
  DoMyOperation(); 

  return 0;
}

Infelizmente, em um ambiente de plataforma cruzada e compilador cruzado, não existe um método confiável único para fazer isso exclusivamente em tempo de compilação.

• Ambos _WIN32 e _WIN64 às vezes pode tanto ser indefinido, se as configurações do projeto são falhos ou corrompido (particularmente no Visual Studio 2008 SP1).
• Um projeto chamado "Win32" pode ser definido como 64 bits, devido a um erro de configuração do projeto.
• No Visual Studio 2008 SP1, às vezes o intellisense não esmaece as partes corretas do código, de acordo com o atual #define. Isso dificulta ver exatamente qual #define está sendo usado em tempo de compilação.

Portanto, o único método confiável é combinar 3 verificações simples :

• 1) Configuração do tempo de compilação , e;
• 2) verificação de tempo de execução e;
• 3) Verificação robusta do tempo de compilação .

Verificação simples 1/3: configuração do tempo de compilação

Escolha qualquer método para definir a variável #define necessária. Sugiro o método de @JaredPar:

// Check windows
#if _WIN32 || _WIN64
   #if _WIN64
     #define ENV64BIT
  #else
    #define ENV32BIT
  #endif
#endif

// Check GCC
#if __GNUC__
  #if __x86_64__ || __ppc64__
    #define ENV64BIT
  #else
    #define ENV32BIT
  #endif
#endif

Verificação simples 2/3: verificação de tempo de execução

Em main (), verifique novamente se sizeof () faz sentido:

#if defined(ENV64BIT)
    if (sizeof(void*) != 8)
    {
        wprintf(L"ENV64BIT: Error: pointer should be 8 bytes. Exiting.");
        exit(0);
    }
    wprintf(L"Diagnostics: we are running in 64-bit mode.\n");
#elif defined (ENV32BIT)
    if (sizeof(void*) != 4)
    {
        wprintf(L"ENV32BIT: Error: pointer should be 4 bytes. Exiting.");
        exit(0);
    }
    wprintf(L"Diagnostics: we are running in 32-bit mode.\n");
#else
    #error "Must define either ENV32BIT or ENV64BIT".
#endif

Verificação simples 3/3: verificação robusta do tempo de compilação

A regra geral é "todo #define deve terminar em um #else que gera um erro".

#if defined(ENV64BIT)
    // 64-bit code here.
#elif defined (ENV32BIT)
    // 32-bit code here.
#else
    // INCREASE ROBUSTNESS. ALWAYS THROW AN ERROR ON THE ELSE.
    // - What if I made a typo and checked for ENV6BIT instead of ENV64BIT?
    // - What if both ENV64BIT and ENV32BIT are not defined?
    // - What if project is corrupted, and _WIN64 and _WIN32 are not defined?
    // - What if I didn't include the required header file?
    // - What if I checked for _WIN32 first instead of second?
    //   (in Windows, both are defined in 64-bit, so this will break codebase)
    // - What if the code has just been ported to a different OS?
    // - What if there is an unknown unknown, not mentioned in this list so far?
    // I'm only human, and the mistakes above would break the *entire* codebase.
    #error "Must define either ENV32BIT or ENV64BIT"
#endif

Atualização 2017-01-17

Comentário de @AI.G:

4 anos depois (não sei se era possível antes), você pode converter a verificação em tempo de execução para uma em tempo de compilação usando a afirmação estática: static_assert (sizeof (void *) == 4) ;. Agora tudo é feito em tempo de compilação :)

Apêndice A

Incidencialmente, as regras acima podem ser adaptadas para tornar toda a sua base de código mais confiável:

• Cada instrução if () termina em um "else" que gera um aviso ou erro.
• Cada instrução switch () termina com um "padrão:" que gera um aviso ou erro.

A razão pela qual isso funciona bem é que obriga você a pensar em todos os casos com antecedência e a não confiar na lógica (às vezes falha) da parte "else" para executar o código correto.

Usei essa técnica (entre muitas outras) para escrever um projeto de 30.000 linhas que funcionou perfeitamente desde o primeiro dia em que foi implantado na produção (há 12 meses).

Você deve poder usar as macros definidas em stdint.h. Em particular, INTPTR_MAXé exatamente o valor que você precisa.

#include <cstdint>
#if INTPTR_MAX == INT32_MAX
    #define THIS_IS_32_BIT_ENVIRONMENT
#elif INTPTR_MAX == INT64_MAX
    #define THIS_IS_64_BIT_ENVIRONMENT
#else
    #error "Environment not 32 or 64-bit."
#endif

Algumas versões (todas?) Do compilador da Microsoft não são fornecidas stdint.h. Não sei por que, já que é um arquivo padrão. Aqui está uma versão que você pode usar:http://msinttypes.googlecode.com/svn/trunk/stdint.h

Isso não funcionará no Windows para começar. Longs e ints são ambos de 32 bits, esteja você compilando para janelas de 32 ou 64 bits. Eu acho que verificar se o tamanho de um ponteiro é 8 bytes é provavelmente uma rota mais confiável.

Você poderia fazer isso:

#if __WORDSIZE == 64
char *size = "64bits";
#else
char *size = "32bits";
#endif

Try this:
#ifdef _WIN64
// 64 bit code
#elif _WIN32
// 32 bit code
#else
   if(sizeof(void*)==4)

       // 32 bit code
   else 

       // 64 bit code   
#endif

"Compilado em 64 bits" não está bem definido em C ++.

O C ++ define apenas limites inferiores para tamanhos como int, long e void *. Não há garantia de que int seja de 64 bits, mesmo quando compilado para uma plataforma de 64 bits. O modelo permite a por exemplo 23 bits ints esizeof(int *) != sizeof(char *)

Existem diferentes modelos de programação para plataformas de 64 bits.

Sua melhor aposta é um teste específico da plataforma. Sua segunda melhor decisão portátil deve ser mais específica no que é 64 bits.

Sua abordagem não foi muito distante, mas você está apenas verificando se longe inttem o mesmo tamanho. Teoricamente, os dois poderiam ter 64 bits; nesse caso, sua verificação falharia, assumindo que ambos eram 32 bits. Aqui está uma verificação que realmente verifica o tamanho dos tipos em si, não o tamanho relativo:

#if ((UINT_MAX) == 0xffffffffu)
    #define INT_IS32BIT
#else
    #define INT_IS64BIT
#endif
#if ((ULONG_MAX) == 0xfffffffful)
    #define LONG_IS32BIT
#else
    #define LONG_IS64BIT
#endif

Em princípio, você pode fazer isso para qualquer tipo para o qual você tenha uma macro definida pelo sistema com o valor máximo.

Observe que o padrão exige long longpelo menos 64 bits, mesmo em sistemas de 32 bits.

As pessoas já sugeriram métodos que tentarão determinar se o programa está sendo compilado em 32-bitou 64-bit.

E quero acrescentar que você pode usar o recurso c ++ 11 static_assertpara garantir que a arquitetura seja o que você pensa que é ("relaxar").

Portanto, no local em que você define as macros:

#if ...
# define IS32BIT
  static_assert(sizeof(void *) == 4, "Error: The Arch is not what I think it is")
#elif ...
# define IS64BIT
  static_assert(sizeof(void *) == 8, "Error: The Arch is not what I think it is")
#else
# error "Cannot determine the Arch"
#endif

O código abaixo funciona bem para a maioria dos ambientes atuais:

  #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) &&     !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
    #define IS64BIT 1
 #else
    #define IS32BIT 1
#endif

Se você puder usar as configurações do projeto em todos os seus ambientes, isso facilitaria a definição de um símbolo de 64 e 32 bits. Então você teria configurações de projeto como esta:

Depuração de
32 bits Liberação de
32 bits Depuração de 64 bits
64 bits Versão de 64 bits

EDIT: Estas são configurações genéricas, não configurações direcionadas. Ligue para eles como quiser.

Se você não pode fazer isso, eu gosto da ideia de Jared.

Colocaria fontes de 32 e 64 bits em arquivos diferentes e depois selecionaria os arquivos de origem apropriados usando o sistema de compilação.

Tomando emprestado a excelente resposta do Contango acima e combinando-a com " Melhores macros, melhores sinalizadores " do Fluent C ++, você pode:

// Macro for checking bitness (safer macros borrowed from 
// https://www.fluentcpp.com/2019/05/28/better-macros-better-flags/)
#define MYPROJ_IS_BITNESS( X ) MYPROJ_IS_BITNESS_PRIVATE_DEFINITION_##X()

// Bitness checks borrowed from https://stackoverflow.com/a/12338526/201787
#if _WIN64 || ( __GNUC__ && __x86_64__ )
#    define MYPROJ_IS_BITNESS_PRIVATE_DEFINITION_64() 1
#    define MYPROJ_IS_BITNESS_PRIVATE_DEFINITION_32() 0
#    define MYPROJ_IF_64_BIT_ELSE( x64, x86 ) (x64)
    static_assert( sizeof( void* ) == 8, "Pointer size is unexpected for this bitness" );
#elif _WIN32 || __GNUC__
#    define MYPROJ_IS_BITNESS_PRIVATE_DEFINITION_64() 0
#    define MYPROJ_IS_BITNESS_PRIVATE_DEFINITION_32() 1
#    define MYPROJ_IF_64_BIT_ELSE( x64, x86 ) (x86)
    static_assert( sizeof( void* ) == 4, "Pointer size is unexpected for this bitness" );
#else
#    error "Unknown bitness!"
#endif

Então você pode usá-lo como:

#if MYPROJ_IS_BITNESS( 64 )
    DoMy64BitOperation()
#else
    DoMy32BitOperation()
#endif

Ou usando a macro extra que eu adicionei:

MYPROJ_IF_64_BIT_ELSE( DoMy64BitOperation(), DoMy32BitOperation() );

Estou adicionando esta resposta como um caso de uso e exemplo completo para a verificação de tempo de execução descrita em outra resposta .

Esta é a abordagem que eu tenho adotado para transmitir ao usuário final se o programa foi compilado como 64 bits ou 32 bits (ou outro, nesse caso):

version.h

#ifndef MY_VERSION
#define MY_VERSION

#include <string>

const std::string version = "0.09";
const std::string arch = (std::to_string(sizeof(void*) * 8) + "-bit");

#endif

test.cc

#include <iostream>
#include "version.h"

int main()
{
    std::cerr << "My App v" << version << " [" << arch << "]" << std::endl;
}

Compilar e testar

g++ -g test.cc
./a.out
My App v0.09 [64-bit]