Memory layout when C ++ is running ---- what is this?

Address: http://blog.csdn.net/smstong/article/details/6604388

 

First, let's ask a question. In C ++, is the this pointer in the member function always the same as the address of the object that calls this function? If your answer is: Not necessarily. At least you are a veteran. You don't need to read the following content. If your answer is yes, you are strongly advised to take a look at the following content.

 

Non-static member functions, whether virtual or not, hide a this pointer parameter. The purpose of this parameter is to provide a base address for the function so that the function can find the member variables of the object. Then how does a non-static member function find member variables based on the this pointer? Let's look at the example.

 

1. No virtual table

1. # Include <iostream>
2. # Include <stdio. h>
4. Using namespace STD;
6. Class
7. {
8. Public:
9. Int X;
10. Int y;
11. Public:
12. Void F1 ()
13. {
14. This-> x = 1;
15. This-> Y = 2;
16. Cout <"the value of this pointer is:" <STD: Hex <STD: showbase <This <Endl;
17. }
18. };
22. Int main (INT argc, char ** argv)
23. {
24. A;
25. Cout <"the address of object A is:" <& A <Endl;
26. Cout <"the size of object A is:" <sizeof (a) <Endl;
27. Cout <"the address of a. x member is:" <& A. x <Endl;
28. Cout <"the offset of A. X Member is:" <& A: x <Endl;
29. A. F1 ();
30. Cin> argc;
31. Return 0;
32. }

Then the pseudo code of function F1 is:

 

* (This + & A: x-1) = 1;

* (This + & A: Y-1) = 2;

 

Where & A: X is the offset of member x + 1, & A: Y is the offset of member y + 1, which is the basic syntax knowledge of C ++, hope you know. But these offsets correspond to the corresponding offsets. Is it the object address? The answer is no. It is the offset relative to the first member variable, which may not be different for some objects, but for objects with classes with virtual tables, there is a difference. These offsets are determined during compilation. In this example, & A: X under VC ++ 2010 has a value of 1, & A: Y, and a value of 5. For more information about the reason, see inside the C ++ object model.

Therefore, only the value of this needs to be determined for finding the member variable. The program running result is as follows:

In this example, the object address is the same as the address of this pointer. The memory figure is as follows.

2. There is a virtual table.

1. # Include <iostream>
2. # Include <stdio. h>
4. Using namespace STD;
6. Class
7. {
8. Public:
9. Int X;
10. Int y;
11. Public:
12. Virtual void F1 ()
13. {
14. This-> x = 1;
15. This-> Y = 2;
16. Cout <"the value of this pointer is:" <STD: Hex <STD: showbase <This <Endl;
17. }
18. };
22. Int main (INT argc, char ** argv)
23. {
24. A * P = new ();
25. Cout <"the address of object A is:" <p <Endl;
26. Cout <"the size of object A is:" <sizeof (a) <Endl;
27. Cout <"the address of a. x member is:" <& P-> x <Endl;
28. Cout <"the offset of A. X Member is:" <& A: x <Endl;
29. P-> F1 ();
30. Cin> argc;
31. Return 0;
32. }

 

In this case, the pseudo code of function F1 is:

 

* (This + 4 + & A: x-1) = 1; // + 4 because there is a virtual table pointer

* (This + 4 + & A: Y-1) = 2; // + 4 because there is a virtual table pointer

 

The program running result is as follows:

The memory layout is as follows:

Conclusion: The value of this is the same as the object address, and the offset of the member variable does not change because of the existence of the virtual table pointer. The member functions of classes with virtual tables have different addressing methods for member variables. Add one + 4.

3. Single inheritance

1. # Include <iostream>
2. # Include <stdio. h>
4. Using namespace STD;
6. Class
7. {
8. Public:
9. Int X;
10. Int y;
11. Public:
12. Void F1 ()
13. {
14. This-> x = 1;
15. This-> Y = 2;
16. Cout <"the value of this pointer is:" <STD: Hex <STD: showbase <This <Endl;
17. }
18. };
20. Class B: public
21. {
22. Public:
23. Int Z;
24. Public:
25. Virtual void F2 ()
26. {
27. Cout <"the value of this pointer is:" <STD: Hex <STD: showbase <This <Endl;
28. }
29. };
31. Int main (INT argc, char ** argv)
32. {
33. B * pb = new B ();
34. Cout <"the object address is:" <STD: Hex <STD: showbase <Pb <Endl;
35. Pb-> F1 ();
36. Pb-> F2 ();
38. Cin> argc;
39. Return 0;
40. }

 

Running result:

Memory layout:

Conclusion: The value of this pointer is determined by two factors: one is the object address, and the other is the class that defines the member function. This points to the subobject class that defines the method in the object.

4 Multi-Inheritance

First, check whether a has a virtual function or B has a virtual function.

1. # Include <iostream>
2. # Include <stdio. h>
4. Using namespace STD;
6. Class
7. {
8. Public:
9. Int X;
10. Int y;
11. Public:
12. Void F1 ()
13. {
14. This-> x = 1;
15. This-> Y = 2;
16. Cout <"the value of this pointer is:" <STD: Hex <STD: showbase <This <Endl;
17. }
18. };
20. Class B
21. {
22. Public:
23. Int Z;
24. Public:
25. Virtual void F2 ()
26. {
27. Cout <"the value of this pointer is:" <STD: Hex <STD: showbase <This <Endl;
28. }
29. };
31. Class C: Public A, public B
32. {
33. Public:
34. Int;
35. Public:
36. Virtual void F2 ()
37. {
38. Cout <"the value of this pointer is:" <STD: Hex <STD: showbase <This <Endl;
39. }
40. Void F3 ()
41. {
42. Cout <"the value of this pointer is:" <STD: Hex <STD: showbase <This <Endl;
43. }
44. };
45. Int main (INT argc, char ** argv)
46. {
47. C * Pc = new C ();
48. Cout <"object size:" <sizeof (c) <Endl;
49. Cout <"the object address is:" <STD: Hex <STD: showbase <Pc <Endl;
50. PC-> F1 ();
51. PC-> F2 ();
52. PC-> F3 ();
54. Cin> argc;
55. Return 0;
56. }

Result:

Memory layout:

Again, if a and B both have virtual functions.

Code:

1. # Include <iostream>
2. # Include <stdio. h>
4. Using namespace STD;
6. Class
7. {
8. Public:
9. Int X;
10. Int y;
11. Public:
12. Virtual void F1 ()
13. {
14. This-> x = 1;
15. This-> Y = 2;
16. Cout <"the value of this pointer is:" <STD: Hex <STD: showbase <This <Endl;
17. }
18. };
20. Class B
21. {
22. Public:
23. Int Z;
24. Public:
25. Virtual void F2 ()
26. {
27. Cout <"the value of this pointer is:" <STD: Hex <STD: showbase <This <Endl;
28. }
29. };
31. Class C: Public A, public B
32. {
33. Public:
34. Int;
35. Public:
36. Virtual void F2 ()
37. {
38. Cout <"the value of this pointer is:" <STD: Hex <STD: showbase <This <Endl;
39. }
40. Void F3 ()
41. {
42. Cout <"the value of this pointer is:" <STD: Hex <STD: showbase <This <Endl;
43. }
44. };
45. Int main (INT argc, char ** argv)
46. {
47. C * Pc = new C ();
48. Cout <"object size:" <sizeof (c) <Endl;
49. Cout <"the object address is:" <STD: Hex <STD: showbase <Pc <Endl;
50. Cout <"X address" <& PC-> x <Endl;
51. Cout <"Z address" <& PC-> Z <Endl;
52. PC-> F1 ();
53. PC-> F2 ();
54. PC-> B: F2 ();
55. PC-> F3 ();
57. Cin> argc;
58. Return 0;
59. }

Result:

Memory layout:

Conclusion: The method for determining the value of this pointer is verified again. This must always point to the subobject class that defines the member function. C ++ ensures that the base class subobject exactly corresponds to the base class object, so that the member function can address the offset of the variable in the class defined by the member variable.