5

The 8-bit,16-bit,32-bit,64-bit operating systems have different data range for integers,float and double values.

Is this the compiler or the processor that makes difference(8bit,16bit,32bit,64bit).

If in a network if a 16 bit integer data from one system is transferred to a 32 bit system or vice-versa will the data be correctly represented in memory.Please help me to understand.

Sajad Bahmani
  • 17,325
  • 27
  • 86
  • 108
Angus
  • 12,133
  • 29
  • 96
  • 151
  • possible duplicate of [Does the size of an int depend on the compiler and/or processor?](http://stackoverflow.com/questions/2331751/does-the-size-of-an-int-depend-on-the-compiler-and-or-processor) – progrmr Sep 01 '11 at 11:34

5 Answers5

7

Ultimately, it is up to the compiler. The compiler is free to choose any data types it likes*, even if it has to emulate their behaviour with software routines. Of course, typically, for efficiency it will try to replicate the native types of the underlying hardware.

As to your second question, yes, of course, if you transfer the raw representation from one architecture to another, it may be interpreted incorrectly (endianness is another issue). That is why functions like ntohs() are used.

* Well, not literally anything it likes. The C standard places some constraints, such as that an int must be at least as large as a short.

Oliver Charlesworth
  • 267,707
  • 33
  • 569
  • 680
  • I think it rather replicates the types used by the underlying OS. E.g. on Linux 64bit on Intel, long int is 64 bit, while in Windows 64bit it is 32 bit, on the same processor. The native register type is 64 bit in both occasions. – Rudy Velthuis Sep 01 '11 at 12:04
  • Actually the C standard imposes some restrictions on what types the compiler may choose. For instance, if `int` is 16 bits, `short` can't be 32 bits. – JeremyP Sep 01 '11 at 13:06
3

The compiler (more properly the "implementation") is free to choose the sizes, subject to the limits in the C standard. The set of sizes offered by C for its various types depends in part on the hardware it runs on; i.e. the compiler makes the choice but, it (except in cases like Java where datatypes are explicitly independent of underlying hardware) is strongly influenced by what the hardware offers.

Abimaran Kugathasan
  • 31,165
  • 11
  • 75
  • 105
2

It depends not on just the compiler and operating system. It is dictated by the architecture (processor at least).

When passing data between possibly different architectures they use special fixed size data type, e.g. uint64_t, uint32_t instead of int, short etc.

But the size of integers is not the only concern when communicating between computers with different architectures, there's a byte order issue too (try googling about BigEndian and LittleEndian)

unkulunkulu
  • 11,576
  • 2
  • 31
  • 49
1

The size of a given type depends on the CPU and the conventions on the operating system.

If you want to have an int of a specific size, use the stdint.h header [wikipedia]. It defines the int8_t, int16_t, int32_t, int64_t, some others and their unsigned equivalent.

For communications between different computers, the protocol should define the sizes and byte order to use.

Arnaud Le Blanc
  • 98,321
  • 23
  • 206
  • 194
  • 2
    Ultimately, though, it is the compiler that chooses what sizes/endianness/etc. to expose for its data types. Not the hardware. – Oliver Charlesworth Sep 01 '11 at 11:31
  • That's right, but the compiler's choices depend on the hardware and conventions of the operating system. – Arnaud Le Blanc Sep 01 '11 at 11:35
  • Some compilers (for rare architectures) may not provide the fixed width types in the `` header. They must be defined only for an architecture where it makes sense to have them (... think computers with 9-bit bytes). – pmg Sep 01 '11 at 11:37
  • @arnaud576875: Actually, the compiler can ignore the conventions of the hardware / operating system if it so chooses. – JeremyP Sep 01 '11 at 13:09
1

In a network it has to be defined in the protocol which data sizes you have. For endianness, it is highly recommended to use big endian values.

If there weren't the issue with the APIs, a compiler would be free to set its short, int, long as it wants. Bot often, the API calls are connected to these types. E.g. the open() function returns an int, whose size should be correct.

But the types might as well be part of the ABI definition.

glglgl
  • 89,107
  • 13
  • 149
  • 217