การหา 32 vs 64 บิตใน C ++

ฉันกำลังมองหาวิธีที่เชื่อถือได้ตรวจสอบว่ารหัส C ++ จะถูกรวบรวมใน 32 vs 64 บิต เราเกิดขึ้นกับสิ่งที่เราคิดว่าเป็นวิธีแก้ปัญหาที่สมเหตุสมผลโดยใช้มาโคร แต่ก็อยากรู้ว่าคนอื่นจะนึกถึงกรณีที่อาจล้มเหลวหรือมีวิธีที่ดีกว่าในการทำเช่นนี้ โปรดทราบว่าเรากำลังพยายามทำสิ่งนี้ในสภาพแวดล้อมคอมไพเลอร์แบบหลายแพลตฟอร์ม

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

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

ขอบคุณ

น่าเสียดายที่ไม่มีมาโครข้ามแพลตฟอร์มซึ่งกำหนด 32/64 บิตในคอมไพเลอร์หลัก ฉันพบวิธีที่มีประสิทธิภาพที่สุดในการทำสิ่งต่อไปนี้

ก่อนอื่นฉันเลือกตัวแทนของตัวเอง ฉันชอบ ENVIRONMENT64 / ENVIRONMENT32 จากนั้นฉันก็พบว่าคอมไพเลอร์หลักทั้งหมดใช้ในการพิจารณาว่ามันเป็นสภาพแวดล้อม 64 บิตหรือไม่และใช้เพื่อตั้งค่าตัวแปรของฉัน

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

อีกเส้นทางที่ง่ายขึ้นคือการตั้งค่าตัวแปรเหล่านี้จากบรรทัดคำสั่งคอมไพเลอร์

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

โชคไม่ดีที่ใน cross platform, cross compiler environment ไม่มีวิธีการที่เชื่อถือได้เพียงวิธีเดียวในการรวบรวมเวลา

• ทั้ง _WIN32 และ _WIN64 สามารถบางครั้งทั้งสองไม่ได้กำหนดถ้าการตั้งค่าโครงการมีข้อบกพร่องหรือเสียหาย (โดยเฉพาะอย่างยิ่งใน Visual Studio 2008 SP1)
• โครงการที่ชื่อว่า "Win32" สามารถตั้งค่าเป็น 64- บิตได้เนื่องจากข้อผิดพลาดของการกำหนดค่าโครงการ
• ใน Visual Studio 2008 SP1 บางครั้ง Intellisense จะไม่ทำให้ส่วนที่ถูกต้องของรหัสเป็นไปตาม #define ปัจจุบัน สิ่งนี้ทำให้เป็นการยากที่จะดูว่า #define ใดถูกใช้ในเวลารวบรวม

ดังนั้นวิธีการที่เชื่อถือได้เพียงวิธีเดียวคือการรวมการตรวจสอบง่าย ๆ 3 รายการ :

• 1) การตั้งค่าเวลารวบรวมและ;
• 2) การตรวจสอบรันไทม์และ;
• 3) การตรวจสอบรวบรวมเวลาที่แข็งแกร่ง

ตรวจสอบง่าย 1/3: การตั้งค่าเวลาคอมไพล์

เลือกวิธีการใด ๆ เพื่อตั้งค่าตัวแปร #define ที่ต้องการ ฉันแนะนำวิธีการจาก @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

ตรวจสอบง่าย 2/3: การตรวจสอบรันไทม์

ใน main () ให้ตรวจสอบอีกครั้งเพื่อดูว่า sizeof () สมเหตุสมผลหรือไม่:

#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

การตรวจสอบง่าย 3/3: การตรวจสอบเวลารวบรวมอย่างมีประสิทธิภาพ

กฎทั่วไปคือ "ทุก #define ต้องลงท้ายด้วย #else ซึ่งสร้างข้อผิดพลาด"

#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

อัปเดต 2017-01-17

ความคิดเห็นจาก@AI.G:

4 ปีต่อมา (ไม่ทราบว่าเป็นไปได้มาก่อนหรือไม่) คุณสามารถแปลงการตรวจสอบเวลาทำงานเป็นการรวบรวมเวลาโดยใช้การยืนยันแบบคงที่: static_assert (sizeof (void *) == 4); ตอนนี้มันก็ทำตอนรวบรวม :)

ภาคผนวกก

อนึ่งกฎดังกล่าวสามารถปรับให้ฐานข้อมูลทั้งหมดของคุณเชื่อถือได้มากขึ้น:

• คำสั่ง if () ทุกคำลงท้ายด้วย "else" ซึ่งสร้างคำเตือนหรือข้อผิดพลาด
• คำสั่ง switch () ทุกคำลงท้ายด้วย "default:" ซึ่งสร้างคำเตือนหรือข้อผิดพลาด

เหตุผลที่ทำให้การทำงานดีคือมันบังคับให้คุณคิดทุกกรณีล่วงหน้าและไม่พึ่งพาตรรกะ (บางครั้งมีข้อบกพร่อง) ในส่วน "อื่น" เพื่อรันโค้ดที่ถูกต้อง

ฉันใช้เทคนิคนี้ (ท่ามกลางคนอื่น ๆ ) เพื่อเขียนโครงการ 30,000 เส้นที่ทำงานได้อย่างไร้ที่ตินับตั้งแต่วันที่มันถูกนำไปใช้ในการผลิตครั้งแรก (นั่นคือ 12 เดือนที่แล้ว)

stdint.hคุณควรจะสามารถที่จะใช้แมโครที่กำหนดไว้ใน โดยเฉพาะอย่างยิ่งINTPTR_MAXเป็นค่าที่คุณต้องการ

#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

บางคน (ทั้งหมด?) stdint.hรุ่นของคอมไพเลอร์ไมโครซอฟท์ไม่ได้มาด้วย ไม่แน่ใจว่าทำไมเพราะมันเป็นไฟล์มาตรฐาน นี่คือรุ่นที่คุณสามารถใช้ได้:http://msinttypes.googlecode.com/svn/trunk/stdint.h

สิ่งนี้จะไม่ทำงานบน Windows สำหรับการเริ่มต้น longs และ ints มีทั้ง 32 บิตไม่ว่าคุณจะคอมไพล์สำหรับ windows 32 บิตหรือ 64 บิต ฉันคิดว่าการตรวจสอบว่าขนาดของตัวชี้เป็น 8 ไบต์น่าจะเป็นเส้นทางที่เชื่อถือได้มากกว่าหรือไม่

คุณสามารถทำได้:

#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 บิต" ไม่ได้ถูกนิยามไว้อย่างดีใน C ++

c ++ ชุดเฉพาะข้อ จำกัด ที่ต่ำกว่าสำหรับขนาดเช่น int void *และยาว ไม่มีการรับประกันว่า int เป็น 64 บิตแม้เมื่อรวบรวมสำหรับแพลตฟอร์ม 64 บิต รูปแบบที่ช่วยให้เช่น 23 บิตintและsizeof(int *) != sizeof(char *)

มีรูปแบบการเขียนโปรแกรมที่แตกต่างกันสำหรับแพลตฟอร์ม 64 บิต

ทางออกที่ดีที่สุดของคุณคือการทดสอบเฉพาะแพลตฟอร์ม การตัดสินใจแบบพกพาที่ดีที่สุดอันดับสองของคุณจะต้องเจาะจงมากขึ้นในสิ่งที่ 64 บิต

วิธีการของคุณไม่ได้ไกลเกินไป แต่คุณเป็นเพียงการตรวจสอบว่าlongและintมีขนาดเดียวกัน ในทางทฤษฎีทั้งคู่อาจเป็น 64 บิตซึ่งในกรณีนี้เช็คของคุณจะล้มเหลวโดยสมมติว่าทั้งสองเป็น 32 บิต นี่คือการตรวจสอบที่ตรวจสอบขนาดจริง ๆ ของตัวเองไม่ใช่ขนาดที่เกี่ยวข้อง:

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

โดยหลักการคุณสามารถทำสิ่งนี้ได้ทุกประเภทที่คุณมีมาโครที่ระบบกำหนดด้วยค่าสูงสุด

โปรดทราบว่ามาตรฐานนั้นต้องlong longมีอย่างน้อย 64 บิตแม้ในระบบ 32 บิต

ผู้คนได้แนะนำวิธีการต่าง ๆ ที่จะพยายามตรวจสอบว่ามีการรวบรวมโปรแกรม32-bitหรือ64-bitไม่

และฉันต้องการเพิ่มว่าคุณสามารถใช้คุณสมบัติ c ++ 11 static_assertเพื่อให้แน่ใจว่าสถาปัตยกรรมเป็นสิ่งที่คุณคิดว่าเป็น ("เพื่อผ่อนคลาย")

ดังนั้นในสถานที่ที่คุณกำหนดมาโคร:

#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

โค้ดด้านล่างทำงานได้ดีสำหรับสภาพแวดล้อมส่วนใหญ่ในปัจจุบัน:

  #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

หากคุณสามารถใช้การกำหนดค่าโครงการในทุกสภาพแวดล้อมของคุณนั่นจะทำให้การกำหนดสัญลักษณ์ 64 และ 32 บิตเป็นเรื่องง่าย ดังนั้นคุณจะมีการกำหนดค่าโครงการเช่นนี้:

Debug
32- บิต Debug 32- บิต Debug 32-
บิต
64- บิต

แก้ไข: นี่คือการกำหนดค่าทั่วไปไม่ใช่การกำหนดค่าที่กำหนดเป้าหมาย เรียกพวกเขาทุกอย่างที่คุณต้องการ

ถ้าคุณทำอย่างนั้นไม่ได้ฉันชอบความคิดของเจเร็ด

ฉันต้องการวางซอร์ส 32- บิตและ 64- บิตในไฟล์ต่าง ๆ จากนั้นเลือกไฟล์ต้นฉบับที่เหมาะสมโดยใช้ระบบบิลด์

การยืมจากคำตอบที่ยอดเยี่ยมของContangoและรวมกับ " Better Macros, Better Flags " จาก Fluent C ++ คุณสามารถทำได้:

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

จากนั้นคุณสามารถใช้มันเช่น:

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

หรือใช้มาโครพิเศษที่ฉันเพิ่ม:

MYPROJ_IF_64_BIT_ELSE( DoMy64BitOperation(), DoMy32BitOperation() );

ฉันกำลังเพิ่มคำตอบนี้เป็นกรณีการใช้งานและตัวอย่างที่สมบูรณ์สำหรับการตรวจสอบรันไทม์ที่อธิบายไว้ในคำตอบอื่นคำตอบอื่น

นี่เป็นวิธีที่ฉันใช้ในการสื่อความหมายถึงผู้ใช้ปลายทางไม่ว่าโปรแกรมจะถูกรวบรวมเป็น 64 บิตหรือ 32 บิต (หรืออื่น ๆ สำหรับเรื่องนั้น):

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

รวบรวมและทดสอบ

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