C++程序运行时内存布局之----------this到底是什么？

先问一个问题，在C++里，成员函数里的this指针和调用此函数的对象地址总是一样的吗？如果你的回答是：不一定。那么至少你是个老手吧，下面的内容你就不用看了；如果你的回答是：是啊，那么强烈建议你看看下面的内容。

 

非静态成员函数，无论是不是虚函数，都隐藏了一个this指针参数。这个参数的目的就是给函数提供一个基地址，以便于函数体内能找到对象的成员变量。那非静态成员函数是如何根据this指针找到成员变量的呢？直接看例子吧

 

1没有虚表的情况

view plain

1. #include <iostream>  
2. #include <stdio.h>  
3.   
4. using namespace std;  
5.   
6. class A  
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<<"this指针得值是:"<<std::hex<<std::showbase<<this<<endl;  
17.     }  
18. };  
19.   
20.   
21.   
22. int main(int argc, char** argv)  
23. {  
24.     A a;  
25.     cout<<"a对象的地址是:"<<&a<<endl;  
26.     cout<<"a对象的大小是:"<<sizeof(A)<<endl;  
27.     cout<<"成员a.x的地址是: "<<&a.x<<endl;  
28.     cout<<"成员a.x的偏移是:"<<&A::x<<endl;  
29.     a.F1();  
30.     cin>>argc;  
31.     return 0;  
32. }  

那么函数F1的实现伪代码为：

 

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

*(this+&A::y-1) = 2;

 

其中&A::x是成员x的偏移+1，&A::y是成员y的偏移+1，这可是C++基本语法的知识，希望你知道，呵呵。可这些偏移量是相对应那里的偏移呢，是对象地址吗，答案是NO。是相对于第一个成员变量的偏移，这对于有些对象也许没有差别，但是对于有虚表的类的对象，就有差别了。这些偏移在编译期间就是确定了的。对于本例在VC++2010下&A::x,值为1， &A::y,值为5。为什么不是0,4，请看《Inside The C++ Object Model》。

所以，对于找到成员变量，需要进一步确定的只有this的值。程序运行结果如下：

可见此例中，对象的地址与this指针的地址相同，内存图如下所示。

2有一个虚表的情况

view plain

1. #include <iostream>  
2. #include <stdio.h>  
3.   
4. using namespace std;  
5.   
6. class A  
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<<"this指针得值是:"<<std::hex<<std::showbase<<this<<endl;  
17.     }  
18. };  
19.   
20.   
21.   
22. int main(int argc, char** argv)  
23. {  
24.     A* p = new A();  
25.     cout<<"a对象的地址是:"<<p<<endl;  
26.     cout<<"a对象的大小是:"<<sizeof(A)<<endl;  
27.     cout<<"成员a.x的地址是: "<<&p->x<<endl;  
28.     cout<<"成员a.x的偏移是:"<<&A::x<<endl;  
29.     p->F1();  
30.     cin>>argc;  
31.     return 0;  
32. }  

 

此时函数F1的实现伪代码为：

 

*(this+4+&A::x-1) = 1;  //+4是因为存在虚表指针

*(this+4+&A::y-1) = 2;  //+4是因为存在虚表指针

 

程序运行结果如下：

内存布局如下：

结论：this的值和对象地址相同，成员变量偏移量不因虚表指针存在而改变。带虚表的类的成员函数对成员变量的寻址方式不同，增加一个+4。

3单继承的情况

view plain

1. #include <iostream>  
2. #include <stdio.h>  
3.   
4. using namespace std;  
5.   
6. class A  
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<<"this指针得值是:"<<std::hex<<std::showbase<<this<<endl;  
17.     }  
18. };  
19.   
20. class B : public A  
21. {  
22. public:  
23.     int z;  
24. public:  
25.     virtual void F2()  
26.     {  
27.         cout<<"this指针得值是:"<<std::hex<<std::showbase<<this<<endl;  
28.     }  
29. };  
30.   
31. int main(int argc, char** argv)  
32. {  
33.     B* pb = new B();  
34.     cout<<"对象的地址为:"<<std::hex<<std::showbase<<pb<<endl;  
35.     pb->F1();  
36.     pb->F2();  
37.   
38.     cin>>argc;  
39.     return 0;  
40. }  

 

运行结果：

内存布局：

结论：this指针的值受两个因素确定，一是对象的地址，二是定义成员函数的类。This指向的是对象内，定义该方法的类得subobject。

4 多继承的情况

先看A没有虚函数，B有虚函数的情况

view plain

1. #include <iostream>  
2. #include <stdio.h>  
3.   
4. using namespace std;  
5.   
6. class A  
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<<"this指针得值是:"<<std::hex<<std::showbase<<this<<endl;  
17.     }  
18. };  
19.   
20. class B  
21. {  
22. public:  
23.     int z;  
24. public:  
25.     virtual void F2()  
26.     {  
27.         cout<<"this指针得值是:"<<std::hex<<std::showbase<<this<<endl;  
28.     }  
29. };  
30.   
31. class C : public A, public B  
32. {  
33. public:  
34.     int a;  
35. public:  
36.     virtual void F2()  
37.     {  
38.         cout<<"this指针得值是:"<<std::hex<<std::showbase<<this<<endl;  
39.     }  
40.     void F3()  
41.     {  
42.         cout<<"this指针得值是:"<<std::hex<<std::showbase<<this<<endl;  
43.     }  
44. };  
45. int main(int argc, char** argv)  
46. {  
47.     C* pc = new C();  
48.     cout<<"对象的大小为:"<<sizeof(C)<<endl;  
49.     cout<<"对象的地址为:"<<std::hex<<std::showbase<<pc<<endl;  
50.     pc->F1();  
51.     pc->F2();  
52.     pc->F3();  
53.   
54.     cin>>argc;  
55.     return 0;  
56. }  

结果：

内存布局：

再看，如果A,B都有虚函数的情况。

代码：

view plain

1. #include <iostream>  
2. #include <stdio.h>  
3.   
4. using namespace std;  
5.   
6. class A  
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<<"this指针得值是:"<<std::hex<<std::showbase<<this<<endl;  
17.     }  
18. };  
19.   
20. class B  
21. {  
22. public:  
23.     int z;  
24. public:  
25.     virtual void F2()  
26.     {  
27.         cout<<"this指针得值是:"<<std::hex<<std::showbase<<this<<endl;  
28.     }  
29. };  
30.   
31. class C : public A, public B  
32. {  
33. public:  
34.     int a;  
35. public:  
36.     virtual void F2()  
37.     {  
38.         cout<<"this指针得值是:"<<std::hex<<std::showbase<<this<<endl;  
39.     }  
40.     void F3()  
41.     {  
42.         cout<<"this指针得值是:"<<std::hex<<std::showbase<<this<<endl;  
43.     }  
44. };  
45. int main(int argc, char** argv)  
46. {  
47.     C* pc = new C();  
48.     cout<<"对象的大小为:"<<sizeof(C)<<endl;  
49.     cout<<"对象的地址为:"<<std::hex<<std::showbase<<pc<<endl;  
50.     cout<<"x的地址"<<&pc->x<<endl;  
51.     cout<<"z的地址"<<&pc->z<<endl;  
52.     pc->F1();  
53.     pc->F2();  
54.     pc->B::F2();  
55.     pc->F3();  
56.   
57.     cin>>argc;  
58.     return 0;  
59. }  

结果：

内存布局：

结论：再一次验证了this指针的值的确定方法，this始终要保证指向定义了该成员函数的类得subobject。因为C++保证base class subobject与base class object完全对应，从而保证了成员函数能根据成员变量在定义了该变量的类中的偏移寻址。

本文转自

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