Определение 32 против 64 бит в C ++

Я ищу способ надежно определить, компилируется ли код C ++ в 32 против 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;
}

К сожалению, в кросс-платформенной среде кросс-компиляции не существует единого надежного способа сделать это исключительно во время компиляции.

• Оба _WIN32 и _WIN64 иногда и неопределенные, если параметры проекта испорчены или повреждены (особенно на Visual Studio 2008 SP1).
• Проект с пометкой «Win32» может быть установлен на 64-разрядную версию из-за ошибки конфигурации проекта.
• В Visual Studio 2008 с пакетом обновления 1 (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: static_assert (sizeof (void *) == 4) ;. Теперь все это делается во время компиляции :)

Приложение

Кстати, приведенные выше правила могут быть адаптированы, чтобы сделать всю вашу кодовую базу более надежной:

• Каждый оператор if () заканчивается на «else», которое генерирует предупреждение или ошибку.
• Каждый оператор switch () заканчивается значением «default:», которое генерирует предупреждение или ошибку.

Причина того, что это работает хорошо, заключается в том, что он заставляет вас заранее думать о каждом отдельном случае, а не полагаться на (иногда ошибочную) логику в части «else» для выполнения правильного кода.

Я использовал эту технику (среди многих других), чтобы написать 30-тысячный линейный проект, который работал безупречно со дня, когда он был впервые запущен в производство (это было 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

Некоторые (все?) Версии компилятора Microsoft не входят в комплект stdint.h. Не знаю почему, так как это стандартный файл. Вот версия, которую вы можете использовать:http://msinttypes.googlecode.com/svn/trunk/stdint.h

Это не будет работать на Windows для начала. Long и int являются 32-битными, независимо от того, компилируете ли вы для 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, long и 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-разрядного символа. Таким образом, у вас будут такие конфигурации проекта:

32-битная отладка
32-разрядная версия
64-разрядная отладка
64-разрядная версия

РЕДАКТИРОВАТЬ: это общие конфигурации, а не целевые конфигурации. Называй их как хочешь.

Если ты не можешь сделать это, мне нравится идея Джареда.

Я помещал 32-битные и 64-битные источники в разные файлы, а затем выбирал подходящие исходные файлы, используя систему сборки.

Заимствования из репорт «s отличного ответа выше , и сочетая его с„ Лучше Макросами, 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]