29、不一样的C++系列--对象模型分析

对象模型分析

C++对象模型

首先来说一说class的本质：

• class是一种特殊的struct
  
  • 在内存中class依旧可以看作变量的集合
  • class与struct遵循相同的内存对齐规则
  • class中的成员函数与成员变量是分开存放的
    
    • 每个对象有独立的成员变量
    • 所有对象共享类中的成员函数

然后再来看一个问题：

class A
{
    int i;
    int j;
    char c;
    double d;
};

struct B
{
    int i;
    int j;
    char c;
    double d;
};

有上述1个类A、一个结构体B，请问执行下列语句输出多少？

sizeof(A) = ?
sizeof(B) = ?

最终输出结果为：

sizeof(A) = 24
sizeof(B) = 24

再举一个例子：

#include <iostream>
#include <string>

using namespace std;

class A
{
    int i;
    int j;
    char c;
    double d;
public:
    void print()
    {
        cout << "i = " << i << ", "
             << "j = " << j << ", "
             << "c = " << c << ", "
             << "d = " << d << endl;
    }
};

struct B
{
    int i;
    int j;
    char c;
    double d;
};

int main()
{
    A a;

    cout << "sizeof(A) = " << sizeof(A) << endl;    // 20 bytes
    cout << "sizeof(a) = " << sizeof(a) << endl;
    cout << "sizeof(B) = " << sizeof(B) << endl;    // 20 bytes

    a.print();

    //用B指针类型指向类A的对象
    B* p = reinterpret_cast<B*>(&a);

    //通过指针修改A对象的各个值
    p->i = 1;
    p->j = 2;
    p->c = 'c';
    p->d = 3;

    a.print();

    p->i = 100;
    p->j = 200;
    p->c = 'C';
    p->d = 3.14;

    a.print();

    return 0;
}

最终输出结果为：

sizeof(A) = 24
sizeof(a) = 24
sizeof(B) = 24
i = 0, j = 1, c =  , d = 2.26503e-314
i = 1, j = 2, c = c, d = 3
i = 100, j = 200, c = C, d = 3.14

从输出结果结合代码可以看出：
1、 类A 结构体B 内存大小是一样的
2、在定义类A的对象后，未初始化时，输出成员变量都是未初始化的值
3、使用结构体B的指针指向类A对象时，可以直接修改成员变量的值

分析得出：

• 运行时的类对象退化为结构体的形式
  
  • 所有成员变量在内存中依次排布
  • 成员变量间可能存在内存空隙
  • 可以通过内存地址直接访问成员变量
  • 访问权限关键字在运行时失效
• 类中的成员函数位于代码段中
• 调用成员函数时对象地址作为参数隐式传递
• 成员函数通过对象地址访问成员变量
• C++语法规则隐藏了对象地址的传递过程

继承对象模型

• 在C++编译器的内部 类可以理解为结构体
• 子类是由父类成员叠加子类新成员得到的

class Derived : public Demo
{
    int mk;
};

Demo =>     int mi;     <=  Derived
Demo =>     int mj;     <=  Derived
            int mk;     <=  Derived

首先来看一个例子：

#include <iostream>
#include <string>

using namespace std;

//类Demo
class Demo
{
//子类可以直接访问
protected:
    int mi;
    int mj;
public:
    //虚函数print
    virtual void print()
    {
        cout << "mi = " << mi << ", "
             << "mj = " << mj << endl;
    }
};

//类Derived 继承Demo
class Derived : public Demo
{
    //子类中的成员变量mk
    int mk;
public:
    //带参构造函数
    Derived(int i, int j, int k)
    {
        mi = i;
        mj = j;
        mk = k;
    }
    //子类成员函数print
    void print()
    {
        cout << "mi = " << mi << ", "
             << "mj = " << mj << ", "
             << "mk = " << mk << endl;
    }
};

//结构体Test
struct Test
{
    //包含1个指针 3个int类型变量
    //这个指针是指向虚函数表的指针
    //虚函数表指针位于对象最开始的位置
    void* p;
    int mi;
    int mj;
    int mk;
};

int main()
{
    //输出Demo类和Derived类
    cout << "sizeof(Demo) = " << sizeof(Demo) << endl;         
    cout << "sizeof(Derived) = " << sizeof(Derived) << endl;  

    //定义并初始化d
    Derived d(1, 2, 3);
    //使用结构体Test指针指向Derived类对象
    Test* p = reinterpret_cast<Test*>(&d);

    cout << "Before changing ..." << endl;

    //输出成员变量以及父类的成员变量
    d.print();

    //直接通过p指针来赋值d的成员变量
    p->mi = 10;
    p->mj = 20;
    p->mk = 30;

    cout << "After changing ..." << endl;

    //输出各成员变量
    d.print();

    return 0;
}

输出结果如下：

sizeof(Demo) = 16
sizeof(Derived) = 24
Before changing ...
mi = 1, mj = 2, mk = 3
After changing ...
mi = 10, mj = 20, mk = 30

在这里说明一下，由于是在64位系统下运行，所以指针占8个字节。Demo占16个字节，是包含了2个4字节的int变量，加上1个8字节指向虚函数表的指针，共16个字节。Derived占24个字节是因为内存对齐，直接给int类型的mk变量分配8个字节，所以共24个字节。使用Test结构体指向Derived类对象时，要注意指向虚函数表的指针是位于对象内存最开始的位置，void * p就是这个指针，其余的按顺序排列。

• C++多态的实现原理
  
  • 当类中声明虚函数时，编译器会在类中生成一个虚函数表
  • 虚函数表是一个存储成员函数地址的数据结构
  • 虚函数表是由编译器自动生成与维护的
  • virtual成员函数会被编译器放入虚函数表中
  • 存在虚函数时，每个对象中都有一个指向虚函数表的指针

当有Demo类如下：

class Demo
{
    int mi, mj;
public:
    virtual int add(int value)
    {
        return mi + mj + value;
    }   
};

此时这个对象就会有一个指针，指向编译器维护的虚函数表。虚函数表中保存这成员函数的地址：

VTABLE  =>  void Demo :: add(int value)

当有Derived类继承Demo类时，如下：

class Derived : public Demo
{
    int mk;
public:
    virtual int add(int value)
    {
        return mk + value;
    }
};

此时这个对象也会有一个指针，指向编译器维护的虚函数表。虚函数表中保存这成员函数的地址：

VTABLE  =>  void Derived :: add (int value)

当执行这个函数时：

void run(Demo * p, int v)
{
    p -> add(v);
}

执行时，编译器会确认 add( ) 是否为虚函数？
1、Yes -> 编译器在对象 VPTR 所指向的虚函数表中查找 add ( ) 的地址
2、No -> 编译器直接可以确定被调成员函数的地址
所以，调用顺序如下：

p -> VPTR -> VTABLE  void (*pAdd)(int value) -> 0xFF010203

调用效率对比： 虚函数 < 普通成员函数