Determinazione di 32 vs 64 bit in C ++

Sto cercando un modo per determinare in modo affidabile se il codice C ++ viene compilato in 32 vs 64 bit. Abbiamo trovato quella che pensiamo sia una soluzione ragionevole usando le macro, ma siamo curiosi di sapere se le persone potrebbero pensare a casi in cui ciò potrebbe fallire o se esiste un modo migliore per farlo. Si noti che stiamo provando a farlo in un ambiente con più compilatori multipiattaforma.

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

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

Grazie.

Sfortunatamente non esiste una macro multipiattaforma che definisce 32/64 bit tra i principali compilatori. Ho trovato il modo più efficace per farlo è il seguente.

Per prima cosa scelgo la mia rappresentazione. Preferisco ENVIRONMENT64 / ENVIRONMENT32. Poi scopro cosa usano tutti i principali compilatori per determinare se si tratta di un ambiente a 64 bit o meno e lo uso per impostare le mie variabili.

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

Un altro percorso più semplice è semplicemente impostare queste variabili dalla riga di comando del compilatore.

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;
}

Sfortunatamente, in un ambiente cross-platform e cross-compilatore, non esiste un unico metodo affidabile per farlo puramente in fase di compilazione.

• A volte sia _WIN32 che _WIN64 possono essere entrambi indefiniti, se le impostazioni del progetto sono errate o danneggiate (in particolare su Visual Studio 2008 SP1).
• Un progetto con l'etichetta "Win32" potrebbe essere impostato su 64 bit, a causa di un errore di configurazione del progetto.
• Su Visual Studio 2008 SP1, a volte l'intellisense non oscura le parti corrette del codice, secondo l'attuale #define. Questo rende difficile vedere esattamente quale #define viene usato al momento della compilazione.

Pertanto, l' unico metodo affidabile è combinare 3 semplici controlli :

• 1) Impostazione del tempo di compilazione e;
• 2) controllo di runtime e;
• 3) Controllo del tempo di compilazione robusto .

Controllo semplice 1/3: impostazione del tempo di compilazione

Scegli un metodo per impostare la variabile #define richiesta. Suggerisco il metodo da @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

Controllo semplice 2/3: controllo runtime

In main (), controlla due volte se sizeof () ha senso:

#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

Controllo semplice 3/3: controllo del tempo di compilazione robusto

La regola generale è "ogni #define deve finire con un #else che genera un errore".

#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

Aggiornamento 2017-01-17

Commento di @AI.G:

4 anni dopo (non so se fosse possibile prima) è possibile convertire il controllo di run-time in tempo di compilazione usando assert statico: static_assert (sizeof (void *) == 4) ;. Ora è tutto fatto in fase di compilazione :)

Appendice A

Per inciso, le regole sopra possono essere adattate per rendere più affidabile l'intera base di codice:

• Ogni istruzione if () termina con un "else" che genera un avviso o un errore.
• Ogni istruzione switch () termina con un "valore predefinito:" che genera un avviso o un errore.

Il motivo per cui funziona bene è che ti costringe a pensare in anticipo a ogni singolo caso e non fare affidamento sulla logica (a volte imperfetta) nella parte "else" per eseguire il codice corretto.

Ho usato questa tecnica (tra le altre cose) per scrivere un progetto di 30.000 linee che ha funzionato perfettamente dal giorno in cui è stato implementato per la prima volta in produzione (12 mesi fa).

Dovresti essere in grado di utilizzare le macro definite in stdint.h. In particolare INTPTR_MAXè esattamente il valore che ti serve.

#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

Alcune (tutte?) Versioni del compilatore di Microsoft non vengono fornite stdint.h. Non so perché, dato che è un file standard. Ecco una versione che puoi usare:http://msinttypes.googlecode.com/svn/trunk/stdint.h

Per prima cosa non funzionerà su Windows. I long e gli ints sono entrambi 32 bit sia che si stiano compilando per finestre a 32 bit o 64 bit. Penso che verificare se la dimensione di un puntatore è di 8 byte sia probabilmente un percorso più affidabile.

Potresti farlo:

#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

"Compilato in 64 bit" non è ben definito in C ++.

C ++ imposta solo limiti inferiori per dimensioni come int, long e void *. Non vi è alcuna garanzia che int sia 64 bit anche se compilato per una piattaforma a 64 bit. Il modello consente ad esempio a 23 bit ints esizeof(int *) != sizeof(char *)

Esistono diversi modelli di programmazione per piattaforme a 64 bit.

La tua scommessa migliore è un test specifico per piattaforma. La tua seconda migliore decisione portatile deve essere più specifica in ciò che è 64 bit.

Il tuo approccio non era troppo lontano, ma stai solo verificando se longe inthanno le stesse dimensioni. Teoricamente, potrebbero essere entrambi 64 bit, nel qual caso il tuo controllo fallirebbe, assumendo entrambi 32 bit. Ecco un controllo che controlla effettivamente la dimensione dei tipi stessi, non la loro dimensione relativa:

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

In linea di principio, puoi farlo per qualsiasi tipo per cui hai una macro definita dal sistema con il valore massimo.

Si noti che lo standard richiede long longdi essere almeno 64 bit anche su sistemi a 32 bit.

Le persone hanno già suggerito metodi che tenteranno di determinare se il programma viene compilato in 32-bito 64-bit.

E voglio aggiungere che puoi usare la funzione c ++ 11 static_assertper assicurarti che l'architettura sia quella che pensi ("per rilassarti").

Quindi nel luogo in cui si definiscono le macro:

#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

Il codice seguente funziona perfettamente per la maggior parte degli ambienti attuali:

  #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 puoi usare le configurazioni di progetto in tutti i tuoi ambienti, ciò semplificherebbe la definizione di un simbolo a 64 e 32 bit. Quindi avresti configurazioni di progetto come questa:

Debug a
32 bit Versione a 32
bit Debug a
64 bit Versione a 64 bit

EDIT: si tratta di configurazioni generiche, non di configurazioni mirate. Chiamali come vuoi.

Se non puoi farlo, mi piace l'idea di Jared.

Metterei i sorgenti a 32 e 64 bit in file diversi e quindi selezionerei i file sorgente appropriati usando il sistema di compilazione.

Prendendo in prestito da Contango s' ottima risposta di cui sopra e combinandolo con ' Meglio Macro, meglio Bandiere ' dal perfetto C ++, si può fare:

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

Quindi puoi usarlo come:

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

O usando la macro extra che ho aggiunto:

MYPROJ_IF_64_BIT_ELSE( DoMy64BitOperation(), DoMy32BitOperation() );

Sto aggiungendo questa risposta come caso d'uso ed esempio completo per il controllo di runtime descritto in un'altra risposta .

Questo è l'approccio che ho adottato per comunicare all'utente finale se il programma è stato compilato come 64-bit o 32-bit (o altro, del resto):

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;
}

Compila e verifica

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