[proficient in high concurrency] deeply understand the basis of C language and C language under assembly

​ Author's brief introduction ： Xiaoming Java Asking the way , Senior R & D Engineer of a large financial Internet company , Good at orders / High security in the trading field / You can use / Concurrent / Performance architecture design and implementation , Focus on the research of computer and financial technology
If this article is good , Please pay attention. 、 give the thumbs-up 、 Collect three companies to support bloggers ​

Introduction to this article ：C The basic part of language does not need to be repeated , Mainly explain the structure 、 Pointer and array principle , And analyze the C Language .Liunx Kernel and JNI It's all through C To write , This part mainly explains the idea of executing programs by operating pointers and memory , For the follow-up Hotspot and java Of api It is very important to understand .

Two 、C Language foundation

1. Structural applications

You have to use struct sentence ,struct Statement defines a data type that contains multiple members

 struct tag {   // tag It's the structure label   	member-list // member-list  It's the standard variable definition   	member-list  	...  } variable-list; // variable-list Is a structural variable , Defined at the end of the structure , Before the last semicolon , You can specify one or more structural variables 

Structural applications ： Describes how to declare （ Definition ） Structure , Initializing structure variables （ amount to new perhaps set object ）, How to access structure members （ It is equivalent to accessing object properties ） , Structs are used as function parameters and pointers to structs .

2. Look at the structure from the assembly point of view

From this simple code analysis ,name and age Address difference 8 Bytes , Finishing is a plastic surgery 4 Bytes +4 Bytes filled , We disassemble it , Look at the implementation of assembly code .

#include<stdio.h>struct User { //  Declared structure  	int age;	char *name;	long money;};int main() {	struct User user = {18,"XiaoMing",10000};	struct User *p = &user; 		printf("user Variable address  : %p",&user); 	printf("p Pointer access value : %d",p->age); 	printf("age The address of  : %p",&(p->age)); 	printf("p Pointer access value name: %s",p->name); 	printf("name The address of : %p",&(p->name)); }// user Variable address  : 000000000062FE30// p Pointer access value : 18// age The address of  : 000000000062FE30// p Pointer access value name: XiaoMing// name The address of : 000000000062FE38

// main Method assembly code  main: push   %rbp        //  Open up new stack frames  mov    %rsp,%rbpsub    $0x40,%rsp  //  create 64byte Space , Note the following stored data and memory alignment mechanisms   callq  0x4023b0 <__main>  movl   $0x11,-0x20(%rbp)  // mov Instructions , To type 17（0x11,4 Bytes ）, character string , Long integer is put into the address corresponding to the stack , Equivalent to execution  struct User user = {17,"lisa",10000};movl   $0x2710,-0x10(%rbp)lea    0x28b5(%rip),%rax        # 0x404050 //  take 17 The address of rax In the register , Then save it on the stack , Equivalent to execution  struct User *p = &user; mov    %rax,-0x18(%rbp)  // lea: Take a valid address ,mov: Send instructions  lea    -0x20(%rbp),%rax   mov    %rax,-0x8(%rbp)lea    -0x20(%rbp),%rax  //   take 17 The address of rax In the register , And then call printf, Equivalent to execution  printf("user Variable address  : %p",&user); mov    %rax,%rdxlea    0x2899(%rip),%rcx        # 0x404055callq  0x402dd0 <printf>mov    -0x8(%rbp),%rax   //   take 17 The address of rax In the register , Then as an address , Put the value in the addressed address unit into eax register  mov    (%rax),%eax       //  (%rax) It means that you will rax The value in the register is placed as address addressing eax In the register  mov    %eax,%edxlea    0x2897(%rip),%rcx        # 0x404067callq  0x402dd0 <printf>mov    -0x8(%rbp),%rax   //  Shift the address forward 8 Contents of byte unit address , Put in rax register , This content points to *** The pointer to , because 64 It's a plane , Right now 8 Bytes  mov    %rax,%rdxlea    0x2894(%rip),%rcx        # 0x404077callq  0x402dd0 <printf>mov    -0x8(%rbp),%raxmov    0x8(%rax),%raxmov    %rax,%rdxlea    0x288c(%rip),%rcx        # 0x404086callq  0x402dd0 <printf>mov    -0x8(%rbp),%raxadd    $0x8,%raxmov    %rax,%rdxlea    0x2889(%rip),%rcx        # 0x40409acallq  0x402dd0 <printf>mov    $0x0,%eaxadd    $0x40,%rsp  //  Add the address value directly 8, Equivalent to address plus 8 Bytes  pop    %rbplesve  //  Clear the stack frame and set the address return retq         // ret: Return instruction 

3. The pointer principle

Each variable will have a memory address , Every memory address can be used & visit , He represents the address in memory . First, define a concept , A pointer is a variable , Its value is the address of another variable （ Direct address of memory location ）, All use must be declared first .

	// type *varName; type Is the base type of the pointer , Must be a valid data type  	int *ip;    //  Shaping the pointer  	double *dp; //  All actual data types , All memory addresses 16 Hexadecimal number  	float *fp;	char *cp; 

Application of pointer ： Inside this p It's a pointer , And variables var Same type of

#include<stdio.h>int main() {	int var = 20;	int *p; 	p = &var;	printf("var The address of the variable  : %p",&var); 	printf("p The storage address of the pointer : %p",p); 	printf("p The value accessed by the pointer : %d",*p); } // var The address of the variable  : 000000000062FE44// p The storage address of the pointer : 000000000062FE44// p The value accessed by the pointer : 20 

4. Looking at pointers from an assembly point of view

The code after disassembling the above code , The author is 64 Bit system

main:push   %rbp           //  Open up new stack frames  mov    %rsp,%rbp          sub    $0x30,%rsp     //  Open up on the stack 48（0x30）byte Size space  callq  0x402120 <__main>movl   $0x14,-0xc(%rbp) //  take 4byte The size of 20（0x14） Put in stack （rbp） lea    -0xc(%rbp),%rax  //  take 20 Get the address in the stack , Put in rax register  mov    %rax,-0x8(%rbp)  //  take rax register ,20 Put the address of on the stack , stay 64 Bit system , The address size is 8byte   The above two lines of code are equivalent to  int *p; p=&var; lea    -0xc(%rbp),%rax  //  Once again 20 The address of  mov    %rax,%rdx     //  take 20 The address from rax Register into rdx In the register  lea    0x2aa6(%rip),%rcx        # 0x404000callq  0x402b38 <printf>    //  amount to printf("var The address of the variable  : %p",&var); mov    -0x8(%rbp),%rax   //  Save before 20 The address of rax in  mov    %rax,%rdxlea    0x2aa6(%rip),%rcx        # 0x404013callq  0x402b38 <printf>    //  amount to printf("p The storage address of the pointer : %p",p); mov    -0x8(%rbp),%rax   //  Save before 20 The address of rax in  mov    (%rax),%eax       //  Note that there  (%rax), Is equivalent to rax The display in the register is used as the address , Get the value of the corresponding address in memory , Put in eax register 						 // 20 Only 4byte（32 position ）, So no need rax register （64 position ） mov    %eax,%edxlea    0x2aa6(%rip),%rcx        # 0x404027callq  0x402b38 <printf>    //  amount to printf("p The value accessed by the pointer : %d",*p); mov    $0x0,%eaxadd    $0x30,%rsppop    %rbpretq   

Here we summarize , A pointer is a memory unit that holds an address , It's usually used & Address character , amount to lea Instructions , Use the pointer with * Solution address character , Equivalent to ()  for example mov    (%rax),%eax, Put the previous lea The instruction obtains the address information as access , To get the variable information of the address response .

5. Some basic applications of pointers  

Accessing arrays through pointers , Arrays are continuous spaces , The pointer stores the address of the corresponding data , When declaring an array, it is the address of the first element in the newly opened continuous address space by default , Use var[index] Equivalent to our direct manipulation of pointers * Get elements by reference ;
Pointer array is to save the element address （ The pointer ） Array of

#include<stdio.h>int main() {	/**	 *  Accessing arrays through pointers  	 */	int var[] = {1,2,3};	printf(" Address : %p",var); 	printf(" Address : %p",var+1); 	printf(" value : %d",*var); 	printf(" value : %d",*(var+1)); 		/**	 *  Pointer array  	 */ 	int i, *arr[3];	for (i=0;i<3;i++) {		arr[i] = &var[i];	}	for(i=0;i<3;i++){		printf("var[%d] = %d ",i , *arr[i]); 		} } //  Address : 000000000062FE40//  Address : 000000000062FE44//  value : 1//  value : 2// var[0] = 1 var[1] = 2 var[2] = 3