Określanie 32 vs 64 bit w C ++

Szukam sposobu, aby wiarygodnie określić, czy kod C ++ jest kompilowany w wersji 32 vs 64 bit. Wymyśliliśmy to, co uważamy za rozsądne rozwiązanie przy użyciu makr, ale byliśmy ciekawi, czy ludzie mogą wymyślić przypadki, w których może się to nie udać, lub czy istnieje lepszy sposób na zrobienie tego. Należy pamiętać, że próbujemy to zrobić w wieloplatformowym środowisku kompilatorów.

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

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

Dzięki.

Niestety nie ma makra wieloplatformowego, które definiuje 32/64 bity w głównych kompilatorach. Najskuteczniejszy sposób, aby to zrobić, jest następujący.

Najpierw wybieram własną reprezentację. Wolę ŚRODOWISKO64 / ŚRODOWISKO32. Następnie dowiaduję się, czego używają wszystkie główne kompilatory do określenia, czy jest to środowisko 64-bitowe, czy nie, i używam tego do ustawiania moich zmiennych.

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

Inną łatwiejszą drogą jest po prostu ustawienie tych zmiennych z wiersza poleceń kompilatora.

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

Niestety, w środowisku wieloplatformowym i kompilatorach wieloplatformowych nie ma jednej niezawodnej metody robienia tego wyłącznie w czasie kompilacji.

• Zarówno _WIN32 i _WIN64 czasami może zarówno być niezdefiniowana, jeśli ustawienia projektu są wadliwe lub uszkodzone (szczególnie w Visual Studio 2008 SP1).
• Projekt oznaczony jako „Win32” mógł być ustawiony na 64-bitowy z powodu błędu konfiguracji projektu.
• W programie Visual Studio 2008 z dodatkiem SP1 czasami funkcja Intellisense nie powoduje wyszarzenia poprawnych części kodu, zgodnie z bieżącym #define. To sprawia, że ​​trudno jest zobaczyć, który #define jest używany w czasie kompilacji.

Dlatego jedyną niezawodną metodą jest połączenie 3 prostych kontroli :

• 1) ustawienie czasu kompilacji oraz;
• 2) sprawdzenie w czasie wykonywania oraz;
• 3) Solidne sprawdzanie czasu kompilacji .

Proste sprawdzenie 1/3: ustawienie czasu kompilacji

Wybierz dowolną metodę, aby ustawić wymaganą zmienną #define. Proponuję metodę z @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

Proste sprawdzenie 2/3: sprawdzenie w czasie wykonywania

W main () dwukrotnie sprawdź, czy sizeof () ma sens:

#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

Proste sprawdzenie 3/3: Solidne sprawdzanie czasu kompilacji

Ogólna zasada brzmi: „każdy #define musi kończyć się #else, który generuje błąd”.

#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

Aktualizacja 2017-01-17

Komentarz od @AI.G:

4 lata później (nie wiem, czy wcześniej było to możliwe) możesz przekonwertować sprawdzenie w czasie wykonywania na sprawdzenie kompilacji za pomocą statycznego assert: static_assert (sizeof (void *) == 4) ;. Teraz wszystko jest gotowe w czasie kompilacji :)

załącznik A

Nawiasem mówiąc, powyższe reguły można dostosować, aby cała baza kodu była bardziej niezawodna:

• Każda instrukcja if () kończy się „else”, które generuje ostrzeżenie lub błąd.
• Każda instrukcja switch () kończy się „default:”, które generuje ostrzeżenie lub błąd.

Powodem, dla którego to działa dobrze, jest to, że zmusza cię do przemyślenia każdego pojedynczego przypadku z wyprzedzeniem i nie polega na (czasem błędnej) logice w części „else”, aby wykonać poprawny kod.

Użyłem tej techniki (między innymi), aby napisać projekt 30 000 linii, który działał bezbłędnie od dnia pierwszego wdrożenia do produkcji (czyli 12 miesięcy temu).

Powinieneś móc używać makr zdefiniowanych w stdint.h. W szczególności INTPTR_MAXjest to dokładnie taka wartość, jakiej potrzebujesz.

#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

Niektóre (wszystkie?) Wersje kompilatora Microsoftu nie są dostarczane z stdint.h. Nie wiem dlaczego, ponieważ jest to standardowy plik. Oto wersja, której możesz użyć:http://msinttypes.googlecode.com/svn/trunk/stdint.h

Na początek to nie zadziała w systemie Windows. Długie i int są 32-bitowe, niezależnie od tego, czy kompilujesz dla okien 32-bitowych, czy 64-bitowych. Myślę, że sprawdzenie, czy rozmiar wskaźnika wynosi 8 bajtów, jest prawdopodobnie bardziej niezawodną trasą.

Możesz to zrobić:

#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

„Kompilacja w wersji 64-bitowej” nie jest dobrze zdefiniowana w C ++.

C ++ ustawia tylko dolne limity dla rozmiarów, takich jak int, long i void *. Nie ma gwarancji, że int jest 64-bitowy, nawet po skompilowaniu dla platformy 64-bitowej. Model dopuszcza np. 23 bity intisizeof(int *) != sizeof(char *)

Istnieją różne modele programowania dla platform 64-bitowych.

Najlepszym rozwiązaniem jest test specyficzny dla platformy. Twój drugi najlepszy przenośne decyzja musi być bardziej szczegółowe w co jest 64-bitowy.

Twoje podejście nie było zbyt odległe, ale sprawdzasz tylko, czy longi czy intsą tej samej wielkości. Teoretycznie oba mogą mieć 64 bity, w takim przypadku twój test nie powiedzie się, zakładając, że oba mają 32 bity. Oto kontrola, która faktycznie sprawdza rozmiar samych typów, a nie ich względny rozmiar:

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

W zasadzie możesz to zrobić dla każdego typu, dla którego masz zdefiniowane przez system makro z wartością maksymalną.

Zauważ, że standard wymaga long longco najmniej 64 bitów, nawet w systemach 32-bitowych.

Ludzie już zasugerowali metody, które spróbują określić, czy program jest kompilowany w 32-bitlub 64-bit.

I chcę dodać, że możesz użyć funkcji c ++ 11, static_assertaby upewnić się, że architektura jest taka, jaką myślisz („odprężyć się”).

A więc w miejscu, w którym definiujesz makra:

#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

Poniższy kod działa dobrze w większości obecnych środowisk:

  #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

Jeśli możesz używać konfiguracji projektu we wszystkich swoich środowiskach, ułatwiłoby to zdefiniowanie 64- i 32-bitowego symbolu. Więc miałbyś takie konfiguracje projektu:

32-bitowe debugowanie
32-bitowe wydanie
64-bitowe debugowanie
64-bitowe wydanie

EDYCJA: są to konfiguracje ogólne, a nie docelowe. Zadzwoń do nich, jak chcesz.

Jeśli nie możesz tego zrobić, podoba mi się pomysł Jareda.

Umieściłbym źródła 32-bitowe i 64-bitowe w różnych plikach, a następnie wybrałbym odpowiednie pliki źródłowe za pomocą systemu kompilacji.

Pożyczanie od contango jest doskonałą odpowiedzią powyżej i łącząc ją z « lepszych makr, lepszy Flags » z Fluent C ++, można zrobić:

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

Następnie możesz go używać tak:

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

Lub korzystając z dodatkowego makra, które dodałem:

MYPROJ_IF_64_BIT_ELSE( DoMy64BitOperation(), DoMy32BitOperation() );

Dodaję tę odpowiedź jako przypadek użycia i kompletny przykład sprawdzania środowiska uruchomieniowego opisanego w innej odpowiedzi .

Oto podejście, które obrałem, aby przekazać użytkownikowi końcowemu, czy program został skompilowany jako 64-bitowy, czy 32-bitowy (lub inny, jeśli o to chodzi):

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

Kompiluj i testuj

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