Bestimmen von 32 vs 64 Bit in C ++

Ich suche nach einer Möglichkeit, zuverlässig festzustellen, ob C ++ - Code in 32 vs 64 Bit kompiliert wird. Wir haben uns eine unserer Meinung nach vernünftige Lösung mit Makros ausgedacht, waren aber neugierig zu wissen, ob die Leute an Fälle denken könnten, in denen dies fehlschlagen könnte, oder ob es einen besseren Weg gibt, dies zu tun. Bitte beachten Sie, dass wir dies in einer plattformübergreifenden Umgebung mit mehreren Compilern versuchen.

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

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

Vielen Dank.

Leider gibt es kein plattformübergreifendes Makro, das 32/64 Bit für die wichtigsten Compiler definiert. Ich habe den effektivsten Weg gefunden, dies zu tun, ist der folgende.

Zuerst wähle ich meine eigene Darstellung. Ich bevorzuge ENVIRONMENT64 / ENVIRONMENT32. Dann finde ich heraus, was alle großen Compiler verwenden, um festzustellen, ob es sich um eine 64-Bit-Umgebung handelt oder nicht, und verwende dies, um meine Variablen festzulegen.

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

Eine andere einfachere Möglichkeit besteht darin, diese Variablen einfach über die Compiler-Befehlszeile festzulegen.

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

Leider gibt es in einer plattformübergreifenden, compilerübergreifenden Umgebung keine einzige zuverlässige Methode, um dies nur zur Kompilierungszeit zu tun.

• Sowohl _WIN32 als auch _WIN64 können manchmal beide undefiniert sein, wenn die Projekteinstellungen fehlerhaft oder beschädigt sind (insbesondere in Visual Studio 2008 SP1).
• Ein Projekt mit der Bezeichnung "Win32" kann aufgrund eines Projektkonfigurationsfehlers auf 64-Bit festgelegt werden.
• In Visual Studio 2008 SP1 grauisiert der Intellisense manchmal nicht die richtigen Teile des Codes gemäß der aktuellen #define. Dies macht es schwierig, genau zu erkennen, welche #define zur Kompilierungszeit verwendet wird.

Daher besteht die einzig zuverlässige Methode darin, drei einfache Überprüfungen zu kombinieren :

• 1) Kompilierzeiteinstellung und;
• 2) Laufzeitprüfung und;
• 3) Robuste Überprüfung der Kompilierungszeit .

Einfache Prüfung 1/3: Einstellung der Kompilierungszeit

Wählen Sie eine beliebige Methode, um die erforderliche Variable #define festzulegen. Ich schlage die Methode von @JaredPar vor:

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

Einfache Prüfung 2/3: Laufzeitprüfung

Überprüfen Sie in main () noch einmal, ob sizeof () sinnvoll ist:

#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

Einfache Prüfung 3/3: Robuste Prüfung der Kompilierungszeit

Die allgemeine Regel lautet: "Jede #define muss mit einer #else enden, die einen Fehler erzeugt."

#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

Update 2017-01-17

Kommentar von @AI.G:

4 Jahre später (ich weiß nicht, ob es vorher möglich war) können Sie die Laufzeitprüfung mit static assert: static_assert (sizeof (void *) == 4); in die Kompilierungszeit konvertieren. Jetzt ist alles zur Kompilierungszeit erledigt :)

Anhang A

Im Übrigen können die oben genannten Regeln angepasst werden, um Ihre gesamte Codebasis zuverlässiger zu machen:

• Jede if () - Anweisung endet mit einem "else", das eine Warnung oder einen Fehler generiert.
• Jede switch () - Anweisung endet mit einem "default:", der eine Warnung oder einen Fehler generiert.

Der Grund, warum dies gut funktioniert, besteht darin, dass Sie gezwungen sind, jeden einzelnen Fall im Voraus zu überlegen und sich nicht auf die (manchmal fehlerhafte) Logik im "else" -Teil zu verlassen, um den richtigen Code auszuführen.

Ich habe diese Technik (unter anderem) verwendet, um ein 30.000-Zeilen-Projekt zu schreiben, das vom ersten Tag an (vor 12 Monaten) einwandfrei funktionierte.

Sie sollten in der Lage sein, die in definierten Makros zu verwenden stdint.h. Insbesondere INTPTR_MAXist genau der Wert, den Sie benötigen.

#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

Einige (alle?) Versionen des Microsoft-Compilers werden nicht mitgeliefert stdint.h. Ich weiß nicht warum, da es sich um eine Standarddatei handelt. Hier ist eine Version, die Sie verwenden können:http://msinttypes.googlecode.com/svn/trunk/stdint.h

Das funktioniert unter Windows zunächst einmal nicht. Longs und Ints sind beide 32-Bit, unabhängig davon, ob Sie für 32-Bit- oder 64-Bit-Fenster kompilieren. Ich würde denken, dass die Überprüfung, ob die Größe eines Zeigers 8 Bytes beträgt, wahrscheinlich eine zuverlässigere Route ist.

Sie könnten dies tun:

#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

"In 64 Bit kompiliert" ist in C ++ nicht gut definiert.

C ++ legt nur Untergrenzen für Größen wie int, long und fest void *. Es gibt keine Garantie dafür, dass int 64-Bit ist, selbst wenn es für eine 64-Bit-Plattform kompiliert wurde. Das Modell erlaubt zB 23 Bit ints undsizeof(int *) != sizeof(char *)

Es gibt verschiedene Programmiermodelle für 64-Bit-Plattformen.

Ihre beste Wahl ist ein plattformspezifischer Test. Ihre zweitbeste, müssen tragbare Entscheidung spezifischere in sein , was 64 Bit.

Ihr Ansatz war nicht zu weit entfernt, aber Sie prüfen nur, ob longund intsind Sie gleich groß. Theoretisch könnten beide 64 Bit sein. In diesem Fall würde Ihre Prüfung fehlschlagen, vorausgesetzt, beide sind 32 Bit. Hier ist eine Überprüfung, die tatsächlich die Größe der Typen selbst überprüft, nicht ihre relative Größe:

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

Grundsätzlich können Sie dies für jeden Typ tun, für den Sie ein systemdefiniertes Makro mit dem Maximalwert haben.

Beachten Sie, dass der Standard long longauch auf 32-Bit-Systemen mindestens 64 Bit betragen muss.

Die Leute haben bereits Methoden vorgeschlagen, die versuchen festzustellen, ob das Programm in 32-bitoder kompiliert wird 64-bit.

Und ich möchte hinzufügen, dass Sie die c ++ 11-Funktion verwenden können static_assert, um sicherzustellen, dass die Architektur so ist, wie Sie denken ("zum Entspannen").

Also an der Stelle, an der Sie die Makros definieren:

#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

Der folgende Code funktioniert in den meisten aktuellen Umgebungen einwandfrei:

  #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

Wenn Sie Projektkonfigurationen in all Ihren Umgebungen verwenden können, würde dies die Definition eines 64- und 32-Bit-Symbols vereinfachen. Sie hätten also folgende Projektkonfigurationen:

32-Bit-Debug
32-Bit-Release
64-Bit-Debug
64-Bit-Release

BEARBEITEN: Dies sind generische Konfigurationen, keine gezielten Konfigurationen. Rufen Sie sie an, wie Sie wollen.

Wenn du das nicht kannst, mag ich Jareds Idee.

Ich würde 32-Bit- und 64-Bit-Quellen in verschiedenen Dateien platzieren und dann mithilfe des Build-Systems geeignete Quelldateien auswählen.

Angelehnt an Contango ‚s ausgezeichnete Antwort oben und es mit‚kombiniert Besseren Makros, Better Flags ‘von Fluent C ++, können Sie tun:

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

Dann können Sie es wie folgt verwenden:

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

Oder mit dem zusätzlichen Makro, das ich hinzugefügt habe:

MYPROJ_IF_64_BIT_ELSE( DoMy64BitOperation(), DoMy32BitOperation() );

Ich füge diese Antwort als Anwendungsfall und vollständiges Beispiel für die in einer anderen Antwort beschriebene Laufzeitprüfung hinzu .

Dies ist der Ansatz, den ich gewählt habe, um dem Endbenutzer zu vermitteln, ob das Programm als 64-Bit oder 32-Bit (oder in einem anderen Fall) kompiliert wurde:

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

Kompilieren und testen

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