Thread: how to get Data Type Size Independet of System?

Hello!!

I'm programming functions to differents system (Unix, Solaris, Microcontrolers,...) and I just need tu use data tipe with constat size independently of the system. I've heard there are some pre-processing intructions to force these sizes.

More exactly, I'm looking for:

int --> 4 bytes
short --> 2 bytes
float --> 4 bytes
double --> 8 bytes
(char is alwais 1 bytes in ASCII compatible system)

Thanks so much!!

Pablo, from Barcelona

Originally Posted by matsp

I would also add a piece of code that does like this (somewhere in the early part of the code, e.g. in main):

Code:

if (sizeof(int32) != 4) { printf("sizeof(int32) is not 4, it is %d\n", (int)sizeof(int32)); }

On the philosophy of "make an error occur at compile time rather than run time" I wouldn't do that. For example, with an int16 type, use the following sort of logic.

Code:

#include <limits.h>
#if SHRT_MIN == -32767 && SHRT_MAX == 32767
typedef short int16;
#elif   /*  do other tests to find an appropriate int16 type */
#else
/*    trigger compiler error if we cannot find a suitable int16 type *.
#error short is not 2 8-bit bytes
#endif

The macros SHRT_MIN and SHRT_MAX specify the minimum and maximum value that can be stored in a short, respectively. For long the corresponding macros are LONG_MIN and LONG_MAX, and for long long LLONG_MIN and LLONG_MAX. For unsigned types, the macros to check are USHRT_MAX, ULONG_MAX, and ULLONG_MAX (no corresponding _MIN macros as, for unsigned types, the minimum value is zero).

In general, it is not possible to force the size of short/int/long/long long to particular values via the preprocessor. It is, with only a few compilers, possible to select sizes via command line options or other compiler-configuration options. Hence I agree with providing a set of typedefs for types of required sizes.

I'll leave floating point types alone, as they are trickier, but the macros are in <float.h> for checking properties of floating point types. However, keep in mind that there is at least one machine where a float is 8 bytes and a double is 16 (that machine does not support 4 byte floating point at all). sizeof() for floating point types is the least of your worries -- floating point types have exponent and mantissa fields, which are both of variable sizes.

I would tend to query that, matsp.

The range of values that can be stored in a variable correlates directly with its size (and correlates exactly with all real-world computing devices that are based on binary representations). The range [-32767, 32767] (+/- one on one end or the other, but that's only a minor wrinkle) is the range that can be represented using two 8-bit characters. i.e. if we assume a char is 8-bit, sizeof(short) will be 2 if it can represent exactly that range.

In practice, for example, when deciding what size integer to use the most common considerations are memory usage, speed of operations on the type, and the range of values that can be stored. You will not try to use a 16 bit signed integer to represent 40000, for example.

http://en.wikipedia.org/wiki/Stdint.h#New_integer_types

Originally Posted by Prelude

>char is alwais 1 bytes in ASCII compatible system
Actually, ASCII has nothing to do with it. char isn't required to be 1 byte (presumably you're thinking of an octet) even on an "ASCII compatible system", but sizeof(char) is guaranteed to be 1.

My understanding was that in the context of C/C++, a byte by definition was whatever the size of a char is (so one can say that sizeof() returns the size in bytes, with sizeof(char) always being 1, but a C/C++ byte isn't necessarily 8 bits).