Determinación de 32 vs 64 bit en C ++

Estoy buscando una manera de determinar de manera confiable si el código C ++ se está compilando en 32 contra 64 bits. Se nos ocurrió lo que creemos que es una solución razonable utilizando macros, pero tenía curiosidad por saber si la gente podría pensar en casos en los que esto podría fallar o si hay una mejor manera de hacerlo. Tenga en cuenta que estamos tratando de hacer esto en un entorno multiplataforma y compilador múltiple.

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

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

Gracias.

Desafortunadamente, no existe una macro multiplataforma que defina 32/64 bits en los principales compiladores. He encontrado que la forma más efectiva de hacer esto es la siguiente.

Primero elijo mi propia representación. Prefiero ENVIRONMENT64 / ENVIRONMENT32. Luego descubro lo que utilizan todos los compiladores principales para determinar si es un entorno de 64 bits o no y lo uso para establecer mis variables.

// 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

Otra ruta más fácil es simplemente establecer estas variables desde la línea de comandos del 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;
}

Desafortunadamente, en un entorno de plataforma cruzada, compilador cruzado, no existe un método confiable único para hacer esto puramente en tiempo de compilación.

• Tanto _WIN32 y _WIN64 pueden a veces tanto indefinidos, si la configuración del proyecto son defectuosos o dañados (particularmente en Visual Studio 2008 SP1).
• Un proyecto etiquetado como "Win32" podría establecerse en 64 bits, debido a un error de configuración del proyecto.
• En Visual Studio 2008 SP1, a veces el intellisense no atenúa las partes correctas del código, de acuerdo con el #define actual. Esto hace que sea difícil ver exactamente qué #define se está utilizando en tiempo de compilación.

Por lo tanto, el único método confiable es combinar 3 verificaciones simples :

• 1) Configuración del tiempo de compilación , y;
• 2) Verificación de tiempo de ejecución , y;
• 3) Comprobación robusta del tiempo de compilación .

Comprobación simple 1/3: configuración del tiempo de compilación

Elija cualquier método para establecer la variable #define requerida. Sugiero el 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

Verificación simple 2/3: Verificación de tiempo de ejecución

En main (), verifique dos veces si sizeof () tiene 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

Comprobación simple 3/3: comprobación robusta del tiempo de compilación

La regla general es "cada #definir debe terminar en un #else que genera un error".

#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

Actualizar 2017-01-17

Comentario de @AI.G:

4 años después (no sé si era posible antes) puede convertir la verificación en tiempo de ejecución en una en tiempo de compilación utilizando la aserción estática: static_assert (sizeof (void *) == 4) ;. Ahora todo está hecho en tiempo de compilación :)

Apéndice A

Incidentalmente, las reglas anteriores se pueden adaptar para hacer que toda su base de código sea más confiable:

• Cada instrucción if () termina en un "else" que genera una advertencia o error.
• Cada instrucción switch () termina en un "valor predeterminado:" que genera una advertencia o error.

La razón por la que esto funciona bien es que te obliga a pensar en cada caso por adelantado, y no confiar en la lógica (a veces defectuosa) en la parte "else" para ejecutar el código correcto.

Utilicé esta técnica (entre muchas otras) para escribir un proyecto de 30,000 líneas que funcionó perfectamente desde el día en que se implementó por primera vez en producción (eso fue hace 12 meses).

Debería poder usar las macros definidas en stdint.h. En particular, INTPTR_MAXes exactamente el valor que necesita.

#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

Algunas versiones (¿todas?) Del compilador de Microsoft no vienen con stdint.h . No estoy seguro de por qué, ya que es un archivo estándar. Aquí hay una versión que puede usar:http://msinttypes.googlecode.com/svn/trunk/stdint.h

Eso no funcionará en Windows para empezar. Los largos y las entradas son 32 bits, ya sea que esté compilando para ventanas de 32 bits o 64 bits. Creo que verificar si el tamaño de un puntero es de 8 bytes es probablemente una ruta más confiable.

Podrías hacer esto:

#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 en 64 bits" no está bien definido en C ++.

C ++ establece solo límites inferiores para tamaños como int, long y void *. No hay garantía de que int sea de 64 bits, incluso cuando se compila para una plataforma de 64 bits. El modelo permite, por ejemplo, 23 bit intsysizeof(int *) != sizeof(char *)

Existen diferentes modelos de programación para plataformas de 64 bits.

Su mejor apuesta es una prueba específica de la plataforma. Su segunda mejor decisión portátil debe ser más específica en lo que es 64 bits.

Su enfoque no estaba muy lejos, pero solo está verificando si son del mismo tamaño longy si intson del mismo tamaño. Teóricamente, ambos podrían ser de 64 bits, en cuyo caso su verificación fallaría, suponiendo que ambos sean de 32 bits. Aquí hay una verificación que realmente verifica el tamaño de los tipos en sí, no su tamaño 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

En principio, puede hacer esto para cualquier tipo para el que tenga una macro definida por el sistema con el valor máximo.

Tenga en cuenta que el estándar requiere long longal menos 64 bits, incluso en sistemas de 32 bits.

La gente ya sugirió métodos que intentarán determinar si el programa se está compilando 32-bito64-bit .

Y quiero agregar que puedes usar la función c ++ 11 static_assert para asegurarse de que la arquitectura es lo que usted piensa que es ("para relajarse").

Entonces, en el lugar donde define las 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

El siguiente código funciona bien para la mayoría de los entornos actuales:

  #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

Si puede usar configuraciones de proyecto en todos sus entornos, eso facilitaría la definición de un símbolo de 64 y 32 bits. Entonces tendrías configuraciones de proyecto como esta:

Depuración de
32 bits Versión de 32 bits Versión de
64 bits Depuración de
64 bits

EDITAR: Estas son configuraciones genéricas, no configuraciones dirigidas. Llámalos como quieras.

Si no puedes hacer eso, me gusta la idea de Jared.

Colocaría fuentes de 32 bits y 64 bits en diferentes archivos y luego seleccionaría los archivos fuente apropiados usando el sistema de compilación.

Tomando prestado de la excelente respuesta anterior de Contango y combinándolo con " Mejores macros, mejores banderas " de Fluent C ++, puede hacer:

// 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

Entonces puedes usarlo como:

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

O usando la macro adicional que agregué:

MYPROJ_IF_64_BIT_ELSE( DoMy64BitOperation(), DoMy32BitOperation() );

Estoy agregando esta respuesta como un caso de uso y un ejemplo completo para la verificación de tiempo de ejecución descrita en otra respuesta .

Este es el enfoque que he estado adoptando para transmitir al usuario final si el programa se compiló como 64 bits o 32 bits (u otro, para el 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 y probar

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