C ++ (pointer 2) 03.2 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]

 

(4) pointer and reference

References are one of the differences between C ++ and languages. In essence, the two are the same. Let's take a look at the following two paragraphs.Code.

A) function code for pointers and pointers

[CPP] View plaincopy

1. VoidAdd_point (Int* Q)
2. {
3. (* Q) ++;
4. }
6. VoidAdd_ref (Int& Q)
7. {
8. Q ++;
9. }

B) function call code

[CPP] View plaincopy

2. 56:IntM = 10;
4. 004012e8 mov dword ptr [ebp-4], 0ah
6. 57: add_point (& M );
8. 004012ef Lea eax, [ebp-4]
10. 004012f2 push eax
12. 004012f3 call @ ILT + 45 (process) (00401032)
14. 004012f8 add ESP, 4
16. 58: add_ref (m );
18. 004012fb Lea ECx, [ebp-4]
20. 004012fe push ECx
22. 004012ff call @ ILT + 50 (add_ref) (00401037)
24. 00401304 add ESP, 4
26. 59:Return1;
28. 00401307 mov eax, 1
30. 60 :}

After analysis, we find that the functions implemented by the add_point function and the add_ref function both perform auto-increment processing on the input data. Only when processing, the input parameter of a function is a needle, and the input parameter of a function is a reference. When calling a function, you can find that the pointer and reference are the same. First, let's take a look at add_point. The first sentence gets the address of M and copies it to eax. The second sentence is stack processing, the third sentence is the function add_point, and the fourth sentence is the stack backtracking. Let's also take a look at add_ref. The first sentence gets the address of M and copies it to ECx. The second sentence is ECx pressure stack processing. The third sentence calls the function add_ref and the fourth sentence is stack backtracking. I believe that here, we will understand why C ++'s predecessors encouraged you to use more references.

(5) pointer and struct

When learning data nodes, I believe everyone has learned such a data structure definition:

[CPP] View plaincopy

1. Typedef Struct_ Node
2. {
3. IntData;
4. Struct_ Node * next;
5. } Node;

At that time, we did not understand what this struct meant? In fact, this definition is completely changed to the following:

[CPP] View plaincopy

1. Typedef Struct_ Node
2. {
3. IntData;
4. Void* Next;
5. } Node;

The two data structures are actually completely consistent. The first data stores the data, the second data is a pointer, And the content is a data type address. The identified address type is the same as that of the void * type. However, the previous one is more direct. The latter type of address is convenient, but it is troublesome to convert each time it is used. If you are interested, take a look at the following question:

[CPP] View plaincopy

1. Typedef Struct_ Node
2. {
3. Struct_ Node * next;
4. } Node;

Can we regard the node address as node * or node *? Is there a difference between the two? (Actually there is no difference)

In the Linux kernel code, there is a method for calculating the offset value. For details, refer:

[CPP] View plaincopy

1. IntOffset = (Int) & (Node *) (0)-> next );

(6) Class pointer

The class pointer is complicated, but you can see some clues from a small example:

[CPP] View plaincopy

2. ClassFruit
4. {
6. Public:
8. Fruit (){}
10. ~ Fruit (){}
12. VoidPrint () {printf ("Fruit! \ N");}
14. };
18. ClassApple:PublicFruit
20. {
22. Public:
24. Apple (){}
26. ~ Apple (){}
28. VoidPrint () {printf ("Apple! \ N");}
30. };
34. VoidProcess ()
36. {
38. Fruit F;
40. Apple * A = (Apple *) & F;
42. A-> Print ();
44. Fruit * B = & F;
46. B-> Print ();
48. }

If you are familiar with C ++, you will soon know the answer to this question. Why does a and B point to the same address and use the same print function, but the result is different. I think this is mainly because the data types of the two are different. Once a pointer is bound to a certain data type, all the behavior of this pointer is actually limited by this type of data. The general data type is the same as the custom class type. As long as the print function is not preceded by virtual, we will find that both print calls are hard-coded, which is similar to common function calls. Therefore, pointers cannot be separated from data types. Leaving a specific type of address makes no sense. Just like void * can be forgiven, but void is unacceptable. The assembly code below demonstrates this point.

[CPP] View plaincopy

2. 65: fruit F;
4. 0040132d Lea ECx, [ebp-10h]
6. 00401330 call @ ILT + 35 (fruit: Fruit) (00401028)
8. 00401335 mov dword ptr [ebp-4], 0
10. 66: Apple * A = (Apple *) & F;
12. 0040133c Lea eax, [ebp-10h]
14. 0040133f mov dword ptr [ebp-14h], eax
16. 67: A-> Print ();
18. 00401342 mov ECx, dword ptr [ebp-14h]
20. 00401345 call @ ILT + 0 (Apple: print) (00401005)
22. 68: Fruit * B = & F;
24. 0040134a Lea ECx, [ebp-10h]
26. 0040134d mov dword ptr [ebp-18h], ECx
28. 69: B-> Print ();
30. 00401350 mov ECx, dword ptr [ebp-18h]
32. 00401353 call @ ILT + 25 (fruit: print) (0040101e)

 

(Full text)