Why do we use explicit data types? (from a low level point of view)

user_9009270 0
Viewed 135

When we take a look at some fundamental data types, such as char and int, we know that a char is simply an unsigned byte (depending on the language), int is just a signed dword, bool is just a char that can only be 1 or 0, etc. My question is, why do we use these types in compiled languages instead of just declaring a variable of type byte, dword, etc, since the operations applied to the types mentionned above are pretty much all the same, once you differentiate signed and unsigned data, and floating point data?

To extend the context of the question, in the C language, if and while statements can take a boolean value as an input, which is usually stored as a char, which exausts the need for an explicit boolean type.

In practice, the 2 pieces of code should be equivilant at the binary level:

int main()
{
    int x = 5;
    char y = 'c';
    printf("%d %c\n", x - 8, y + 1);
    return 0;
}

//outputs: -3 d

-

signed dword main()
{
    signed dword x = 5;
    byte y = 'c';
    printf("%d %c\n", x - 8, y + 1);
    return 0;
}

//outputs: -3 d
low-level language-design x86 c types
3 Answers

My question is, why do we use these types in compiled languages

To make the code target-agnostic. Some platforms only have efficient 16-bit integers, and forcing your variables to always be 32-bit would make your code slower for no reason when compiled for such platforms. Or maybe you have a target with 36-bit integers, and a strict 32-bit type would require extra instructions to implement.

Your question sounds very x86-centric. x86 is not the only architecture, and for most languages not the one language designers had in mind.

Even more recent languages that were designed in the era of x86 being widespread on desktops and servers were designed to be portable to other ISAs, like 8-bit AVR where a 32-bit int would take 4 registers vs. 2 for a 16-bit int.

user_2241320

A programming language defines an "abstract" data model, that a computer designer is free to implement his way. For instance, nothing mandates to store a Boolean in a byte, it could be "packed" as a single bit along with others. And if you read carefully the C standard, you will notice that a char has no defined size.

[Anecdotically, I recall an old time when FORTRAN variables, including integers, floats but also booleans, were stored on 72 bits on IBM machines.]

Language designers should put little constraints on machine architecture, to leave opportunities for nice designs. In fact, languages have no "low level", they implicitly describe a virtual machine not tied to a particular hardware (it could be implemented with cogwheels and ropes).

As far as I know, only the ADA language went to the point of specifying in details all the characteristics of the arithmetic, but not to the point of enforcing a number of bits per word.

Ignoring the boolean type was one of the saddest design decision in the C language. I took as late as C99 to integrate it :-(

Another sad decision is to have stopped considering the int type as the one that naturally fits in a machine word (and should have become 64 bits in current PCs).

user_11965490

The point of a high-level language is to provide some isolation from machine details. So, we speak of "integers", not some particular number of bytes of memory. The implementation then maps the higher-level types on whatever seems best suited to the target hardware.

And there are different semantics associated with different 4-byte types: for integers, signed versus unsigned is important to some classes of programs.

I understand this is a C question and it's arguable about how high-level C is or is not; but it is at least intended to be portable across machine architectures.

And, in your example, you assume 'int' is 32 bits. Nothing in the language says that has to be true. It has not always been true, and certainly was not true in the original PDP-11 implementation. And nowadays, for example, it is possibly appropriate to have 'int' be 64 bits on a 64-bit machine.

Note that it's not invariable that languages have types like "integer", etc. BLISS, a language at the same conceptual level as C, has the machine word as the only builtin datatype.

Admin1
Related