What does the C++ standard state the size of int, long type to be?
The C++ standard does not specify the size of integral types in bytes, but it specifies minimum ranges they must be able to hold. You can infer minimum size in bits from the required range. You can infer minimum size in bytes from that and the value of the CHAR_BIT
macro that defines the number of bits in a byte. In all but the most obscure platforms it's 8, and it can't be less than 8.
One additional constraint for char
is that its size is always 1 byte, or CHAR_BIT
bits (hence the name). This is stated explicitly in the standard.
The C standard is a normative reference for the C++ standard, so even though it doesn't state these requirements explicitly, C++ requires the minimum ranges required by the C standard (page 22), which are the same as those from Data Type Ranges on MSDN:
-
signed char
: -127 to 127 (note, not -128 to 127; this accommodates 1's-complement and sign-and-magnitude platforms) -
unsigned char
: 0 to 255 - "plain"
char
: same range assigned char
orunsigned char
, implementation-defined -
signed short
: -32767 to 32767 -
unsigned short
: 0 to 65535 -
signed int
: -32767 to 32767 -
unsigned int
: 0 to 65535 -
signed long
: -2147483647 to 2147483647 -
unsigned long
: 0 to 4294967295 -
signed long long
: -9223372036854775807 to 9223372036854775807 -
unsigned long long
: 0 to 18446744073709551615
A C++ (or C) implementation can define the size of a type in bytes sizeof(type)
to any value, as long as
- the expression
sizeof(type) * CHAR_BIT
evaluates to a number of bits high enough to contain required ranges, and - the ordering of type is still valid (e.g.
sizeof(int) <= sizeof(long)
).
Putting this all together, we are guaranteed that:
-
char
,signed char
, andunsigned char
are at least 8 bits -
signed short
,unsigned short
,signed int
, andunsigned int
are at least 16 bits -
signed long
andunsigned long
are at least 32 bits -
signed long long
andunsigned long long
are at least 64 bits
No guarantee is made about the size of float
or double
except that double
provides at least as much precision as float
.
The actual implementation-specific ranges can be found in <limits.h>
header in C, or <climits>
in C++ (or even better, templated std::numeric_limits
in <limits>
header).
For example, this is how you will find maximum range for int
:
C:
#include <limits.h>
const int min_int = INT_MIN;
const int max_int = INT_MAX;
C++:
#include <limits>
const int min_int = std::numeric_limits<int>::min();
const int max_int = std::numeric_limits<int>::max();
For 32-bit systems, the 'de facto' standard is ILP32 — that is, int
, long
and pointer are all 32-bit quantities.
For 64-bit systems, the primary Unix 'de facto' standard is LP64 — long
and pointer are 64-bit (but int
is 32-bit). The Windows 64-bit standard is LLP64 — long long
and pointer are 64-bit (but long
and int
are both 32-bit).
At one time, some Unix systems used an ILP64 organization.
None of these de facto standards is legislated by the C standard (ISO/IEC 9899:1999), but all are permitted by it.
And, by definition, sizeof(char)
is 1
, notwithstanding the test in the Perl configure script.
Note that there were machines (Crays) where CHAR_BIT
was much larger than 8. That meant, IIRC, that sizeof(int)
was also 1, because both char
and int
were 32-bit.
In practice there's no such thing. Often you can expect std::size_t
to represent the unsigned native integer size on current architecture. i.e. 16-bit, 32-bit or 64-bit but it isn't always the case as pointed out in the comments to this answer.
As far as all the other built-in types go, it really depends on the compiler. Here's two excerpts taken from the current working draft of the latest C++ standard:
There are five standard signed integer types : signed char, short int, int, long int, and long long int. In this list, each type provides at least as much storage as those preceding it in the list.
For each of the standard signed integer types, there exists a corresponding (but different) standard unsigned integer type: unsigned char, unsigned short int, unsigned int, unsigned long int, and unsigned long long int, each of which occupies the same amount of storage and has the same alignment requirements.
If you want to you can statically (compile-time) assert the sizeof these fundamental types. It will alert people to think about porting your code if the sizeof assumptions change.
There is standard.
C90 standard requires that
sizeof(short) <= sizeof(int) <= sizeof(long)
C99 standard requires that
sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long)
Here is the C99 specifications. Page 22 details sizes of different integral types.
Here is the int type sizes (bits) for Windows platforms:
Type C99 Minimum Windows 32bit
char 8 8
short 16 16
int 16 32
long 32 32
long long 64 64
If you are concerned with portability, or you want the name of the type reflects the size, you can look at the header <inttypes.h>
, where the following macros are available:
int8_t
int16_t
int32_t
int64_t
int8_t
is guaranteed to be 8 bits, and int16_t
is guaranteed to be 16 bits, etc.
If you need fixed size types, use types like uint32_t (unsigned integer 32 bits) defined in stdint.h. They are specified in C99.