#include <iostream> using namespace std; class Base1 { public: Base1() { m_A = 100; } int m_A; }; class Base2 { public: Base2() { m_B = 200; } int m_B; }; class Son :public Base1, public Base2 { public: Son() { m_C = 300; m_D = 400; } int m_C; int m_D; }; void test() { Son s; cout << sizeof(s) << endl; } int main() { test(); return 0; }

这段代码定义了三个类：`Base1`、`Base2` 和 `Son`。其中 `Son` 类继承了 `Base1` 和 `Base2` 类，同时增加了两个成员变量 `m_C` 和 `m_D`。

在 `test` 函数中创建了 `Son` 类的对象 `s`，然后输出 `s` 的大小（即占用的字节数），并将结果输出到控制台。

由于 `Son` 类继承了两个基类，因此在内存中会按照继承的先后顺序依次存储基类的成员变量和自身的成员变量。在这个例子中，`Son` 类的内存布局如下：

| Base1::m_A | Base2::m_B | Son::m_C | Son::m_D |
| ---------- | ---------- | -------- | -------- |
| 4 bytes | 4 bytes | 4 bytes | 4 bytes |

因此 `sizeof(s)` 的结果为 `16`（4+4+4+4）。

相关问题

下面程序的运行结果是： #include <iostream> using namespace std; class BaseClass { public: ~BaseClass(){cout<<"~BaseClass() is called!"<<endl;} }; class DerivedClass:public BaseClass { public: ~DerivedClass(){cout<<"~DerivedClass() is called!"<<endl;} }; int main() { DerivedClass d; return 0; }

下面是程序的输出结果：

~DerivedClass() is called!
~BaseClass() is called!

程序中，类DerivedClass是公共继承自BaseClass的派生类。在main函数中，声明了一个DerivedClass对象d。当程序运行结束时，程序会自动调用d的析构函数，并按照继承顺序先调用DerivedClass的析构函数，再调用BaseClass的析构函数。因此，输出结果为~DerivedClass() is called!和~BaseClass() is called!。

#include <iostream> using namespace std; class BaseClass{ //基类 public: ~BaseClass(){ cout<<"基类BaseClass析构"<<endl; } }; class DerivedClass:public BaseClass{ //派生类 public: ~DerivedClass(){ cout<<"派生类DerivedClass析构"<<endl; } }; void main(){ BaseClass *bp = new DerivedClass(); //基类指针 -> 指向：派生类对象 delete bp; }解释程序输出结果

这段程序的输出结果为：

派生类DerivedClass析构
基类BaseClass析构

程序中定义了两个类，分别为 `BaseClass` 和 `DerivedClass`，`DerivedClass` 是从 `BaseClass` 派生而来的。在 `main` 函数中，先定义了一个指向 `DerivedClass` 对象的 `BaseClass` 指针 `bp`，然后通过 `delete` 释放了该指针指向的内存空间。

由于 `BaseClass` 的析构函数是虚函数，因此在通过 `delete` 释放对象时，会先调用 `DerivedClass` 的析构函数，再调用 `BaseClass` 的析构函数。因此程序的输出结果中，先输出了派生类 `DerivedClass` 的析构函数的信息，再输出了基类 `BaseClass` 的析构函数的信息。