当前位置：网站首页>Advanced C language - Section 1 - data storage

Advanced C language - Section 1 - data storage

2022-06-13 04:47:00 【Stretch the curtain with the wind】

Catalog

1. Data type introduction

1.1. Basic classification of types

2. Shaping storage in memory

2.1. Original code 、 Inverse code 、 Complement code

2.1.1. Original code 、 Inverse code 、 Complement introduction

2.1.2. Why is a complement stored in memory

2.2. Introduction to big and small end

2.2.1. Big end and small end

2.2.2. Why there are big end and small end

3.3.3. Design a small program to determine the current machine byte order

2.3. practice （※）

3. Floating point storage in memory  

 3.1. An example （※）

3.2. Floating point storage rules

1. Data type introduction

char              // Character data type
short            // Short
int                // plastic
long            // Long integer
long long   // Longer plastic surgery
float           // Single-precision floating-point
double       // Double precision floating point

c99 Boolean types are introduced in ： _Bool, Its function is to store true and false values , As shown in the figure below （ In the figure true Namely 1,false Namely 0）（ In fact, there is basically no boolean type , because int Type can completely solve , And Boolean types are essentially right int Type has been renamed ）

Need to quote stdbool.h The header file

1.1. Basic classification of types

1. Plastic surgery Family ：

char
        unsigned char    char What is the signed char still unsigned char It depends on the compiler implementation
        signed char        vs In the compiler char And signed char Equivalent
short
        unsigned short [int]    Unsigned short
        signed short [int]        Signed short integers    short And signed short Equivalent
int
        unsigned int    Unsigned integer
        signed int        signed int    int And signed int Equivalent
long
        unsigned long [int]    Unsigned long
        signed long [int]        Signed long integer    long And signed long Equivalent
longlong
notes ：
1. above [ ] The contents of the can be omitted
2.%d Print signed integers ,%u Print unsigned integers
2. Floating point family
float
double

3. Construction type  / Custom type

> An array type ： Remove the array name , The rest is the type of array （ int a[10] The type is int [10] ）
> Type of structure struct
> Enumeration type     enum
> Joint type     union

4. Pointer types

int* pi;
char* pc;
float* pf;
void* pv;
5. Empty type
void Indicates empty type （ No type ）
Usually applied to the return type of a function 、 The parameters of the function 、 Pointer types

2. Shaping storage in memory

2.1. Original code 、 Inverse code 、 Complement code

2.1.1. Original code 、 Inverse code 、 Complement introduction

Integers There are three forms of binary representation of ： Original code 、 Inverse code 、 Complement code
What is stored in memory is a binary complement
Integers are divided into positive integers and negative integers
Positive integer ： Original code 、 Inverse code 、 The complement is the same
15 The original code of ： 00000000 00000000 00000000 00001111
15 The inverse of ： 00000000 00000000 00000000 00001111
15 Complement ： 00000000 00000000 00000000 00001111
Negtive integer ： Original code 、 Inverse code 、 The complement needs to be calculated , as follows
Original code ： The binary code written directly according to the positive and negative of a number is the original code
-15 The original code of ：10000000 00000000 00000000 00001111
Inverse code ： The sign bits remain the same , The reverse of other bits is the reverse code
-15 The inverse of ：11111111 11111111 11111111 11110000
Complement code ： The binary sequence of the inverse code plus one is the complement
-15 Complement ：11111111 11111111 11111111 11110001
notes ：
1.32 Bit binary number , The first bit is the sign bit , The sign bit is 0 Represents an integer , The sign bit is 1, A negative number
2. The inverse code is not the inverse of the original code , Because bitwise negation means that even the sign bit is also inverted

2.1.2. Why is a complement stored in memory

In computer system , All values are represented and stored by complements . The reason lies in , Use complement , Symbol bits and value fields can be treated in a unified way ; meanwhile , Addition and subtraction can also be handled in a unified way （CPU Only adders ） Besides , Complement code and original code are converted to each other , Its operation process is the same , No need for additional hardware circuits .
The man goes next door 1-1, Because there are only adders in the computer , So it is 1+（-1）, Let's try to calculate with the original code and the complement code
1. Use complement , Symbol bits and value fields can be treated in a unified way ; meanwhile , Addition and subtraction can also be handled in a unified way
Original code calculation ：
1 The original code of ：00000000 00000000 00000000 00000001
-1 The original code of ：10000000 00000000 00000000 00000001
1+（-1） The original code of ：10000000 00000000 00000000 00000010    Values for -2（ The result error ）
Complement calculation ：
1 Complement ：00000000 00000000 00000000 00000001
-1 The original code of ：10000000 00000000 00000000 00000001
-1 The inverse of ：11111111 11111111 11111111 11111110
-1 Complement ：11111111 11111111 11111111 11111111
1+（-1） Complement ：1 00000000 00000000 00000000 00000000  The first one to go up 1 It is lost in practice, so it should be 00000000 00000000 00000000 00000000 , And the value is 0（ Results the correct ）
2. Complement code and original code are converted to each other , Its operation process is the same , No need for additional hardware circuits
-1 The original code of ：10000000 00000000 00000000 00000001
-1 The inverse of ：11111111 11111111 11111111 11111110
-1 Complement ：11111111 11111111 11111111 11111111
At this point, I want to -1 The complement of is converted to -1 There are two ways to get the original code of ：1. Counter calculation , Will complement -1 Become an inverse code , When the sign bit of the inverse code is unchanged, the other bits are reversed .2. Continue to complement the complement , That is to say, the complement symbol bit is unchanged and other bits are reversed , Then the value obtained +1, as follows ：
-1 Complement ：11111111 11111111 11111111 11111111
-1 The inverse of the complement of ：10000000 00000000 00000000 00000000
-1 The complement of the complement of ：10000000 00000000 00000000 00000001    It can be seen that this value is -1 The original code of

2.2. Introduction to big and small end

10 Complement ：00000000 00000000 00000000 00001010
10 The complement of is converted to 16 Base number ：0x 00 00 00 0a
-10 The original code of ：10000000 00000000 00000000 00001010
-10 The inverse of ：11111111 11111111 11111111 11110101
-10 Complement ：11111111 11111111 11111111 11110110
-10 The complement of is converted to 16 Base number :0x ff ff ff f6

summary ： We find that the numbers in the memory are always stored backwards

2.2.1. Big end and small end 

int a = 0x11223344;
Big end byte order storage ： When the low byte data of a data is stored at the high address , The contents of the high byte order are placed at the low address , This storage method is large end byte order storage     Memory ： 11 22 33 44
Small end byte order storage ： When a low byte of data is stored at a low address , The contents of high byte order are placed at the high address , This storage method is small end byte order storage     Memory ：44 33 22 11

2.2.2. Why there are big end and small end

Why are there big and small end patterns ？ This is because in a computer system , We are in bytes , Each address corresponds to a byte , A byte is 8bit. But in C In language, except 8 bit Of char outside , also 16 bit Of short type ,32 bit Of long type （ It depends on the compiler ）, in addition , For digits greater than 8 Bit processor , for example 16 Bits or 32 Bit processor , Because the register width is larger than one byte , So there must be a problem of how to arrange multiple bytes . So it leads to big end storage mode and small end storage mode .
for example ： One 16bit Of short type x , The address in memory is 0x0010 , x The value of is 0x1122 , that 0x11 For high byte , 0x22 Is low byte . For big end mode , will 0x11 Put it in the low address , namely 0x0010 in ,0x22 Put it in a high address , namely 0x0011 in . The small end model , Just the opposite . That we use a lot X86 The structure is small end mode , and KEIL C51 It's the big end mode . A great deal of ARM,DSP It's all small end mode . There are some ARM The processor can also choose the big end mode or the small end mode by the hardware .

2.2.3. Design a small program to determine the current machine byte order

Code 1：

Code 2：

Code 3：

2.3. practice

1. Exercise one
Calculate the output of the following code 
#include <stdio.h>
int main()
{
    char a= -1;
    signed char b=-1;
    unsigned char c=-1;
    printf("a=%d,b=%d,c=%d",a,b,c);
    return 0; 
}

answer ：

notes ：

1.  char a=-1 and   signed char b=-1 and  unsigned char c=-1

-1 The original code of ：10000000000000000000000000000001

-1 The inverse of ：11111111111111111111111111111110
-1 Complement ：11111111111111111111111111111111
a Complement （char type ）：11111111
b Complement （ signed char type ）：11111111
c Complement （  unsigned char type ）：11111111
2.%d Print （ When printing, it is considered that the complement is a signed number ）, There's an integer boost （vs Environment char and signed char identical ）
a yes char type , It's symbolic , The complement after promotion is 11111111111111111111111111111111
a With %d Print , Complement the original code ：10000000000000000000000000000001    Values for -1
b yes  signed char type , It's symbolic , The complement after promotion is 11111111111111111111111111111111
b With %d Print , Complement the original code ：10000000000000000000000000000001    Values for -1
c yes   unsigned char type , It's unsigned , The complement after promotion is 00000000000000000000000011111111
b With %d Print , Complement the original code ：00000000000000000000000011111111      Values for 255
2. Exercise 2
Calculate the output of the following code 
#include <stdio.h>
int main()
{
    char a = -128;
    printf("%u\n",a);
    return 0; 
}

answer

notes ：

1.char a = -128

-128 The original code of ：10000000000000000000000010000000

-128 The inverse of ：111111111111111111111111101111111
-128 Complement ：111111111111111111111111110000000
a Complement （char type ）：10000000
2.%u Print （ When printing, it is considered that the complement is an unsigned number ）, There's an integer boost .
a yes char type , It's symbolic , The complement after promotion is 11111111111111111111111110000000
a With %u Print , The complement code is the same as the original code ：11111111111111111111111110000000    Values for 4294967168
3. Practice three
Calculate the output of the following code 
#include <stdio.h>
int main()
{
    char a = 128;
    printf("%u\n",a);
    return 0; 
}

answer ：

notes ：

1.char a = 128

128 The original code of ：00000000000000000000000010000000

128 Complement ：00000000000000000000000010000000

a Complement （char type ）：10000000（ Same as exercise 2 ）
2.%u Print （ When printing, it is considered that the complement is an unsigned number ）, There's an integer boost （ Same as exercise 2 ）
a yes char type , It's symbolic , The complement after promotion is 11111111111111111111111110000000
a With %u Print , The complement code is the same as the original code ：11111111111111111111111110000000    Values for 4294967168
4. Exercise four
Calculate the output of the following code 
#include <stdio.h>
int main()
{
	int i = -20;
	unsigned int j = 10;
	printf("%d\n", i + j);
	return 0;
}

answer ：

notes ：

1.int i = -20

-20 The original code of ：10000000000000000000000000010100

-20 The inverse of ：11111111111111111111111111101011
-20 Complement ：11111111111111111111111111101100
2.    unsigned int j = 10
10 Complement ：00000000000000000000000000001010
3. i + j（ Complement addition ）, And then to %d Print , because j yes unsigned int type , When calculating , take a Of int The type is also converted to unsigned int Type to calculate （ In fact, the computer adds two values （ Subtraction, etc ） When we do not look at the types, we add them directly ）
i + j Complement ：11111111111111111111111111110110
 
i + j The inverse of ：11111111111111111111111111110101
i + j The original code of ：10000000000000000000000000001010    Values for -10
5. Practice five
Calculate the output of the following code 
#include <stdio.h>
int main()
{
	unsigned int i;
	for (i = 9; i >= 0; i--) {
		printf("%u\n", i);
	}
	return 0;
}

answer ： Dead cycle

notes ：

1. When i by 0 When ,i-- by -1

-1 Complement ：11111111111111111111111111111111

because i yes unsigned int type
therefore -1 The complement of is considered to be a 32 A positive number with all one bits , The value is 4294967295
Then subtract one more time to calculate , Form a dead cycle
6. Practice six
Calculate the output of the following code 
#include <stdio.h>
int main()
{
	char a[1000];
	int i;
	for (i = 0; i < 1000; i++)
	{
		a[i] = -1 - i;
	}
	printf("%d", strlen(a));
	return 0;
}

answer ：

  notes ：

1. One char What values can be put in variables of type

char The type is one byte and eight bits , Put data （ All complement ） There are the following possibilities

For no sign char In terms of type , The complement is the original code , The data range is as follows

For signed char In terms of type , The complement is converted to the original code , The data range is as follows （ Specify therein 10000000 The system resolves to by default -128）

  summary ：

（1） The values above are cyclic , That is, the last number plus one becomes the first number , As shown in the figure below

（2） And char Empathy , Deduce other types of numerical ranges

For signed char, Its value range is -128~127

For no sign char, Its value range is 0~255

For signed short, Its value range is -32768~32767 （-32768 by 1000000000000000 Directly parse to get ）

For no sign short, Its value range is 0~65535
The range represented by each type of the integer family ：limits.h In the definition of , As shown in the figure below （ Select the header file to go to the document ）

2. therefore char a[1000] The data stored in it should be

-1-2-3-4-5...-128127126...3210-1-2...
01234...127128129...252253254255256257...

3. It's time to find the string '\0' By , Statistics '\0' Number of previous values , Actually '\0' Of ASCII The code value is 0, So to 0 end , It can be seen from the above table that 0 In front of you are 255 Number .

7. Practice seven

Calculate the output of the following code 

#include <stdio.h>
unsigned char i = 0;
int main()
{
	for (i = 0; i <= 255; i++)
	{
		printf("hello world\n");
	}
	return 0;
}

answer ： Dead cycle

notes ： Unsigned char, Its value range is 0~255, To 255 The next value is 0, The cycle cut-off condition can never be reached , So the loop

3. Floating point storage in memory  

Common floating point numbers ：
3.14159
1E10（ intend 1.0\times10^{10}）
The family of floating-point numbers includes ： float、double、long double type
The range represented by floating point numbers ：float.h In the definition of , As shown in the figure below

 3.1. An example （※）

int main()
{
 int n = 9;
 float *pFloat = (float *)&n;
 printf("n The value of is ：%d\n",n);
 printf("*pFloat The value of is ：%f\n",*pFloat);
 *pFloat = 9.0;
 printf("num The value of is ：%d\n",n);
 printf("*pFloat The value of is ：%f\n",*pFloat);
 return 0; 
}

Running results ：

notes ：

1.%f and %lf Will default to have after the decimal point 6 position

2. We found that using floating-point pointers for storage n The address of , The dereferenced value is not 9 or 9.0, We can infer that floating-point and integer types are stored differently in memory .

3. In the above code *pFloat It is to dereference from the perspective of floating-point numbers

When n=9 when

n The original code of ：00000000000000000000000000001001

n Complement ：00000000000000000000000000001001

00000000000000000000000000001001
SEM

E For zero , The resulting value is a very close one 0 The number of , So printing out is 0.000000

When n=9.0 when

Decimal system 9.0 Convert to binary to 1001.0 Convert to scientific count to ：-1^{0}*1.001*2^{3},S=1,M=1.001,E=3

03+127=130 Binary system ：10000010001 Binary system ：00100000000000000000000
SEM

  So at this time n by ：0100 0001  0001 0000  0000 0000  0000 0000

n The hexadecimal of is        4        1        1       0        0      0       0        0    namely 0x41100000

  From the picture above , Floating point storage also conforms to small segment storage

Put... In memory n Value 01000001000100000000000000000000 use %d out , At this time, the original reverse complement is the same , The value obtained is 1091567616

3.2. Floating point storage rules

According to international standards IEEE（ Institute of electrical and Electronic Engineering ） 754, Any binary floating point number V It can be expressed in the following form ：
\bullet(-1)^S * M * 2^E
\bullet(-1)^s The sign bit , When s=0,V Is a positive number ; When s=1,V It's a negative number .
\bulletM Represents a significant number , Greater than or equal to 1, Less than 2.
\bullet2^E Indicates the index bit .
The number 111.111
The weight 2^22^12^0.2^(-1)=0.52^(-2)=0.252^(-3)=0.125

for example ： Decimal 5.5 Convert to binary to 101.1,101.1 It can be written. -1^{0}*1.011*2^{2}（S=0,M=1.011,E=2）

1. about float（32 Floating point number of bits ）

  The highest 1 Bits are sign bits s, And then 8 Bits are exponents E, The rest 23 Bits are significant numbers M.

2. about double（64 Floating point number of bits ）

  The highest 1 Bits are sign bits S, And then 11 Bits are exponents E, The rest 52 Bits are significant numbers M.

One 、 storage ：
M Storage mode ：
As I said before , 1≤M<2 , in other words ,M It can be written. 1.xxxxxx In the form of , among xxxxxx Represents the fractional part .
IEEE 754 Regulations , Keep it in the computer M when , By default, the first digit of this number is always 1, So it can be discarded , Save only the back xxxxxx part . For example preservation 1.01 When , Save only 01, Wait until you read , Put the first 1 Add . The purpose of this , It's saving 1 Significant digits . With 32 For example, a floating-point number , Leave to M Only 23 position , Will come first 1 After giving up , It's equivalent to being able to save 24 Significant digits .
E Storage mode ：
  First ,E For an unsigned integer （unsigned int）
It means , If E by 8 position , Its value range is 0~255; If E by 11 position , Its value range is 0~2047. however , We know , In scientific counting E You can have negative numbers
such as ：
Decimal system 0.5 Convert to binary to 0.1,0.1 Convert the scientific count to ： -1^{0}* 2^{-1}

therefore IEEE 754 Regulations , In memory E The true value of must be added with an intermediate number , about 8 Bit E, The middle number is 127; about 11 Bit E, The middle number is 1023.

such as ：
Decimal system 0.5 Of E The real value of is -1, And deposit E The real value should be stored in + The middle number （float：-1+127=126 double：-1+1023=1022）
Two 、 How to take it out （ Fetching from memory can be divided into three cases ）
1.E Not all for 0 Or not all of them 1
Floating point numbers are represented by the following rules , The index E The calculated value of minus 127（ or 1023）, Get the real value , And then the significant number M Add the first 1
2.E All for 0（E The real value of is -127 / -1023 For a very small number , Very close to 0）
The exponent of a floating point number E be equal to 1-127（ perhaps 1-1023） That's the true value , Significant figures M No more first 1, It's reduced to 0.xxxxxx Decimals of . This is to show that ±0, And close to 0 A very small number of .
3.E All for 1 （E The real value of is 128 / 1024 For a very large number ）
At this time , If the significant number M All for 0, Express ± infinity （ It depends on the sign bit s）
原网站

版权声明
本文为[Stretch the curtain with the wind]所创，转载请带上原文链接，感谢
https://yzsam.com/2022/02/202202280520088546.html

边栏推荐

猜你喜欢

随机推荐