Data Type Ranges
For 32-bit and 64-bit compilers, Microsoft Visual C++ recognizes the types shown in the table below. Note that the following type also have unsigned forms:
-
int (unsigned int)
-
__int8 (unsigned __int8)
-
__int16 (unsigned __int16)
-
__int32 (unsigned __int32)
-
__int64 (unsigned __int64)
-
short (unsigned short)
-
long (unsigned long)
-
long long (unsigned long long)
| Type Name | Bytes | Other Names | Range of Values |
|---|---|---|---|
| int | 4 | signed | –2,147,483,648 to 2,147,483,647 |
| unsigned int | 4 | unsigned | 0 to 4,294,967,295 |
| __int8 | 1 | char | –128 to 127 |
| unsigned __int8 | 1 | unsigned char | 0 to 255 |
| __int16 | 2 | short, short int, signed short int | –32,768 to 32,767 |
| unsigned __int16 | 2 | unsigned short, unsigned short int | 0 to 65,535 |
| __int32 | 4 | signed, signed int, int | –2,147,483,648 to 2,147,483,647 |
| unsigned __int32 | 4 | unsigned, unsigned int | 0 to 4,294,967,295 |
| __int64 | 8 | long long, signed long long | –9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 |
| unsigned __int64 | 8 | unsigned long long | 0 to 18,446,744,073,709,551,615 |
| bool | 1 | none | false or true |
| char | 1 | none | –128 to 127 by default 0 to 255 when compiled with /J |
| signed char | 1 | none | –128 to 127 |
| unsigned char | 1 | none | 0 to 255 |
| short | 2 | short int, signed short int | –32,768 to 32,767 |
| unsigned short | 2 | unsigned short int | 0 to 65,535 |
| long | 4 | long int, signed long int | –2,147,483,648 to 2,147,483,647 |
| unsigned long | 4 | unsigned long int | 0 to 4,294,967,295 |
| long long | 8 | none (but equivalent to __int64) | –9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 |
| unsigned long long | 8 | none (but equivalent to unsigned __int64) | 0 to 18,446,744,073,709,551,615 |
| enum | varies | none | See Remarks. |
| float | 4 | none | 3.4E +/- 38 (7 digits) |
| double | 8 | none | 1.7E +/- 308 (15 digits) |
| long double | same as double | none | same as double |
| wchar_t | 2 | __wchar_t | 0 to 65,535 |
A variable of __wchar_t designates a wide-character or multibyte character type. By default wchar_t is a typedef for unsigned short. Use the L prefix before a character or string constant to designate the wide-character-type constant. When compiling with /Zc:wchar_t or /Za, the compiler can distinguish between an unsigned short and wchar_t for function overload purposes.
Signed and unsigned are modifiers that can be used with any integral type except bool. The char type behaves like signed char by default, but you can specify /J (compiler option) to make behave like unsigned char by default.
The int and unsigned int types have the size of the system word: four bytes. However, portable code should not depend on the size of int.
Microsoft C/C++ also features support for sized integer types. See __int8, __int16, __int32, __int64 for more information. Also see Integer Limits.
See Fundamental Types for more information on the restrictions of the sizes of each type.
The range of enumerated types varies depending on the language context and specified compiler flags. In C and C++ non-CLR enumerations, enumeration constants and values of enumerated types are expressed in terms of type int. C++ CLR enumerations may be backed by a specified scalar type. The range of an enumeration is defined as the smallest and largest values that can be stored in the bit-fields of the smallest and largest of its enumerators. However, the C++ compiler will allow any value within the range of the backing type of the enumeration to be specified (this may require a cast). For more information, refer to C Enumeration Declarations and C++ Enumeration Declarations.
-
3/10/2010
Win64 deliberately isolates itself from cross platform compatibility in order to NOT allow easy movement of programs from the windows platform to another (or vice-versa). Doing things like not following the 'standard ISO C99 example (which uses 64-bit longs, even though the language ALLOWS 32-bit, for compat with 32-bit platforms, most code written for a 64-bit platform runs about 10-15% faster than the 32-bit equiv. This is only another contributing factor for why Windows generally runs slower with the same resources than a linux platform (I have both, my windows hardware is about 30% faster, but runs about 30-50% slower than my linux platform) due to OS overhead.
You can see the the result of these choices by looking at a stack trace in process explorer or process hacker -- it is almost always the case that 3-4 calls per stack chain are for misaligned data -- something the x64 platform handles transparently, but costs you double to triple the access time for a 64-bit datum, and up to twice as slow for 32-bit misaligned data.
Memory has constantly been the slowest part of modern computers for the last 20-30 years. Doubling (or tripling) the access time to data due to misalignment is guaranteed to create a noticeable performance hit.
MS *USED* to have brilliant engineers on staff.. some of the best... then they all cashed in their stock options and left. Now? There are very few people at MS that really understand the whole 'stack' from drivers+kernel, up through the 'oh so well documented (not), DRM layer, and up into the user layer. Stack depths now can easily easily show 30-40 calls deep -- vs. half that or less on a linux. It's really a shame
- 2/29/2012
- Astara__
- 3/10/2010
- wroweil
Answer: http://blogs.msdn.com/oldnewthing/archive/2005/01/31/363790.aspx
- 10/17/2009
- Rob Grainger
- 11/19/2009
- Medinoc
- 3/22/2009
- msdn vc6快捷键
- 6/15/2009
- Thomas Lee
