Thread: uint8, 16 noob question

It's an unsigned 8-bit integer... meaning to say it accepts the values of 0-255 without overflowing.

It can be used anywhere you need a really small integer... ever wonder why in most Final Fantasy games the highest a player stat can go is 255?

The number of bits used to represent the integer. I guess you use these versions when you need to be sure of the exact size of the variable you are creating. Simply stating 'int' only gives you an approximation on the size. You can also use these to increase the maximum possible value stored. Sometimes you could need a 'large' integer and store it in an unsigned __int32. For anything bigger than that, you'll need a big-number library like GMP.

Originally Posted by Desolation

Sometimes you could need a 'large' integer and store it in an unsigned __int32. For anything bigger than that, you'll need a big-number library like GMP.

I believe __int64 is also standard.

When in doubt, and if your IDE makes it easy to look for definitions, you can always search for the definition of a non user-defined type.

unsigned __int8 is a typedef. Depending on your compiler implementation, it's quite possible that it is defined as:

Code:

typedef unsigned char unsigned __int8;

Which means it is the equivalent of a unsigned char.

Originally Posted by SlyMaelstrom

I believe __int64 is also standard.

I think it is as well but wouldn't you need a 64 bit processor ?

Originally Posted by Mario F.

Which means it is the equivalent of a unsigned char.

Which I must say is super lame especially if you expect your __int8 to output an integer without any cast.

They aren't typedefs in MSVC++. =]

Nor are they "standard", except for in Microsoft compilers (I think).

So it would appear... in that case, I feel like they could make a decent addition to the standard (not as typedefs but actual types), because they've served me well in the past and I've yet to run into a compiler that didn't compile them.

C99 has them. I think they're called intX_t and uintX_t in <stdint.h>.

Yes, except that an unsigned short could be larger than 2 bytes, whereas a uint16 (or a variation) will always be 2 bytes. This can be useful.

NONE of these are mentioned in the ANSI/ISO standard. (The leading undorescore is a hint.)

__int8, __int16, __int32, __int64

Microsoft Specific
Microsoft C/C++ features support for sized integer types. You can declare 8-, 16-, 32-, or 64-bit integer variables by using the __intn type specifier, where n is 8, 16, 32, or 64.

The following example declares one variable for each of these types of sized integers:

__int8 nSmall; // Declares 8-bit integer
__int16 nMedium; // Declares 16-bit integer
__int32 nLarge; // Declares 32-bit integer
__int64 nHuge; // Declares 64-bit integer

The types __int8, __int16, and __int32 are synonyms for the ANSI types that have the same size, and are useful for writing portable code that behaves identically across multiple platforms. Note that the __int8 data type is synonymous with type char, __int16 is synonymous with type short, and __int32 is synonymous with type int. The __int64 type has no ANSI equivalent.

C++ Specific
Because __int8, __int16, and __int32 are considered synonyms by the compiler, care should be taken when using these types as arguments to overloaded function calls.

But, much of C99 is going to be included in the new standard. I don't know the details, but I think I've read that long long int will be part of the new standard.

I believe __int64 is also standard....

...I think it is as well but wouldn't you need a 64 bit processor ?

No! The compiler can store a single variable in a series of consecutive memory locations. You can run Standard ANSI C/C++ on an 8-bit machine, even though Standard C/C++ requires a long int to hold at least 32 bits. If something is part of the standard, then it can't require any special hardware... All C++ compilers are supposed to include it.