I'm wondering what integer types people typically use here rather than just the standard uint and int. The size of the integer (4 bytes, 8 bytes, etc.) can change from system to system and make it easy for your game to work on one system but totally flop on another. What one needs is a set of integer types that are guaranteed to be the same size across all systems. So basically what I'm looking for is a set of integer types that: - have a static size - are available on multiple architectures and operating systems (my game is cross-platform) - (preferrably) are supported natively on major compilers At work I was introduced to using the types defined in inttypes.h. I was able to compile my source using those types on both x86 and PowerPC with GCC, but I don't know if that header is something specific to the GNU C libraries or not. Basically to use it you would do this (C++):

#include <inttypes.h>

int32_t var1;  // A signed 32-bit integer
uint32_t var2; // An unsigned 32-bit integer

And there are other sizes as well of course. Anyone have experience to share with variable type selection? EDIT: By the way my game uses SDL, which I think uses types like Uint32...? [Edited by - Roots on August 17, 2005 9:26:34 PM]

Quote:Original post by snk_kid
The C99 standard provides fixed sized integral types. As of this moment standard C++ does not incorporate them (its being considered & reviewed as we speak) but some compilers provide them as an extension or provide some form of fixed sized integral types so if you can get your hands on the boost library they have a a cross platform implementation of C99 fixed sized integral types for C++ check here

Hmm, well if possible I would like a solution that didn't require introducing a huge code library as a dependance (especially if we're only using it for one or two small things). Thanks for the info though.


On a side note, I noticed you have a quote from School Rumble in your sig. I translated almost all of the School Rumble manga for <a href="http://www.yanime.com/>Yanime by the way. [grin]

I've found that as long as I can refer to the bounds properly [ala numeric_limits<foo>] I often don't care about the size of the type.

Quote:Original post by Telastyn
I've found that as long as I can refer to the bounds properly [ala numeric_limits<foo>] I often don't care about the size of the type.

When using/computing values this is often true. However, when you want to serialize data in a binary form having the sizes be consistent across platforms comes in mighty handy.

-John