C ++ (copy and assign value functions) 10 from the perspective of Assembly

[Disclaimer: All Rights Reserved. You are welcome to reprint it. Do not use it for commercial purposes. Contact Email: feixiaoxing @ 163.com]

 

The copy constructor and the copy function are two important functions in the class. What is the difference between the two? In fact, it is also very simple. For example, we can add a class definition:

[CPP] View plaincopy

2. ClassApple
4. {
6. Public:
8. Apple () {printf ("Apple ()! \ N");}
10. Apple (Apple & A) {printf ("Copy Apple ()! \ N");}
12. Apple & operator = (Apple & A) {printf ("= Apple () \ n");Return*This;}
14. ~ Apple () {printf ("~ Apple ()! \ N");}
16. VoidPrint ()Const{Return;}
18. };

So what are the called functions in the following functions?

[CPP] View plaincopy

1. VoidProcess ()
2. {
3. Apple A, C;
4. Apple B =;
5. C = B;
6. }

In fact, this is the result of the compilation. You can take a look at it and try to read it yourself. If you do not understand it at a time, you can read it several more times.

[CPP] View plaincopy

2. 70: Apple A, C;
4. 0040127d Lea ECx, [ebp-10h]
6. 00401280 call @ ILT + 70 (Apple: Apple) (0040104b)
8. 00401285 mov dword ptr [ebp-4], 0
10. 0040128c Lea ECx, [ebp-14h]
12. 0040128f call @ ILT + 70 (Apple: Apple) (0040104b)
14. 00401294 mov byte PTR [ebp-4], 1
16. 71: Apple B =;
18. 00401298 Lea eax, [ebp-10h]
20. 0040129b push eax
22. 0040129c Lea ECx, [ebp-18h]
24. 0040129f call @ ILT + 50 (Apple: Apple) (00401037)
26. 004012a4 mov byte PTR [ebp-4], 2
28. 72: c = B;
30. 004012a8 Lea ECx, [ebp-18h]
32. 004012ab push ECx
34. 004012ac Lea ECx, [ebp-14h]
36. 004012af call @ ILT + 75 (Apple: Operator =) (00401050)
38. 73 :}
40. 004012b4 mov byte PTR [ebp-4], 1
42. 004012b8 Lea ECx, [ebp-18h]
44. 004012bb call @ ILT + 0 (Apple ::~ Apple) (00401005)
46. 004012c0 mov byte PTR [ebp-4], 0
48. 004012c4 Lea ECx, [ebp-14h]
50. 004012c7 call @ ILT + 0 (Apple ::~ Apple) (00401005)
52. 004012cc mov dword ptr [ebp-4], 0 ffffffffh
54. 004012d3 Lea ECx, [ebp-10h]
56. 004012d6 call @ ILT + 0 (Apple ::~ Apple) (00401005)
58. 004012db mov ECx, dword ptr [ebp-0Ch]
60. 004012de mov dword ptr fs: [0], ECx
62. 004012e5 pop EDI
64. 004012e6 pop ESI
66. 004012e7 pop EBX
68. 004012e8 add ESP, 58 h
70. 004012eb cmp ebp, ESP
72. 004012ed call _ chkesp (004087c0)
74. 004012f2 mov ESP, EBP
76. 004012f4 pop EBP
78. 004012f5 RET

CodeFor example, you can view the corresponding assembly code according to 70, 71, 72, and 73:

(1) 70 sentences: we can see that the function has been called twice, which happens to be Apple's constructor call. This also corresponds to two temporary variables A and C, the addresses of the two variables are [ebp-10] and [ebp-14], here we can see that the size of the entire class is 4 bytes, it is a common memory for storing data. The main reason why constructors can be bound with the corresponding memory is that ECx records the starting address of the memory, which is critical in C ++ compilation. We can see that the C ++ constructor seems to be not bound to the memory. In fact, the conventions have been made in VC. ECx is the this pointer, which is the class memory start address. If you are interested, let's take a look at the register that stores this pointer during G ++ compilation? (Actually eax)

(2) 71: The eax records the address of the referenced variable, and ECx is next to four bytes under EBP. However, the address of the function call is not the same as the default constructor, so we can guess that the constructor here is a copy constructor. We can check the Print message during debugging.

(3) 72 sentences: The 0x4012af statement clearly tells us that the called function here is the operator = function, which is the reload of arithmetic operators, we will focus on this in our blog later.

(4) 73: as we have mentioned earlier, the Destructor are automatically called at the end of the function call. So here we see three calls appear? These three variables are exactly the three variables A, B, and C we mentioned earlier. So what is the order of the three variable calls? Let's look at the address of the variable, which is [ebp-18h], [ebp-14h], [ebp-10h], which is exactly the opposite order of the variable. So we can see that the Destructor and the constructor correspond exactly to each other, who appears first and then analyzes the constructor.

 

 

[notice: the following blog summarizes some of the phenomena in the structure and analysis.]