Not to long ago, someone told me that
long are not 64 bits on 64 bit machines and I should always use
int. This did not make sense to me. I have seen docs (such as the one on Apple's official site) say that
long are indeed 64 bits when compiling for a 64-bit CPU. I looked up what it was on 64-bit Windows and found
intremain 32-bit in length, and special new data types are defined for 64-bit integers.
What should I use? Should I define something like
sw ((un)signed width) as a
long if not on Windows, and otherwise do a check on the target CPU bitsize?
In the Unix world, there were a few possible arrangements for the sizes of integers and pointers for 64-bit platforms. The two mostly widely used were ILP64 (actually, only a very few examples of this; Cray was one such) and LP64 (for almost everything else). The acronynms come from 'int, long, pointers are 64-bit' and 'long, pointers are 64-bit'.
Type ILP64 LP64 LLP64 char 8 8 8 short 16 16 16 int 64 32 32 long 64 64 32 long long 64 64 64 pointer 64 64 64
The ILP64 system was abandoned in favour of LP64 (that is, almost all later entrants used LP64, based on the recommendations of the Aspen group; only systems with a long heritage of 64-bit operation use a different scheme). All modern 64-bit Unix systems use LP64. MacOS X and Linux are both modern 64-bit systems.
Microsoft uses a different scheme for transitioning to 64-bit: LLP64 ('long long, pointers are 64-bit'). This has the merit of meaning that 32-bit software can be recompiled without change. It has the demerit of being different from what everyone else does, and also requires code to be revised to exploit 64-bit capacities. There always was revision necessary; it was just a different set of revisions from the ones needed on Unix platforms.
If you design your software around platform-neutral integer type names, probably using the C99
<inttypes.h> header, which, when the types are available on the platform, provides, in signed (listed) and unsigned (not listed; prefix with 'u'):
int8_t- 8-bit integers
int16_t- 16-bit integers
int32_t- 32-bit integers
int64_t- 64-bit integers
uintptr_t- unsigned integers big enough to hold pointers
intmax_t- biggest size of integer on the platform (might be larger than
You can then code your application using these types where it matters, and being very careful with system types (which might be different). There is an
intptr_t type - a signed integer type for holding pointers; you should plan on not using it, or only using it as the result of a subtraction of two
uintptr_t values (
But, as the question points out (in disbelief), there are different systems for the sizes of the integer data types on 64-bit machines. Get used to it; the world isn't going to change.