C ++ (class inheritance) 11 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]

 

Inheritance is a basic attribute of a class, but how is the function initialized during the class inheritance process? How can we analyze the structure? Let's take a look at the following section.Code?

[CPP] View plaincopy

2. ClassEmployee
4. {
6. Public:
8. Employee () {printf ("Employee ()! \ N");}
10. ~ Employee () {printf ("~ Employee ()! \ N");}
12. };
16. ClassManager:PublicEmployee
18. {
20. Public:
22. Manager () {printf ("Manager ()! \ N");}
24. ~ Manager () {printf ("~ Maneger ()! \ N");}
26. };

Seeing the code above, I believe everyone understands that we have defined such a class. The base class is empoyee, and the inheritance class is Manager. We can see that manager is a special kind of employee. How can we arrange functions during memory construction and analysis?

[CPP] View plaincopy

2. 74: manager m;
4. 00401268 Lea ECx, [ebp-4]
6. 0040126b call @ ILT + 60 (Manager: Manager) (00401041)
8. 75 :}
10. 00401270 Lea ECx, [ebp-4]
12. 00401273 call @ ILT + 0 (Manager ::~ Manager) (00401005)
14. 00401278 pop EDI
16. 00401279 pop ESI
18. 004020.a pop EBX
20. 004010000b add ESP, 44 h
22. 0040da-e cmp ebp, ESP
24. 00401280 call _ chkesp (00408760)
26. 00401285 mov ESP, EBP
28. 00401287 pop EBP

We found that the manager structure and analysis structure are also simple. A constructor is constructed when a variable appears. When will the structure be analyzed? The function is analyzed at the end of the process. Next, we can further discuss how the structure and structure of the Manager are actually implemented?

[CPP] View plaincopy

2. 65:ClassManager:PublicEmployee
4. 66 :{
6. 67:Public:
8. 68: Manager () {printf ("Manager ()! \ N");}
10. 004012a0 push EBP
12. 004012a1 mov EBP, ESP
14. 004012a3 sub ESP, 44 h
16. 004012a6 push EBX
18. 004012a7 push ESI
20. 004012a8 push EDI
22. 004012a9 push ECx
24. 004012aa Lea EDI, [ebp-44h]
26. 004012ad mov ECx, 11 h
28. 004012b2 mov eax, 0 cccccccch
30. 004012b7 rep STOs dword ptr [EDI]
32. 004012b9 pop ECx
34. 004012ba mov dword ptr [ebp-4], ECx
36. 004012bd mov ECx, dword ptr [ebp-4]
38. 004012c0 call @ ILT + 40 (employee: Employee) (0040102d)
40. 004012c5 push offset string"Manager ()! \ N"(00431020)
42. 004012ca call printf (004086e0)
44. 004012cf add ESP, 4
46. 004012d2 mov eax, dword ptr [ebp-4]
48. 004012d5 pop EDI
50. 004012d6 pop ESI
52. 004012d7 pop EBX
54. 004012d8 add ESP, 44 h
56. 004012db cmp ebp, ESP
58. 004012dd call _ chkesp (00408760)
60. 004012e2 mov ESP, EBP
62. 004012e4 pop EBP
64. 004012e5 RET

We found that the default constructor of employee is added to the Manager constructor. What about the Destructor?

[CPP] View plaincopy

2. 69 :~ Manager () {printf ("~ Maneger ()! \ N");}
4. 00401350 push EBP
6. 00401351 mov EBP, ESP
8. 00401353 sub ESP, 44 h
10. 00401356 push EBX
12. 00401357 push ESI
14. 00401358 push EDI
16. 00401359 push ECx
18. 0040135a Lea EDI, [ebp-44h]
20. 0040135d mov ECx, 11 h
22. 00401362 mov eax, 0 cccccccch
24. 00401367 rep STOs dword ptr [EDI]
26. 00401369 pop ECx
28. 0040136a mov dword ptr [ebp-4], ECx
30. 0040136d push offset string"~ Maneger ()! \ N"(00431040)
32. 00401372 call printf (004086e0)
34. 00401377 add ESP, 4
36. 0040137a mov ECx, dword ptr [ebp-4]
38. 0040137d call @ ILT + 5 (employee ::~ Employee) (0040100a)
40. 00401382 pop EDI
42. 00401383 pop ESI
44. 00401384 pop EBX
46. 00401385 add ESP, 44 h
48. 00401388 cmp ebp, ESP
50. 0040138a call _ chkesp (00408760)
52. 0040138f mov ESP, EBP
54. 00401391 pop EBP
56. 00401392 RET

We found that when the manager is constructed, the employee is constructed first, and then the manager is printed. When the structure is analyzed, the manager first analyzes itself and then calls the destructor of the employee, the assembly code above demonstrates everything.