In-depth analysis of C language data types and value ranges

Data Storage Overview

Variables in C language have different data types, and the value space of each data type is different. Therefore, variables of different data types have different value spaces. In the C language program, most of the various types of variables are described in decimal form, but in fact these variables are stored in the form of binary in the computer , and C language allows direct bit operations on the binary to complete special request.

A bit (bit, also known as "bit", abbreviated b) in C language can store a binary number (0 or 1), and a byte (Byte, abbreviated B) can store 8 bits (bit).

Data storage is in "byte" (Byte) , and data transmission is mostly in "bit" (bit). In a computer, a string of numbers is processed or calculated as a whole called a word. Words are usually divided into bytes. In memory, each cell usually stores one word, so each word can be addressed. The length of a word is expressed in bits (the word length refers to the number of binary digits that a computer can process at one time). Such as 32-bit and 64-bit operating systems, word length is an important factor to measure computer performance.

The amount of information storage is a measure of the amount of programs and data stored in the memory , and a bit stores a binary number, that is, 0 or 1, which is the smallest storage unit. 8 binary is a byte unit, an English letter (partial case) and English punctuation occupies one byte space (8bit), a Chinese character and Chinese punctuation occupy two byte space (16bit).

The relationship between computer storage units is as follows :

$1byte\left(Byte\right)\_=8bits\left(bit\right)$ 1 KB (kilobyte) = 1024 B 1KB (kilobyte) =$1024B$
$1KB\left(kilobytes\right)\_=1024B$
$1MB\left(megabytes\right)=1024KB\; 1GB$
$1GB\left(gigabytes\right)=1024MB$
$1TB\left(terabytes\right)=1024GB$
$1PB\left(Petabytes\right)=1024TB$
$1exabyte\left(exabytes\right)=1024PB$
$1ZB(ten\; trillion\; terabytes)=1024EB$
$1YB(one\; trillion\; quintillion\; bytes)=1024ZB$
$1BB(hundred\; billion\; petabytes)=1024YB$

basic data type

Programming languages ​​generally provide several different data types to meet the needs of programming.
The following are several basic data types:

1) Character type: represented by char
2) Integer type: represented by int
3) Single-precision real number type: represented by float
4) Double-precision real number type: represented by double
5) Empty type: represented by void

binary representation of an integer

Integers are divided into two types: unsigned and signed. Signed integers can be positive or negative. The sign is represented by the highest bit of the byte. 0 means positive and 1 means negative. . as follows:

1) Signed binary integer
10110100, its highest bit is the sign bit, therefore, $(10110100{)}_2$The decimal number of is $-(2^5+2^4+2^2)=-52$ .$\_$while$(00110100{)}_2$The decimal number is $2^5+2^4+2^2=52$ .
It should be noted that in order not to waste the storage space of the computer, there are different treatments for "positive zero" and "negative zero". For "positive zero" (00000000), it represents 0, and for "negative zero" (10000000), it represents -128.
2)Unsigned binary integer
The highest bit of 0 or 1 does not represent a sign bit, but a specific value. For example,$(10110100{)}_2$, its decimal number is $(2^7+2^5+2^4+2^2)=180$

Binary representation of floating point numbers

The representation of floating-point numbers in the computer can be divided into single-precision floating-point numbers and double-precision floating-point numbers according to the number of bytes allocated by the system. Usually, the computer will allocate 4 bytes to single-precision floating-point numbers and 8 bytes to double-precision float. When the computer stores floating-point numbers, it needs to convert decimal floating-point numbers into binary representation. The conversion method is to first convert the floating-point number into an integer part and a pure decimal part, and then convert the integer part and the pure decimal part into binary respectively.

1) For the integer part, divide by 2 and take the remainder until the quotient is zero. The first remainder is the highest bit, and the last integer bit is the lowest bit. For example, the decimal number 56 can be expressed in binary by dividing by 2 and taking the remainder: $56_{10}=(111000{)}_2$。

2) The fractional part is multiplied by 2 and rounded until the remaining decimals are 0 or meet the precision requirements. The highest bit of the integer obtained first is the highest bit, and the last integer is the lowest bit. For example: decimal 0.432, the binary representation can be obtained by multiplying by 2 and taking the remainder: $(0.432{)}_{10}=(0.011{)}_2$

So you can convert the floating point number 4.625 into binary number as: $(56.432{)}_{10}=111000.011_2$

The storage of floating-point numbers follows the IEEE754 standard, and any binary floating-point number can be expressed in the following form:

Ranges

The integer (int) data type can also be used with the following four modifiers to describe the length and value range of the data:

1) signed (signed)
2) unsigned (unsigned)
3) long (long)
4) short (short)

The character (char) data type can only be modified with singned (signed) or unsigned (unsigned).

1. 1 byte
   Character type: 【char】 The value range is ASCII characters
   Unsigned character type: 【unsingned char】 The value range is 0~255
   Signed character type: 【signed char】 The value range is -128~127
2. 2 bytes
   Integer: [ int] The value range is -32768~32767
   Signed integer type: [ signed int] The value range is -32768~32767
   Unsigned integer type: [ unsigned int] The value range is 0~65535
   Short integer type: [ short int】The value range is -32768~32767
   Signed short integer: the value range is 【singned short int】-32768~32767
   Unsigned short integer: the value range is 【unsinged short int】0~65535
3. 4 bytes
   Long integer: [ long int] The value range is -2147483648~2147483647
   Signed long integer: [ signed long int] The value range is -2147483648~2147483647
   Unsigned long integer: [ unsinged long int] The value range is 0~4294967295
   Single-precision real number type: 【float】value range is about $\pm 3.4\times 10^{\pm 38}$
   double-precision real number type: [double] the value range is about$\pm 1.7\times 10^{\pm 308}$

The data type and byte length shown above are the standards that are suitable for the compilation environment of C language. Different compilation systems will expand the data type and byte length.