Preprocessor macro to identify 64bit
Duplicate Question:
Is there a GCC preprocessor directive to check if the code is being compiled on a 64 bit machine?
__LP64__
Seems to be what you want.
What preprocessor directive or other method should I use to discern 32- vs 64-bit environment?
See here for a similar question.
LP64
_LP64
These macros are defined, with value 1, if (and only if) the
compilation is for a target where long
int and pointer both use 64-bits and
int uses 32-bit.
Detecting 64bit compile in C
Since you tagged this "gcc", try
#if __x86_64__
/* 64-bit */
#endif
How do I check OS with a preprocessor directive?
The Predefined Macros for OS site has a very complete list of checks. Here are a few of them, with links to where they're found:
Windows
_WIN32
Both 32 bit and 64 bit_WIN64
64 bit only__CYGWIN__
Unix (Linux, *BSD, but not Mac OS X)
See this related question on some of the pitfalls of using this check.
unix
__unix
__unix__
Mac OS X
__APPLE__
Also used for classic__MACH__
Both are defined; checking for either should work.
Linux
__linux__
linux
Obsolete (not POSIX compliant)__linux
Obsolete (not POSIX compliant)
FreeBSD
__FreeBSD__
Android
__ANDROID__
How to check (via the preprocessor) if a C source file is being compiled as C++ code
#ifndef __cplusplus
If I remember correctly.
How can I detect if I'm compiling for a 64bits architecture in C++
Why are you choosing one block over the other? If your decision is based on the size of a pointer, use sizeof(void*) == 8
. If your decision is based on the size of an integer, use sizeof(int) == 8
.
My point is that the name of the architecture itself should rarely make any difference. You check only what you need to check, for the purposes of what you are going to do. Your question does not cover very clearly what your purpose of the check is. What you are asking is akin to trying to determine if DirectX is installed by querying the version of Windows. You have more portable and generic tools at your disposal.
Is there a a define for 64 bit in gcc
I know of these:
__i386__
__x86_64__
I don't know how reliable they are.
The best option would be adding -DMY_32BIT
to the Makefile's compile line when compiling for 32 bits and checking for MY_32BIT
on your code. That way you can be sure.
Determining 32 vs 64 bit in C++
Unfortunately there is no cross platform macro which defines 32 / 64 bit across the major compilers. I've found the most effective way to do this is the following.
First I pick my own representation. I prefer ENVIRONMENT64 / ENVIRONMENT32. Then I find out what all of the major compilers use for determining if it's a 64 bit environment or not and use that to set my variables.
// 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
Another easier route is to simply set these variables from the compiler command line.
How to detect reliably Mac OS X, iOS, Linux, Windows in C preprocessor?
There are predefined macros that are used by most compilers, you can find the list here. GCC compiler predefined macros can be found here.
Here is an example for gcc:
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
//define something for Windows (32-bit and 64-bit, this part is common)
#ifdef _WIN64
//define something for Windows (64-bit only)
#else
//define something for Windows (32-bit only)
#endif
#elif __APPLE__
#include <TargetConditionals.h>
#if TARGET_IPHONE_SIMULATOR
// iOS, tvOS, or watchOS Simulator
#elif TARGET_OS_MACCATALYST
// Mac's Catalyst (ports iOS API into Mac, like UIKit).
#elif TARGET_OS_IPHONE
// iOS, tvOS, or watchOS device
#elif TARGET_OS_MAC
// Other kinds of Apple platforms
#else
# error "Unknown Apple platform"
#endif
#elif __ANDROID__
// Below __linux__ check should be enough to handle Android,
// but something may be unique to Android.
#elif __linux__
// linux
#elif __unix__ // all unices not caught above
// Unix
#elif defined(_POSIX_VERSION)
// POSIX
#else
# error "Unknown compiler"
#endif
The defined macros depend on the compiler that you are going to use.
The _WIN64
#ifdef
can be nested into the _WIN32
#ifdef
because _WIN32
is even defined when targeting the Windows x64 version. This prevents code duplication if some header includes are common to both
(also WIN32
without underscore allows IDE to highlight the right partition of code).
Related Topics
How Is Tr1::Reference_Wrapper Useful
Why Is a C++ Bool Var True by Default
Why C++ Doesn't Support Named Parameter
What Is the Purpose of Max_Digits10 and How Is It Different from Digits10
What Are the Advantages and Disadvantages of Implementing Classes in Header Files
Using 'Void' Template Arguments in C++
Understanding Rvalue References
C++ Class Member Function Callback
What Is the Array Form of 'Delete'
How to Implement "_Mm_Storeu_Epi64" Without Aliasing Problems
What Does Exactly the Warning Mean About Hidden Symbol Being Referenced by Dso
How to Find If a Variable Is Allocated in Stack or Heap
How to Overload Array Index Operator for Wrapper Class of 2D Array