I. The basic theoretical function parameter transfer mechanism of the function parameter transmission mechanism is essentially a method of communicating when the call function (process) and the modified function (process) are invoked. Basic parameter transfer mechanisms have two types: value transfer and reference delivery. The following discussion claims that the function of the other functions is the main adjustment function, the function called is called function. During a passl-by-value process, the formal parameters of the modulated function as partial variable processing of the modulated function, that is, the memory space is opened in the stack to store the value of the arguments that are placed in the main adjustment, thus Become a copy of the argument. The value transfer is characterized by any operation of the modulated function to the formal parameters as a local variable, and does not affect the value of the real parameters variable. During the pass-by-reference process, the formal parameters of the modulated function also opens up memory space as a local variable in the stack, but the address of the real parameters that are placed in the main adjustment function is stored. Any operation of the modulus of the modulus is processed into indirect addressing, that is, the address of the horses in the horses in the stack. Because of this, any operation of the modulus of the modulus is used affects the real parameters in the main adjustment function. Second, the function parameter transfer mechanism in the C language is in the C language, and the value passed is the only parameter transfer mechanism available. However, according to the author, many friends also believe that this is the reference to pass due to the influence of the pointer variable as the function parameters. This is wrong. Please see the following code: int sw * x, int * y) {int TEMP; TEMP = * x; * x = * y; * y = Temp; return temp;} void main () {int a = 1 , b = 2; int * p1 = & a; int * p2 = & b; SWAP (P1, P2)} function SWAP is used as a parameter in two pointer variables, and when the main () calls SWAP, the pointer is transmitted. The value of the variables P1, P2 (that is, the address of variables A, B) is placed in the memory cell that SWAP is in the form of forms X, Y in the stack. This can be seen from the following assembly code (note is the author added): 22: void main () 23: {... ... 13: int a = 1, b = 2; 00401088 MOV DWORD PTR [EBP-4 ], 1 0040108F MOV DWORD PTR [EBP-8], 2 14: INT * P1 = & A; 00401096 Lea EAX, [EBP-4] 00401099 MOV DWORD PTR [EBP-0CH], EAX 15: INT * P2 = & B; 0040109C LEA ECX, [EBP-8] 0040109F MOV DWORD PTR [EBP-10H], ECX 16: SWAP (P1, P2); 004010A2 MOV EDX, DWORD PTR [EBP-10H]; Parameter P2 Value Inn 004010A5 PUSH EDX 004010A5 004010A6 MOV EAX, DWORD PTR [EBP-0CH]; Parameter P1 Value Inn 004010A9 PUSH EAX 004010AA Call @ ilt 15 (SWAP) (00401014); Call SWAP Function 004010AF Add ESP, 8; Cleanup Stack Parameters 17: } Read the above code To note that the Intel80x86 series CPU's processing is generated downward, ie, from the high address unit to the low address unit. From the above assembly code, it is known that main () before calling SWAP, press the value of the arguments from the right to the left, first P2, and then press the stack.
After the call is over, the main adjustment main () is responsible for cleaning the parameters in the stack. SWAP will use these to enter the stack variable. The following is the assembly code of the SWAP function: 14: Void swap (int * x, int * y) 15: {00401030 PUSH EBP 00401031 MOV EBP, ESP; EBP points to the top ... ...... 16: int Temp; 17: Temp = * x; 4: int Temp; 5: Temp = * x; 00401048 MOV EAX, DWORD PTR [EBP 8]; operation has been stored in P1 in the stack, set P1; into EAX 0040104B MOV ECX, DWORD PTR [EAX ]; P1 is placed in ECX 0040104D MOV DWORD PTR [EBP-4], and ECX is placed in the TEMP variable via the register site; the * p1 is placed in the TEMP variable. The following is similar to 6: * x = * y; 00401050 MOV EDX, DWORD PTR [EBP 8] 00401053 MOV EAX, DWORD PTR [EBP 0CH] 00401056 MOV ECX, DWORD PTR [EAX] 00401058 MOV DWORD PTR [EDX], ECX 7: * y = Temp; 0040105A MOV EDX, DWORD PTR [EBP 0CH] 0040105D MOV EAX, DWORD PTR [EBP-4] 00401060 MOV DWORD PTR [EDX], EAX 8: Return Temp; 00401062 MOV Eax, DWORD PTR [ EBP-4] 9:} Basically, the above assembly code, basically explains the principle of the C language median delivery, but only the value of the pointer is the value of the pointer. This article also discusses the SWAP function transmitted by the reference. From these assembly code analysis, here we can get the following points: 1. The stack storage area of the process is the main area of the primary and the modulated function. 2. The parameter in the C language is from right to left. 3. The stack area structure used by the modulated function is: local variables (such as TEMP) return address function parameters lower address high address 4. The stack is cleaned by the main adjustment function after the call. 5. The return value of the function is generally placed in the register. Here is a need to add some points: First, the parameters are put in stack. For internal types, since the compiler knows the memory size used by the various variables, use the PUSH instruction directly; for custom types (such as Structure), the source address is used to perform byte delivery byte the address to the stack. . Second, the function return value is generally placed in the register, which is mainly to support interrupts; if it is placed in the stack, it is possible to overwrite because it is interrupted. Third, if the return value of the function is large, then from the stack to the address unit of the returned value (by the Motor) to the modulated function to the modulated function before calling) to reach the returned purpose. For the second and third, "Thinking In C " book has a better elaboration in Chapter 10. The fourth is an obvious conclusion, if the address returns a local variable in the modulo is meaningless; because the local variable is stored in the stack, the stack will be cleaned up after the call is completed, and these addresses become invalid. Third, the function parameter transfer mechanism in the C language C has both the value of C has a reference delivery. On the value transfer with C, it will focus on the reference delivery. As mentioned earlier herein, reference delivery is the address of the transfer variable to the stack used by the modulated function.
Declaring reference delivery in C to use "&" symbols, but not when calling. The following code is the SWAP2 function and main function that uses references: INT & SWAP2 (INT & X, INT & Y) {INT TEMP; TEMP = X; X = Y; Y = Temp; Return X;} void main () {Int a = 1, b = 2; SWAP2 (A, B);} At this time, the function SWAP2 will accept the address of the two integer variables while returning one of them. From the main function, call SWAP2 (A, B) for SWAP2, you can't see if the reference passes is used, whether to use reference delivery, is determined by the definition of the SWAP2 function. The following is a compilation code for the main function: 11: void main () 12: {... ...... 13: int a = 1, b = 2; 00401088 MOV DWORD PTR [EBP-4], 1; Variable A 0040108F MOV DWORD PTR [EBP-8], 2; Variables B 14: SWAP2 (A, B); 00401096 Lea Eax, [EBP-8]; send B offset address to EAX 00401099 PUSH EAX; B offset address stack 0040109A LEA ECX, [EBP-4]; send A's offset address into ECX 0040109D PUSH ECX; the offset address stack 0040109E Call @ ilt 20 (SWAP2) (00401019); call SWAP function 004010A3 Add ESP, 8; Cleanup parameters 15:} It can be seen that the main function is stacking the B and A from the right to left before calling SWAP2, which is the address of the transfer variable. The assembly code of the SWAP2 function is: 2: INT & SWAP2 (INT & X, INT & Y) 3: {00401030 PUSH EBP 00401031 MOV EBP, ESP ... ... 4: int Temp; 5: Temp = x; 00401048 MOV EAX, DWORD PTR [EBP 8] 0040104B MOV ECX, DWORD PTR [EAX] 0040104D MOV DWORD PTR [EBP-4], ECX 6: X = Y; 00401050 MOV EDX, DWORD PTR [EBP 8] 00401053 MOV EAX, DWORD PTR [EBP 0CH] 00401056 MOV ECX, DWORD PTR [EBP] 00401058 MOV DWORD PTR [EDX], ECX 7: Y = TEMP; 0040105A MOV EDX, DWORD PTR [EBP 0CH] 0040105D MOV EAX, DWORD PTR [EBP-4 ] 00401060 MOV DWORD PTR [EDX], EAX 8: RETURN X; 00401062 MOV EAX, DWORD PTR [EBP 8]; Returns x, since X is offset by external variables;, returning is a legal 9:} It can be seen that SWAP2 is the same as the assembly code of the previous SWAP function. This is because the front SWAP function accepts the pointer variable, and the value of the pointer variable is the address. Therefore, for the SWAP2 and the front SWAP here, the function parameters in the stack are stored all the address, which is consistent in the way in the function.
