c++对象的内存布局。

disheng727

如下代码：

1. 
   
2. class A {
   
3. public:
   
4.     int a;
   
5.     char x;
   
6. };
   
7. 
   
8. class B : public A {
   
9. public:
   
10.     char y;
    
11. };
    
12. 
    
13. class C : public B {
    
14. public:
    
15.     char z;
    
16. };
    
17. 
    
18. int main() {
    
19.     cout << sizeof(A) << sizeof(B) << sizeof(C) << endl;
    
20.     return 0;
    
21. }
    

复制代码

我测试了一下，32位机上，结果为 8，12，12.
肯定涉及到内存对齐的问题。但为什么B和C对象的大小是一样的呢？从内存上来看，这三者对象的数据成员是怎放置的？

[ 本帖最后由 disheng727 于 2009-5-19 21:49 编辑 ]

system888net

编译器相关问题!

disheng727

原帖由 system888net 于 2009-5-19 21:47 发表
编译器相关问题!

一句话 说的我没话说。看样子，这问题不值得深究。

system888net

原帖由 disheng727 于 2009-5-19 21:52 发表

一句话 说的我没话说。看样子，这问题不值得深究。

g++ -S

OwnWaterloo

为什么总是有人对这个感兴趣 ……

#include <assert.h> #include <string.h> class A { public:     int a;     char x; }; class B : public A { public:     char y; }; class C : public B { public:     char z; }; typedef struct A_layout {     int a;     char x;     static void test() {         A a = A();         a.a = 1212;         a.x = 'a';         A_layout layout = A_layout();         memcpy(&layout,&a,sizeof(layout));         assert(a.a==layout.a);         assert(a.x==layout.x);     } private:     static const char assume[]; } A_layout; const char A_layout::assume[sizeof(A_layout)==sizeof(A)?1:-1] = {0}; typedef struct B_layout {     union     {         A_layout inheritedA;         struct         {             int a;             char x;         };     };     char y;     static void test() {         B b = B();         B_layout layout = B_layout();         test_layout(b,layout);         b.a = 1212;         b.x = 'a';         b.y = 'b';         test_layout(b,layout);     } private:     static void test_union(const B_layout& layout) {         assert(&layout.a==&layout.inheritedA.a);         assert(layout.a==layout.inheritedA.a);         assert(&layout.x==&layout.inheritedA.x);         assert(layout.x==layout.inheritedA.x);     }     static void test_layout(const B& b,B_layout& layout) {         test_union(layout);         memcpy(&layout,&b,sizeof(layout));         test_union(layout);         assert(b.a==layout.a);         assert(b.x==layout.x);         assert(b.y==layout.y);     }     static const char assume[]; } B_layout; const char B_layout::assume[sizeof(B_layout)==sizeof(B)?1:-1] = {0}; typedef struct C_layout {     union     {         B_layout inheritedB;         struct         {             union             {                 A_layout inheritedA;                 struct                 {                     int a;                     char x;                 };             };             char y;         };     };     char z;     static void test() {         C c = C();         C_layout layout = C_layout();         test_layout(c,layout);         c.a = 1212;         c.x = 'a';         c.y = 'b';         c.z = 'c';         test_layout(c,layout);     } private:     static void test_layout(const C& c,C_layout& layout) {         test_union(layout);         memcpy(&layout,&c,sizeof(layout));         test_union(layout);         assert(c.a==layout.a);         assert(c.x==layout.x);         assert(c.y==layout.y);         assert(c.z==layout.z);     }     static void test_union(const C_layout& layout) {         assert(&layout.y==&layout.inheritedB.y);         assert(layout.y==layout.inheritedB.y);         assert(&layout.x==&layout.inheritedB.x);         assert(layout.x==layout.inheritedB.x);         assert(&layout.x==&layout.inheritedA.x);         assert(layout.x==layout.inheritedA.x);         assert(&layout.a==&layout.inheritedB.a);         assert(layout.a==layout.inheritedB.a);         assert(&layout.a==&layout.inheritedA.a);         assert(layout.a==layout.inheritedA.a);     }     static const char assume[]; } C_layout; const char C_layout::assume[sizeof(C_layout)==sizeof(C)?1:-1] = {0}; int main() {     A_layout::test();     B_layout::test();     C_layout::test(); #if defined(_MSC_VER) && _MSC_VER<1400 // msvc6 don't support omit return in main.     return 0; #endif }

很无聊 ……

prolj

不是不值得深究，是一般人深究不起

lsupper

我觉的A因为第一个是int 所以4个字节，接下去是char，要跟int对齐，所以总共8字节~~~

B和C中的char都跟int对齐~~~~ 结果就~~~~ 呵呵 不知道理解的对不~~~~~~

windyrobin

强烈要求大牛跳出来指点！！！

daybreakcx

内存对齐问题要深究东西多了去了……

swxlion

2楼、6楼、9楼正解。
5楼的好长，一会再看。（饭点快到了，饭先 ）

具体还要看编译器采用的行为。但按楼主给出的例子反向猜测对应的编译器的行为，大致是这样的，7楼说的前半段，然后B中的内存布局大概如下：
(+：表示一个字节的有效存储；*：表示一个字节的空闲填充)
int a     ++++
char x   +***
char y   +***

这个时候，C的z和B的y同为char，而且y后面有一个以上char长度的空余，所以就被补充到空余中去，变成如下：
int a        ++++
char x      +***
char y,z   ++**

如果C的z是short，而不是char的话，那是
++++
+***
+*++
还是
++++
+***
+***
++**
就好研编译器的具体行为了。

楼主不妨将整个内存区域全部置0x00，然后，对乘员填充标志性非0数值，然后dump对应的内存空间查看。

PS:
这也是在网络通信中，设计2进制的通讯协议结构所需要小心的地方之一。