类内部存储的东西：太简洁了----小话c++(5)

http://blog.csdn.net/cxsjabcabc/article/details/7623630

想知道一个类内部是什么，没有比知道它存储的数据还更直接的了。

Q： 为什么一个不包含任何成员变量的类的大小不是0？

如下代码：

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. #define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;  
5.   
6. class Test  
7. {  
8. public:  
9.     Test()  
10.     {  
11.         std::cout << "Test is called..." << std::endl;  
12.     }  
13.       
14.     ~Test()  
15.     {  
16.         std::cout << "~Test is called..." << std::endl;  
17.     }  
18. };  
19.   
20. int main (int argc, const char * argv[])  
21. {  
22.     COUT_ENDL(sizeof(Test))  
23.       
24.     return 0;  
25. }  

运行结果：

[plain]  view plain copy

1. sizeof(Test) is 1  

A： 这在于，如果使用Test创建一个对象，那么这个对象的大小如果是0的话，可能造成不同对象具有相同的地址；这可能导致之后的访问出现不明确的状态。所以，一般，编译器会给大小为0的类中自动插入一个字节的大小，具体多大可能取决于编译器。我们能够肯定的是，它一定不是0.

Q： Test类的构造函数占用类对象的空间吗？

A： 根据上面sizeof得到的值，它应该是不占用的。从实际上说，从代码段的角度，它们和c函数中的全局函数没什么不同；只不过如何访问它们可能有限制而已。经过测试，发现如果想直接获取Test类构造函数的地址，赋值给c风格函数指针，编译器总是报错，必须采用指向类成员函数指针的方式才能使用，所以这里无法给出一个很好证明它类似全局函数的例子。

Q： 如果一个类中含有成员变量，可以通过获取此类对象的地址绕开访问权限函数来修改对象内部数据吗？

A： 通过地址来修改数据，c++无法阻止这样的操作，只要它不越界访问。如下代码：

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. #define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;  
5.   
6. class A  
7. {  
8. public:  
9.     A(int value_one, int value_two):_value_one(value_one), _value_two(value_two) { }  
10.     int value_one() const { return _value_one; }  
11.     int value_two() const { return _value_two; }  
12.       
13. private:  
14.     int _value_one;  
15.     int _value_two;  
16. };  
17.   
18. int main (int argc, const char * argv[])  
19. {  
20.     A a(10, 100);  
21.     COUT_ENDL(a.value_one())  
22.     COUT_ENDL(a.value_two())  
23.       
24.     A *pa = &a;  
25.     *(int *)pa = 11;            // modify a's _value_one  
26.     *((int *)pa + 1) = 111;     // modify a's _value_two  
27.       
28.     COUT_ENDL(a.value_one())  
29.     COUT_ENDL(a.value_two())  
30.       
31.     return 0;  
32. }  

运行结果：

[plain]  view plain copy

1. a.value_one() is 10  
2. a.value_two() is 100  
3. a.value_one() is 11  
4. a.value_two() is 111  

显然，此方法有效，而且根本不用担心所操作对应的成员是否是protected或者private的。而且可以确定的是，对象a中成员_value_one地址为a首地址；_value_two的地址紧挨着成员_value_one.

Q： 如果具备继承体系的类对象，成员如何摆放？

A： 如下示例：

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. #define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;  
5.   
6. class A  
7. {  
8. public:  
9.     A(int value_one, int value_two):_value_one(value_one), _value_two(value_two) { }  
10.     int value_one() const { return _value_one; }  
11.     int value_two() const { return _value_two; }  
12.       
13. private:  
14.     int _value_one;  
15.     int _value_two;  
16. };  
17.   
18. class A_Ex : public A  
19. {  
20. public:  
21.     A_Ex(int one, int two, int three):A(one, two), _value_three(three) { }  
22.       
23.     int value_three() const { return _value_three; }  
24.       
25. private:  
26.     int _value_three;  
27. };  
28.   
29. int main (int argc, const char * argv[])  
30. {  
31.     A_Ex a(10, 100, 1000);  
32.       
33.     A *pa = &a;  
34.     COUT_ENDL(*(int *)pa)              
35.     COUT_ENDL(*((int *)pa + 1))      
36.     COUT_ENDL(*((int *)pa + 2))    
37.       
38.     return 0;  
39. }  

运行结果：

[plain]  view plain copy

1. *(int *)pa is 10  
2. *((int *)pa + 1) is 100  
3. *((int *)pa + 2) is 1000  

可以看出，A_Ex类继承A类，它的对象首先存放基类成员信息，接着存放本类成员信息，很简单，很直接。

Q： 如果类中含有虚函数，类大小会发生怎样的变化？

A： 如下代码：

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. #define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;  
5.   
6. class A  
7. {  
8. public:  
9.     A(int value_one, int value_two):_value_one(value_one), _value_two(value_two) { }  
10.     int value_one() const { return _value_one; }  
11.     int value_two() const { return _value_two; }  
12.       
13.     virtual void show() const { }  
14.       
15. private:  
16.     int _value_one;  
17.     int _value_two;  
18. };  
19.   
20. class A_Ex : public A  
21. {  
22. public:  
23.     A_Ex(int one, int two, int three):A(one, two), _value_three(three) { }  
24.       
25.     int value_three() const { return _value_three; }  
26.       
27. private:  
28.     int _value_three;  
29. };  
30.   
31. int main (int argc, const char * argv[])  
32. {  
33.     A a(10, 100);  
34.     A_Ex a_ex(97, 98, 99);  
35.     COUT_ENDL(sizeof(A))  
36.     COUT_ENDL(sizeof(A_Ex))  
37.       
38.     return 0;  
39. }  

运行结果(生成32位应用程序)：

[plain]  view plain copy

1. sizeof(A) is 12  
2. sizeof(A_Ex) is 16  

如果在函数结束前加上断点，并打印变量a和a_ex内部数据，得到如下：

很明显，可以看到，虚表指针占用了对象最初的部分，后面接着是成员变量。

Q： 虚表指针到底在哪里？

A： 根据上面的输出数据，虚表指针保存在对象首地址处。下面将来证明它的存在：

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. #define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;  
5.   
6. class A  
7. {  
8. public:  
9.     A(int value_one, int value_two):_value_one(value_one), _value_two(value_two) { }  
10.     int value_one() const { return _value_one; }  
11.     int value_two() const { return _value_two; }  
12.       
13.     virtual void show() const {  std::cout << "show A..." << std::endl; }  
14.       
15. private:  
16.     int _value_one;  
17.     int _value_two;  
18. };  
19.   
20. class A_Ex : public A  
21. {  
22. public:  
23.     A_Ex(int one, int two, int three):A(one, two), _value_three(three) { }  
24.       
25.     int value_three() const { return _value_three; }  
26.     virtual void show() const { std::cout << "show A_Ex..." << std::endl; }  
27.       
28. private:  
29.     int _value_three;  
30. };  
31.   
32. typedef void (*c_style_show)();  
33.   
34. int main (int argc, const char * argv[])  
35. {  
36.     A a(10, 100);  
37.     A_Ex a_ex(97, 98, 99);  
38.       
39.     int *p_vtable = (int *)&a;  // get the address of a, also the vtable pointer's pointer  
40.     COUT_ENDL(p_vtable)  
41.     int *vtable = (int *)*p_vtable; // dereference to get the vtable pointer  
42.     COUT_ENDL(vtable)  
43.       
44.     // get the first virtual func addr  
45.     int *firstVirtualFunc = (int *)vtable[0];  
46.     COUT_ENDL(firstVirtualFunc)  
47.       
48.     // convert it to the c_style func, and call it  
49.     c_style_show show_func = (c_style_show)firstVirtualFunc;  
50.     show_func();  
51.       
52.     return 0;  
53. }  

上面的代码，是要刻意取出虚函数表中第一个函数指针(理论上就会是show函数).

对象a虚表指针以及虚表内部函数指针的关系简图如下：

由上图，可知，show_func将被赋值为A类中的show函数。执行结果如下：

[plain]  view plain copy

1. p_vtable is 0xbffff9d8  
2. vtable is 0x2060  
3. firstVirtualFunc is 0x1b50  
4. show A...  

同理，可以对a_ex对象进行剖析，找出它的虚表和虚表函数。

其实，从上面的分析，也能间接证明类中的成员函数也可以看成全局函数的特殊形式，只是访问方式有所限制。

Q： 当子类和父类的大小不一致的时候，出现的对象切割，该如何理解？

A： 如果非要将一个较大的对象赋值给较小的对象，而且没有按照特定的转换方式，终究可能会发生数据丢失的问题。如下例子：

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. #define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;  
5.   
6. class A  
7. {  
8. public:  
9.     A(int value_one, int value_two):_value_one(value_one), _value_two(value_two) { }  
10.     int value_one() const { return _value_one; }  
11.     int value_two() const { return _value_two; }  
12.       
13.     virtual void show() const {  std::cout << "show A..." << std::endl; }  
14.   
15.       
16. private:  
17.     int _value_one;  
18.     int _value_two;  
19. };  
20.   
21. class A_Ex : public A  
22. {  
23. public:  
24.     A_Ex(int one, int two, int three):A(one, two), _value_three(three) { }  
25.       
26.     int value_three() const { return _value_three; }  
27.     virtual void show() const { std::cout << "show A_Ex..." << std::endl; }  
28.       
29. private:  
30.     int _value_three;  
31. };  
32.   
33.   
34. int main (int argc, const char * argv[])  
35. {  
36.     A *pa = new A(10, 100);  
37.     A_Ex *pa_ex = new A_Ex(97, 98, 99);  
38.       
39.     pa->show();  
40.     pa_ex->show();  
41.       
42.     *pa = *pa_ex;   // cause slice  
43.     pa->show();  
44.     pa_ex->show();  
45.       
46.     delete pa_ex;  
47.     delete pa;  
48.       
49.     return 0;  
50. }  

输出结果：

[plain]  view plain copy

1. show A...  
2. show A_Ex...  
3. show A...  
4. show A_Ex...  

可以看出，*pa = *pa_ex; 虽然造成了对象切割，但是并没有影响pa对象调用show的结果。调试，具体查看下被切割后的结果：

在两个断点处打印*pa的数据：

可以看出*pa数据确实被对象a_ex的数据替换了，不过也可以看出对象a的虚表指针依然没变，导致了调用show函数没有改变。

Q： 可以改变对象a的虚表指针的值吗？

A： 当然可以。如下代码：

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. #define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;  
5.   
6. class A  
7. {  
8. public:  
9.     A(int value_one, int value_two):_value_one(value_one), _value_two(value_two) { }  
10.     int value_one() const { return _value_one; }  
11.     int value_two() const { return _value_two; }  
12.       
13.     virtual void show() const {  std::cout << "show A..." << std::endl; }  
14.   
15.     A & operator=(const A& a)  
16.     {  
17.         if(this != &a)  
18.         {  
19.             *(int *)this = *(int *)&a;  
20.             _value_one = a._value_one;  
21.             _value_two = a._value_two;  
22.         }  
23.         return *this;  
24.     }  
25.       
26. private:  
27.     int _value_one;  
28.     int _value_two;  
29. };  
30.   
31. class A_Ex : public A  
32. {  
33. public:  
34.     A_Ex(int one, int two, int three):A(one, two), _value_three(three) { }  
35.       
36.     int value_three() const { return _value_three; }  
37.     virtual void show() const { std::cout << "show A_Ex..." << std::endl; }  
38.       
39. private:  
40.     int _value_three;  
41. };  
42.   
43.   
44. int main (int argc, const char * argv[])  
45. {  
46.     A *pa = new A(10, 100);  
47.     A_Ex *pa_ex = new A_Ex(97, 98, 99);  
48.       
49.     pa->show();  
50.     pa_ex->show();  
51.       
52.     *pa = *pa_ex;   // cause slice  
53.     pa->show();  
54.     pa_ex->show();  
55.       
56.     delete pa_ex;  
57.     delete pa;  
58.       
59.     return 0;  
60. }  

类A中增加了重载赋值运算符的函数，且内部将对象首地址的虚表指针更改。

运行结果：

[plain]  view plain copy

1. show A...  
2. show A_Ex...  
3. show A_Ex...  
4. show A_Ex...  

可以看出，对象a的虚表指针已经被更改。

如此简单直白的对象模型, c++继承了c语言的特点。