Integers in C: a little history

Integers are the most basic data type in programming and can be regarded as the cornerstone of programming. The job of a programmer is to give these numbers meanings. No matter how complex the software is, it ultimately comes down to integer operations, because the processor only understands integers.

To represent negative numbers, we introduced two's complement ; to represent decimal numbers, we created scientific notation, so there are floating-point numbers. But in the final analysis, everything is still inseparable from 0 and 1.

---

A brief history of integers

In C, int is almost the default type. Although the compiler may issue a warning, in many cases you can still write code like this:

 <code class="c">main(void) { return 0; }</code>

From a technical point of view, this is equivalent to the following code:

 <code class="c">int main(void) { return 0; }</code>

This practice stems from the programming habit at that time: if the programmer does not specify a type, it is reasonable to use integers by default.

This is also considered in the original intention of the C language design. Initially, int did not have a standard size. On the PDP-11 processor (the platform where C language was originally born), the addressing space is 16 bits, so it is reasonable int is also 16 bits. The idea at that time was that the size of int would grow with the development of the processor.

The Mystery of Size

This approach brings some problems. If the size of int varies from platform to platform, the behavior of programs compiled for different processors will vary, which is contrary to the C language "platform-independent" concept.

Unlike int , the size of char is always clearly defined: 8 bits, signed . Despite the name, char is not an abstract type of text characters, but an 8-bit integer. For example, the character "a" will be converted to the number 97 at compile time, which is simple and clear.

What about other types, such as short and long ? Its size is determined by the compiler:

 <code class="c">short // 编译器自行决定大小long // 编译器自行决定大小</code>

The compiler implementer is free to decide its specific size.

Specifications brought by ANSI C (1989)

The ANSI C standard sets some rules:

• char : at least 8
• short : at least 16 digits
• int : at least as big as short (16-bit or 32-bit)
• long : at least 32

This brings some specifications, but the size of int is still not clear enough. The C99 standard introduces the <stdint.h></stdint.h> header file, and the situation has improved.

Now we have fixed-size integer types:

• int8_t : 8 bits
• int16_t : 16 bits
• int32_t : 32 bits
• int64_t : 64 bit

From then on, the compiler must implement this header file using a fixed-size type.

---

The current situation of integers

Today, using modern compilers like GCC and Clang , the size of integers is more predictable:

type	size
char	8 bits
Short	16 bits
int	32 bits
long	64 bits (32 bits on 32 bit systems)
long long	64 bits

Although long long is still a bit special, it at least brings consistency (I honestly think long long is cool).

---

Best Practices

Now we have header files like <stddef.h></stddef.h> and <stdint.h></stdint.h> . Use int only when necessary, such as the return type of main function. For other cases, it is best to use a fixed-size integer type in <stdint.h></stdint.h> ; for array index or loop count, use size_t in <stddef.h></stddef.h> . Hope these suggestions help you avoid some trouble.

Thank you for reading!

The above is the detailed content of Integers in C: a little history. For more information, please follow other related articles on the PHP Chinese website!