C++ 对象模型

标签：调用函数 Base1 对象模型 Derived C++ int public

对象的内存布局
- 非虚函数类对象
  - 对于不包含虚函数的类，对象的内存布局相对简单，其成员变量按照声明的顺序依次存储。例如：
```
class SimpleClass {
private:
    int num;
    double d;
public:
    SimpleClass(int n, double dd) : num(n), d(dd) {}
};
```
  - 在SimpleClass对象的内存中，首先存储int类型的num，然后存储double类型的d。假设int占4字节，double占8字节，那么一个SimpleClass对象的大小至少为12字节（考虑内存对齐等因素可能会有所增加）。
- 包含虚函数的类对象
  - 如果一个类包含虚函数，对象的内存布局会包含一个虚函数表指针（vptr）。这个指针通常位于对象内存的开头（不同编译器可能有不同的实现方式）。例如：
```
class VirtualClass {
private:
    int num;
    double d;
public:
    VirtualClass(int n, double dd) : num(n), d(dd) {}
    virtual void someVirtualFunction() {}
};
```
  - 在VirtualClass对象的内存中，首先是虚函数表指针（通常在32位系统中占4字节，64位系统中占8字节），然后是成员变量num和d。虚函数表是一个函数指针数组，存储了类的虚函数地址。当调用虚函数时，通过这个虚函数表指针找到虚函数表，再根据表中的指针调用相应的函数。
继承关系中的对象模型
- 单继承
  - 在单继承关系中，派生类对象的内存布局是基类部分在前，派生类部分在后。例如：
```
class Base {
private:
    int baseNum;
public:
    Base(int n) : baseNum(n) {}
};

class Derived : public Base {
private:
    double derivedNum;
public:
    Derived(int n, double d) : Base(n), derivedNum(d) {}
};
```
  - 在Derived对象的内存中，首先是Base类的baseNum，然后是Derived类的derivedNum。如果Base类包含虚函数，那么Derived对象也会包含虚函数表指针（并且这个虚函数表指针会被正确初始化以反映Derived类的虚函数情况）。
- 多继承
  - 多继承的对象模型较为复杂。例如，有类Base1、Base2和派生类Derived：
```
class Base1 {
private:
    int num1;
public:
    Base1(int n) : num1(n) {}
};

class Base2 {
private:
    double num2;
public:
    Base2(double n) : num2(n) {}
};

class Derived : public Base1, public Base2 {
private:
    char ch;
public:
    Derived(int n, double d, char c) : Base1(n), Base2(d), ch(c) {}
};
```
  - 在Derived对象的内存中，首先是Base1的部分（num1），然后是Base2的部分（num2），最后是Derived类特有的部分（ch）。如果基类包含虚函数，处理虚函数表指针会更加复杂，不同编译器可能采用不同的策略来确保正确的虚函数调用。
对象的构造与析构
- 构造函数顺序
  - 在对象创建时，首先调用基类的构造函数，然后按照继承顺序依次调用派生类的构造函数。在构造函数内部，成员变量的初始化按照声明的顺序进行。例如，对于前面提到的Derived类：
```
Derived(int n, double d, char c) : Base1(n), Base2(d), ch(c) {}
```
  - 首先调用Base1的构造函数初始化Base1部分，然后调用Base2的构造函数初始化Base2部分，最后初始化Derived类特有的ch成员。
- 析构函数顺序
  - 析构函数的调用顺序与构造函数相反。当Derived类对象被销毁时，首先调用Derived类的析构函数，然后按照与继承顺序相反的顺序依次调用基类的析构函数。并且，如果基类的析构函数是虚函数，那么通过基类指针删除派生类对象时，可以确保正确调用派生类的析构函数。例如：
```
Base1* ptr = new Derived(1, 2.0, 'a');
delete ptr;
```
  - 如果Base1的析构函数不是虚函数，只会调用Base1的析构函数，可能导致Derived类资源无法正确释放；如果Base1的析构函数是虚函数，则会先调用Derived类的析构函数，再调用Base1的析构函数，正确释放资源。
函数调用机制（特别是虚函数调用）
- 非虚函数调用
  - 对于非虚函数，函数调用在编译时就确定了。编译器根据函数名和作用域直接生成调用代码。例如：
```
class NonVirtualClass {
public:
    void nonVirtualFunction() {}
};

int main() {
    NonVirtualClass obj;
    obj.nonVirtualFunction();
    return 0;
}
```
  - 编译器直接知道obj.nonVirtualFunction()应该调用NonVirtualClass类中的nonVirtualFunction函数，不需要在运行时进行额外的查找。
- 虚函数调用
  - 虚函数的调用是在运行时确定的。当通过基类指针或引用调用虚函数时，会根据对象实际的类型来决定调用哪个函数。例如：
```
class Base {
public:
    virtual void virtualFunction() {
        std::cout << "Base::virtualFunction" << std::endl;
    }
};

class Derived : public Base {
public:
    void virtualFunction() override {
        std::cout << "Derived::virtualFunction" << std::endl;
    }
};

int main() {
    Base* ptr = new Derived();
    ptr->virtualFunction();
    return 0;
}
```
  - 这里ptr是Base类的指针，但实际指向Derived类对象。当调用ptr->virtualFunction()时，由于virtualFunction是虚函数，会在运行时根据ptr实际指向的对象类型（即Derived类）来调用Derived类中的virtualFunction函数。这种机制实现了多态性，使得代码更加灵活和可扩展。

标签：调用,函数,Base1,对象,模型,Derived,C++,int,public
From： https://www.cnblogs.com/androidsuperman/p/18449442

相关文章

赞助商

阅读排行