Thread: Create integer type that is always 32 bit

Technically it's not the case that char is always 1 byte (i.e., 8 bits).
The number of bits of a char is given by the CHAR_BIT macro in <limits.h>.

The proper way to get a 32-bit value is to use the modern <stdint.h> (or <inttypes.h> for printf and scanf formats, too).

Code:

#include <stdio.h>
#include <inttypes.h>   // also includes <stdint.h>

int main() {
    int32_t n = 12345;
    printf("%" PRId32 "\n", n);
    return 0;
}

A char is always 1 byte, but a byte only has to be a minimum of 8 bits.

Originally Posted by c99 draft

Annex E
(informative)
Implementation limits
1 The contents of the header<limits.h>are given below, in alphabetical order. The
minimum magnitudes shown shall be replaced by implementation-defined magnitudes
with the same sign. The values shall all be constant expressions suitable for use in#if
preprocessing directives. The components are described further in 5.2.4.2.1.
#define CHAR_BIT 8

The best you're going to manage is to use a bit-field and live with the braces in the initialiser.

Or you have some conditional code and some static assertions to make sure your type is exactly what you want.

Along the lines of

Code:

typedef int my32t;
STATIC_ASSERT((sizeof(my32t)*CHAR_BIT)==32,"32 bit int size failed");

Originally Posted by MartinR

Why not? Isn't that guaranteed that char must be 1 byte? Do you have some evidences that disclaim that?

Where's YOUR evidence, you lying piece of crap!

All that's guaranteed is that sizeof(char) is 1, but all that means is that the sizes of objects are calculated in multiples of the size of a char.

And in what sense did I "misunderstand" your question, you brainless idiot! You never mentioned anything about not using standard libraries.

Originally Posted by john.c

Where's YOUR evidence, you lying piece of crap!

That was uncalled for. I suggest that you restrain yourself from wildly insulting other members just because they requested that you provide evidence for something that they found contradicted what they thought they understood. After all, if you're right, you get to show that you're right in a way that's helpful.

Originally Posted by john.c

All that's guaranteed is that sizeof(char) is 1, but all that means is that the sizes of objects are calculated in multiples of the size of a char.

The evidence lies in the C standard:

Originally Posted by C11 Clause 6.5.3.4 Paragraph 2a

The sizeof operator yields the size (in bytes) of its operand, which may be an expression or the parenthesized name of a type.

So yes, because the sizes of objects are calculated in multiplies of the size of a char, and because the sizeof operator yields that size in bytes (as per C's notion of what constitutes a "byte"), it follows that in C, it is indeed "guaranteed that char must be 1 byte", therefore MartinR is proven correct. It is just that as Hodor noted, outside of C there's a strong prevalent convention that a byte is 8 bits, whereas C also caters for systems where a "byte" as known to the system may be more than 8 bits, hence you rightly mentioned CHAR_BIT.

Originally Posted by MartinR

Sure I can but this subject is more about how to define such type using standard C types - char for example (assuming char is 8 bits).

Is this merely an exercise to satisfy your curiosity, or is this a requirement for an actual program to be released in production such that you cannot even use the C standard library and hence cannot use what john.c suggested in post #2?

Well the whole point of the standard includes is that it takes all the guess-work out of doing the right thing.

Otherwise you need Pre-defined Compiler Macros / Wiki / Home and a very long list of conditional compilation flags, followed by the static assertion I posted earlier.

Code:

#if defined(WIN32) && defined(MSVC)
typedef int my32t;
#elif defined(DOS) && defined(MSVC)
typedef long int my32t;
#elif defined(LINUX)
typedef int my32t;
#elif // ad nauseam
#else
  #error "Invalid Platform/compiler combo"
#endif

If what you're proposing was that easy on a standard compiler, then stdint wouldn't exist because there would be no need for it.

An unadorned int in C has traditionally aligned itself with the natural register and/or bus width of the target architecture, to be as efficient as possible.

Also, an unadorned int only needs to hold signed 16-bit values to be compliant with the standards. If you want a guaranteed 'at least 32-bits' integer, then choose long int.