Example of array and pointer assembly code analysis in C language

This article mainly introduces the C language in the array and pointer assembly code analysis examples, this article uses a C language example to get the corresponding assembly code, and one by one to annotate the meaning of each sentence assembly code, need friends can refer to the

Watching the programmer's interview today, I happened to see the efficient access to arrays and pointers, idle boredom, wrote a paragraph of small code, a simple analysis of C language behind the compilation, may be a lot of people only pay attention to C language, but in practical applications, when there are problems, sometimes through the analysis of assembly code can solve the problem. This article is just for beginners, Daniel can drift through ~

C source code is as follows:

The code is as follows:

#include "stdafx.h"

int main (int argc, char* argv[])

{

Char a=1;

Char c[] = "1234567890";

Char *p = "1234567890";

A = c[1];

A = p[1];

return 0;

}

To view the assembly code step under VC6.0:

F9 set breakpoints in the front section of the main function-> compile->f5 right-click->go to disassembly in the debugging interface

Debug assembly Code (commented):

The code is as follows:

4: #include "stdafx.h"

5:

6:int Main (int argc, char* argv[])

7: {

00401010 Push EBP

00401011 mov ebp,esp; save stack frame

00401013 Sub esp,54h; raising the top of the stack

00401016 push EBX

00401017 push ESI

00401018 push EDI; registers used in the press program to restore

00401019 Lea EDI,[EBP-54H]

0040101C mov ecx,15h

00401021 mov eax,0cccccccch

00401026 Rep STOs DWORD [edi], the data between the stack top and the stack frame is populated 0xcc, which is equivalent to int 3 in the assembly, because the variables on the stack are initialized to 0XCC in debug mode to check for uninitialized problems

8:char a=1;

00401028 mov byte ptr [ebp-4],1; ebp-4 is the space address allocated for variable a

9:char c[] = "1234567890";

0040102C mov eax,[string "1234567890" (0042201c)

00401031 mov dword ptr [Ebp-10h],eax; 1234567890 "is a string constant, stored at address 0042201c, EBP-10 is the first address of the space allocated in array C, with a total of 12 bytes from ebp-0x10 to ebp-0x04. In this sentence, we first copy the 4 bytes of "1234" into the array C.

00401034 mov ecx,dword ptr [string "1234567890" 4 (00422020)]

0040103A mov dword ptr [ebp-0ch],ecx; function ibid., copy "5678" 4 bytes to array c

0040103D mov dx,word ptr [string "1234567890" 8 (00422024)]

00401044 mov word ptr [ebp-8],dx; function ibid., copy "90" 2 bytes to C

00401048 mov al,[string "1234567890" 0Ah (00422026)]

0040104D mov byte ptr [ebp-6],al; This is familiar to everyone, don't forget

10:char *p = "1234567890";

00401050 mov dword ptr [Ebp-14h],offset string "1234567890" (0042201c); ebp-0x14 is the space address assigned to the pointer p, the size is 4 bytes, and the value in the address is a string " 1234567890 "The first address

11:a = c[1];

00401057 mov cl,byte ptr [ebp-0fh]; Here is the focus, because array c is stored continuously on the stack, it is easy to find the address of one of the characters according to EBP, and take the value, assign to CL

0040105A mov byte ptr [ebp-4],cl; completion assignment

12:a = p[1];

0040105D mov edx,dword ptr [ebp-14h]; here is different from the above, because according to EBP only know the value of the pointer p, first get the value of P, that is, first get a pointer

00401060 mov al,byte ptr [edx 1]; Find a character in the string indirectly based on the resulting pointer

00401063 mov byte ptr [ebp-4],al

13:return 0;

00401066 xor eax,eax eax 0, as the return value of the main function

14:}

00401068 Pop EDI

00401069 pop ESI

0040106A pop ebx

0040106B mov esp,ebp

0040106D pop ebp; Recovery ebp

0040106E ret

Well, as you can see, it takes 2 steps to access an element with an array, and 3 steps when you use the pointer. The visible array is not the same as the pointer, and sometimes the idea that the name of the array can be viewed as a pointer is sometimes true, but sometimes it goes wrong. Let me give you a simple example, and the following example may be a problem that you will often encounter during the development process.

In file Test.cpp:

The code is as follows:

#include "stdafx.h"

#include "inc.h"

extern Char chtest[10];

int main (int argc, char* argv[])

{

printf ("Chtest=%sn", chtest);

return 0;

}

There is an extern declaration that indicates that the chtest array is defined in an external file. Chtest is defined in inc.h:

The code is as follows:

Char chtest[10]= "123456789";

The above program, after compiling, can run successfully. But if you change the red code to the following:

The code is as follows:

extern char *chtest;

At this time, the program in the compilation of the communication, but the error message is: redefinition; Different types of indirection, but this time there is no error in which line of instructions, if the development of a large project, then it is not easy to locate the problem where. The cause of the above error I think we all understand that, because when chtest as a pointer is referenced, its element access is different from the array, even if the program can compile, at run time, there will be errors.

Well, the above content is personal feeling and hair, is some simple fragmentary things, consultation fee. If there are any places that are not appropriate, look at them!