CODEWITHSUNDEEP
c++compilation32bit-64bit
slashmais
slashmais

Reputation: 7155

Is there a standard way to determine at compile-time if system is 32 or 64 bit?

I need to set #ifdef - checks for conditional compile. I want to automate the process but cannot specify the target OS/machine. Is there some way that the pre-compiler can resolve whether it it is running on 32-bit or 64-bit?

(Explanation) I need to define a type that is 64 bits in size. On 64bit OS it is a long, on most others it is a long long.

I found this answer - is this the correct way to go?

[edit] a handy reference for compiler macros

Upvotes: 7

Views: 4705

Answers (8)

rubenvb
rubenvb

Reputation: 76519

Boost has absorbed the old Predef project. You'll want the architecture macros, more specifically BOOST_ARCH_X86_32/BOOST_ARCH_X86_64, assuming you only care about x86.

If you need a wider detection (e.g. ARM64), either add the relevant macro's to your check, or check what you actually want to check, e.g.

sizeof(void*) == 8

Upvotes: 2

Michas
Michas

Reputation: 9428

I would look at source code for a cross-platform library. It is a quite large part. Every pair of OS and compiler has own set of definitions. Few libraries You may look at:
http://www.libsdl.org/ \include\SDL_config*.h (few files)
http://qt.nokia.com/ \src\corelib\global\qglobal.h

Upvotes: 2

Puppy
Puppy

Reputation: 146910

The only compile check you can do reliably would be sizeof(void*) == 8, true for x64 and false for x86. This is a constexpr and you can pass it to templates but you can forget using ifdef with it. There is no platform-independent way to know the address size of the target architecture (at pre-process time), you will need to ask your IDE for one. The Standard doesn't even have the concept of the address size.

Upvotes: 10

AlefSin
AlefSin

Reputation: 1095

Probably the easiest way might be comparing the size of int and long long. You cannot do it in the pre-processor though but you can use it in static_assert.

Edit: WoW all the negative votes. I made my point a bit more clear. Also it appears I should have mentioned 'long long' rather than 'long' because of the way MSVC works.

Upvotes: -2

In silico
In silico

Reputation: 52159

In response to your edit, there is a "macro-less for you" way to get a type that is 64 bits.

if you need a type that can hold 64 bits, then #include <cstdint> and use either int64_t or uint64_t. You can also use the Standard Integer Types provided by Boost.

Another option is to use long long. It's technically not part of the C++ standard (it will be in C++0x) but is supported on just about every compiler.

Upvotes: 4

Sparky
Sparky

Reputation: 14057

I would be tempted to hoist the detection out of the code and put that into the Makefile. Then, you can leverage system tools to detect and set the appropriate macro upon which you are switching in your code.

In your Makefile ...

<do stuff to detect and set SUPPORT_XX_BIT to the appropriate value>
gcc myFile.c -D$(SUPPORT_XX_BIT) -o myFile

In your code ...

#if defined(SUPPORT_32_BIT)
...
#elif defined(SUPPORT_64_BIT)
...
#else
    #error "Select either 32 or 64 bit option\n"
#endif

Upvotes: 0

iammilind
iammilind

Reputation: 69988

No there is no standard language support for macro to determine if the machine is a 64-bit or 32-bit at preprocessor stage.

Upvotes: 4

NPE
NPE

Reputation: 500347

Well, the answer is clearly going to be OS-specific, so you need to narrow down your requirements.

For example, on Unix uname -a typically gives enough info to distinguish a 32-bit build of the OS from a 64-bit build.

The command can be invoked by your pre-compiler. Depending on its output, compiler flags can be set appropriately.

Upvotes: 1

Related Questions