C ++ 'da 32'ye 64 bit belirlenmesi

Güvenilir bir şekilde C ++ kodu 32 vs 64 bit derleniyor olup olmadığını belirlemek için bir yol arıyorum. Makroları kullanarak makul bir çözüm olduğunu düşündüğümüz şeyleri bulduk, ancak insanların bunun başarısız olabileceği durumları düşünüp düşünemeyeceğini veya bunu yapmanın daha iyi bir yolu olup olmadığını merak ediyorduk. Bunu, platformlar arası, çoklu derleyici ortamında yapmaya çalıştığımızı lütfen unutmayın.

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

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

Teşekkürler.

Ne yazık ki, büyük derleyiciler arasında 32/64 bit tanımlayan çapraz platform makrosu yoktur. Bunu yapmanın en etkili yolunu buldum.

Önce kendi temsilciliğimi seçiyorum. ÇEVRE64 / ÇEVRE32'yi tercih ederim. Sonra tüm büyük derleyicilerin 64 bit ortam olup olmadığını belirlemek için ne kullandığını öğreniyorum ve bunu değişkenlerimi ayarlamak için kullanıyorum.

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

Başka bir kolay yol da bu değişkenleri derleyici komut satırından ayarlamaktır.

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

Ne yazık ki, bir çapraz platformda, çapraz derleyici ortamında, bunu yalnızca derleme zamanında yapmak için tek bir güvenilir yöntem yoktur.

• Proje ayarları hatalı veya bozuksa (özellikle Visual Studio 2008 SP1'de) hem _WIN32 hem de _WIN64 bazen tanımsız olabilir .
• "Win32" etiketli bir proje, bir proje yapılandırma hatası nedeniyle 64-bit olarak ayarlanabilir.
• Visual Studio 2008 SP1'de, intellisense, geçerli #define göre bazen kodun doğru kısımlarını grileştirmez. Bu, derleme zamanında hangi #define kullanıldığını görmeyi zorlaştırır.

Bu nedenle, tek güvenilir yöntem 3 basit kontrolü birleştirmektir :

• 1) Derleme zamanı ayarı ve;
• 2) Çalışma zamanı kontrolü ve;
• 3) Sağlam derleme zamanı kontrolü .

Basit kontrol 1/3: Derleme zamanı ayarı

Gerekli #define değişkenini ayarlamak için herhangi bir yöntem seçin . @JaredPar yöntemini öneririm:

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

Basit kontrol 2/3: Çalışma zamanı kontrolü

Main () öğesinde sizeof () yönteminin anlamlı olup olmadığını görmek için iki kez kontrol edin:

#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

Basit kontrol 3/3: Sağlam derleme zamanı kontrolü

Genel kural "her #define hata üreten bir #else ile bitmelidir" dir.

#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

Güncelleme 2017-01-17

Yorum yapan @AI.G:

4 yıl sonra (daha önce mümkün olup olmadığını bilmiyorum) çalışma zamanı kontrolünü statik assert kullanarak derleme zamanı kontrolüne dönüştürebilirsiniz: static_assert (sizeof (void *) == 4) ;. Şimdi her şey derleme zamanında yapılır :)

Ek Bölüm A

Gizli olarak, yukarıdaki kurallar tüm kod tabanınızı daha güvenilir hale getirmek için uyarlanabilir:

• Her if () ifadesi, uyarı veya hata oluşturan bir "else" ile biter.
• Her switch () ifadesi, bir uyarı veya hata oluşturan bir "default:" ile biter.

Bunun iyi çalışmasının nedeni, sizi her bir vakayı önceden düşünmeye ve doğru kodu yürütmek için "başka" kısımdaki (bazen hatalı) mantığa güvenmemeye zorlamasıdır.

Bu tekniği (diğerlerinin yanı sıra) ilk üretime verildiği günden (12 ay önce) 30.000 satırlık bir proje yazmak için kullandım.

İçinde tanımlanan makroları kullanabilmeniz gerekir stdint.h. Özellikle INTPTR_MAXtam olarak ihtiyacınız olan değer.

#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

Microsoft'un derleyicisinin bazı (tümü?) Sürümleri birlikte verilmez stdint.h. Neden olduğundan emin değilim, çünkü standart bir dosya. İşte kullanabileceğiniz bir sürüm:http://msinttypes.googlecode.com/svn/trunk/stdint.h

Bu, bir başlangıç ​​için Windows'ta çalışmaz. İster 32 bit ister 64 bit pencereler için derleme yapsanız, uzunlamasına ve ints 32 bittir. Bir işaretçinin boyutu 8 bayt olup olmadığını kontrol muhtemelen daha güvenilir bir yol olduğunu düşünüyorum.

Bunu yapabilirsin:

#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

"64 bit olarak derlendi" C ++ 'da iyi tanımlanmamıştır.

C ++, int, long ve gibi boyutlar için yalnızca alt sınırlar belirler void *. 64 bitlik bir platform için derlendiğinde bile int'in 64 bit olduğuna dair bir garanti yoktur. Model, örneğin 23 bit ints vesizeof(int *) != sizeof(char *)

Farklı programlama modelleri vardır64 bit platformlar için .

En iyi bahisiniz platforma özgü bir testtir. İkinci en iyi, taşınabilir kararınız 64 bit olan şeyde daha spesifik olmalıdır .

Kişisel yaklaşım çok uzakta değildi, ama yalnızca olmadığını kontrol ediyoruz longve intaynı büyüklüktedir. Teorik olarak, her ikisi de 64 bit olabilir, bu durumda kontrolünüz başarısız olur ve her ikisinin de 32 bit olduğunu varsayar. Burada, göreceli boyutlarını değil, türlerin boyutunu gerçekten kontrol eden bir kontrol vardır:

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

Prensip olarak, maksimum tanımlı sistem tanımlı makrosu olan herhangi bir tür için bunu yapabilirsiniz.

Standardın long long32 bit sistemlerde bile en az 64 bit olması gerektiğini unutmayın .

İnsanlar zaten programın derlenip derlenmediğini belirlemeye çalışacak yöntemler önerdi 32-bitveya 64-bit.

Ve static_assertmimarinin düşündüğünüz gibi olduğundan emin olmak için c ++ 11 özelliğini kullanabileceğinizi eklemek istiyorum ("rahatlamak").

Yani makroları tanımladığınız yerde:

#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

Aşağıdaki kod, mevcut ortamların çoğunda iyi çalışır:

  #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

Proje yapılandırmalarını tüm ortamlarınızda kullanabiliyorsanız, 64 ve 32 bitlik bir sembol tanımlamak kolaylaşır. Yani bunun gibi proje yapılandırmalarınız olur:

32 bit Hata Ayıklama
32 bit Sürüm
64 bit Hata Ayıklama
64 bit Sürüm

EDIT: Bunlar, hedeflenen yapılandırmalar değil, genel yapılandırmalardır. Onları ne istersen ara.

Bunu yapamazsan, Jared'ın fikrini seviyorum.

32-bit ve 64-bit kaynakları farklı dosyalara yerleştirip derleme sistemini kullanarak uygun kaynak dosyaları seçerdim.

Borçlanma repor 'ın üstünde mükemmel cevap ve 'birleştirerek daha iyi makrolar, daha iyi Flags Akıcı C' ++, bunu yapabilirsiniz:

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

Sonra şöyle kullanabilirsiniz:

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

Veya eklediğim ekstra makroyu kullanarak:

MYPROJ_IF_64_BIT_ELSE( DoMy64BitOperation(), DoMy32BitOperation() );

Bu yanıtı başka bir yanıtta açıklanan çalışma zamanı denetimi için bir kullanım durumu ve tam örnek olarak ekliyorum .

Programın 64 bit veya 32 bit (veya bu konuda başka) olarak derlenmiş olup olmadığını son kullanıcıya iletmek için kullandığım yaklaşım budur:

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

Derleme ve Test Etme

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