Advanced data storage

One 、.C Common mistakes in language ：

1. Compile error （ There are syntax errors in the code phase written , Or compile the wrong code , If the return value is missing , Double click the error prompt to jump to the error location ）

2. link error , No, Reference header file or library function , Or the function or variable you created is undefined , Such as : Unexplained external symbols ...... （ Source file test.c→ compile → link →test.exe Executable program , Double click the error prompt and there is no response , Should use the ctrl+F Search the error reporting part , Or directly find the wrong part according to the error report )

Neither of the first two works , And there will be an error message , The naked eye can make mistakes , Easier to find and correct .

3. An error occurred while running （ It is necessary to solve the problem by debugging ）, For example, an endless loop causes stack overflow

4. Wrong answer , The result is not correct .

Two 、 Original code 、 Inverse code 、 Complement code

Inverse code 、 The meaning of complement ：

In the computer CPU Only the addition processor , Processing 1-1 Time is to turn it into 1+（-1） To deal with the .

for example char Type of 1-1：

1 The binary of is -0000 0001;-1 The binary of is -1000 0001;

stay CPU Middle computation 1+（-1） The result is 1000 0010 yes -2 The original code of , obviously 1+（-1）！=-2;

So after scientists' research , Evolved the inverse code 、 Complement operation .

First ,

A positive number 、 back 、 The complement is the same .

The inverse code of a negative number is that the original code negates the binary data bits , The sign bits remain the same , Get the inverse ; And then add the inverse code value +1, Get the complement .

（ There are two ways to get the original code by complement .1. First on the complement value -1, Get the inverse , Then reverse the binary data bits of the inverse code , The sign bits remain the same , The final result is the complement 2. Reverse the complement binary data bit , The sign bits remain the same , And then on the numerical value +1, You can get the original code ）

that 1-1 The operation of is ：

1 Original , back , The complements are all 0000 0001;

-1 The original code of ：1000 0001

Inverse code ：1111 1110

Complement code ：1111 1111

In the operation process of the system, its complement is calculated ：

namely 0000 0001 [phone]=1 0000 0000, because char The type size is 1 Bytes ,8 A bit , The excess high byte bits will be rounded off , The end result is 0000 0000 , yes 0 Complement , Obviously the result is correct . The above is the inverse code 、 The necessity of complement .

3、 ... and 、 Big and small bytes

Big endian byte ： The high byte bits are stored at the low address , The low byte bits are stored at the high address

Small byte ： The high byte bits are stored at the high address , The low byte bits are stored at the low address

In the memory window of the system （ The default is 16 Base display , One bit is a hexadecimal number , Occupy 4 A bit , Two hexadecimal bits represent a byte ） Middle is the small end byte display , And the default , From left to right is the low address to the high address . So the low byte bits are displayed on the left , The high byte bits are shown on the right .

How to determine whether a compiler displays large end bytes or small end bytes ？

int check_sys()

{

int a = 1;

return *(char*)&a;

}

int main()

{

 int ret = check_sys();

if (ret == 1)

{

printf(" The small end \n");

 }

 else

 {

printf(" Big end \n");

}

, Use one char Type a pointer , Part of the interview （ Access starts at a low address ） The low address part of the number , If the low address part is the high byte part , It proves that the compiler is a big endian display ; If the low address part is loaded with low bytes , It proves that the compiler is a small end byte display .

Four 、 Forced conversion （）

int a=2;

char *p=(char*)&a;------ take int The type pointer is forcibly converted to char Type a pointer , In addition to type changes , Other sizes and the like have not changed , There will be no memory leaks , Because the pointer size is determined by the compiler , It's usually 4 or 8 Bytes .

5、 ... and 、%u,%d    And integer lift

signed char b = -1;

unsigned char c = -1;

// //10000000000000000000000000000001

// //11111111111111111111111111111110

// //11111111111111111111111111111111

// //11111111 - c

// //00000000000000000000000011111111

printf("a=%d,b=%d,c=%d", a, b, c);

// //-1 -1 255

// // When we print a When , To have an integer lift

// // Printed is a signed number

// return 0;

//}

in

// //printf("%u\n", ch);//%u Is to print unsigned numbers , What you want me to print must be an unsigned number , Not an unsigned number , I also think it's an unsigned number

// printf("%d\n", ch);//%d Is the signed number printed , What you want me to print must be a signed number , Not a signed number , I also think it's a signed number

Then the result of this problem is , The first two types are upgraded during printing , But because it is a signed number , Integer type promotes the sign bit , After the complement integer is raised, it is converted back to the original code , The result remains the same .

the latter unsigned char c=-1; Because it is first defined as an unsigned number , The complement is 1111 1111, The default is positive , Then its original code 、 Inverse code 、 The complements are all 1111 1111, And unsigned in integer Promotion , The additional bit on the left is 0, therefore unsigned char c=-1; After being defined as an unsigned number , When printing, the integer is improved , The result of printing is 255.

So the print result of this question is -1 -1 255