第51课 C++对象模型分析（下）

继承对象模型：

继承对象模型初探：

结构体与类等价的示例：

可以看到mi、mj、mk被改变了，这三个值在外界本来是访问不到的，但是现在通过一个指针却改变了。

这说明本例中结构体的内存分布和继承类对象的内存分布是一样的。

父类的成员排在前面，继承类新添加的成员排在后面。

多态对象模型：

多态本质分析小实验：

运行结果如下：

可以看到定义了虚函数后，类的大小增加了4个字节，这说明确实多了一个虚函数表指针。

 

 测试虚函数表指针的位置：

#include <iostream>
#include <string>

using namespace std;

class Demo
{
protected:
    int mi;
    int mj;
public:
    virtual void print()
    {
        cout << "mi = " << mi << ", "
             << "mj = " << mj << endl;
    }
};

class Derived : public Demo
{
    int mk;
public:
    Derived(int i, int j, int k)
    {
        mi = i;
        mj = j;
        mk = k;
    }
    
    void print()
    {
        cout << "mi = " << mi << ", "
             << "mj = " << mj << ", "
             << "mk = " << mk << endl;
    }
};

struct Test
{
    void* p;
    int mi;
    int mj;
    int mk;
};

int main()
{
    cout << "sizeof(Demo) = " << sizeof(Demo) << endl;         
    cout << "sizeof(Derived) = " << sizeof(Derived) << endl;  
    
    Derived d(1, 2, 3);
    Test* p = reinterpret_cast<Test*>(&d);
    
    cout << "Before changing ..." << endl;
    
    d.print();
    
    p->mi = 10;
    p->mj = 20;
    p->mk = 30;
    
    cout << "After changing ..." << endl;
    
    d.print();
    
    return 0;
}

 运行结果：

打印结果正确，这说明虚函数表的指针确实在开头的位置。要不然，我们重解释内存后，在结构体中修改的mi、mj、mk和类对象中的mi、mj、mk是不对应的。

用C写面向对象，并实现多态：

#ifndef _51_2_H_
#define _51_2_H_

typedef void Demo;
typedef void Derived;

Demo* Demo_Create(int i, int j);
int Demo_GetI(Demo* pThis);
int Demo_GetJ(Demo* pThis);
int Demo_Add(Demo* pThis, int value);
void Demo_Free(Demo* pThis);

Derived* Derived_Create(int i, int j, int k);
int Derived_GetK(Derived* pThis);
int Derived_Add(Derived* pThis, int value);

#endif

#include "51-2.h"
#include "malloc.h"

static int Demo_Virtual_Add(Demo* pThis, int value);
static int Derived_Virtual_Add(Demo* pThis, int value);

struct VTable     // 2. 定义虚函数表数据结构
{
    int (*pAdd)(void*, int);   // 3. 虚函数表里面存储什么？？？
};

struct ClassDemo
{
    struct VTable* vptr;     // 1. 定义虚函数表指针  ==》 虚函数表指针类型？？？
    int mi;
    int mj;
};

struct ClassDerived
{
    struct ClassDemo d;
    int mk;
};

static struct VTable g_Demo_vtbl = 
{
    Demo_Virtual_Add
};

static struct VTable g_Derived_vtbl = 
{
    Derived_Virtual_Add
};

Demo* Demo_Create(int i, int j)
{
    struct ClassDemo* ret = (struct ClassDemo*)malloc(sizeof(struct ClassDemo)); 

    if( ret != NULL )
    {
        ret->vptr = &g_Demo_vtbl;   // 4. 关联对象和虚函数表
        ret->mi = i;
        ret->mj = j;
    }
    
    return ret;
}

int Demo_GetI(Demo* pThis)
{
     struct ClassDemo* obj = (struct ClassDemo*)pThis;    

     return obj->mi;
}

int Demo_GetJ(Demo* pThis)
{
    struct ClassDemo* obj = (struct ClassDemo*)pThis;

    return obj->mj;
}

// 6. 定义虚函数表中指针所指向的具体函数
static int Demo_Virtual_Add(Demo* pThis, int value)
{
    struct ClassDemo* obj = (struct ClassDemo*)pThis;
    
    return obj->mi + obj->mj + value;
}


// 5. 分析具体的虚函数！！！！
int Demo_Add(Demo* pThis, int value)
{

    struct ClassDemo* obj = (struct ClassDemo*)pThis;

    return obj->vptr->pAdd(pThis, value);
}

void Demo_Free(Demo* pThis)
{
    free(pThis);
}

Derived* Derived_Create(int i, int j, int k)
{
    struct ClassDerived* ret = (struct ClassDerived*)malloc(sizeof(struct ClassDerived));
    
    if( ret != NULL )
    {
        ret->d.vptr = &g_Derived_vtbl;
        ret->d.mi = i;
        ret->d.mj = j;
        ret->mk = k;
    }
    
    return ret;
}

int Derived_GetK(Derived* pThis)
{
    struct ClassDerived* obj = (struct ClassDerived*)pThis;
    
    return obj->mk;
}

static int Derived_Virtual_Add(Demo* pThis, int value)
{
    struct ClassDerived* obj = (struct ClassDerived*)pThis; 

    return obj->mk + value;
}

int Derived_Add(Derived* pThis, int value)
{   
    struct ClassDerived* obj = (struct ClassDerived*)pThis;
    
    return obj->d.vptr->pAdd(pThis, value);
}

#include "stdio.h"
#include "51-2.h"

void run(Demo* p, int v)
{
    int r = Demo_Add(p, v);
    
    printf("r = %d
", r);
}

int main()
{
    Demo* pb = Demo_Create(1, 2);
    Derived* pd = Derived_Create(1, 22, 333);
    
    printf("pb->add(3) = %d
", Demo_Add(pb, 3));
    printf("pd->add(3) = %d
", Derived_Add(pd, 3));
    
    run(pb, 3);
    run(pd, 3);
    
    Demo_Free(pb);
    Demo_Free(pd);
    
    return 0;
}

我们定义了虚函数表的结构体类型，并且定义了一个全局的虚函数表类型的变量。

我们在ClassDemo结构体中塞入一个“虚函数表”指针vtbl。

我们模拟编译器的行为，在生成对象时，将虚函数的地址写入虚函数表变量中，并将虚函数表变量的地址挂接到ClassDemo结构体中的虚函数表指针上。

运行结果如下：

小结：

补充说明：

　　面向对象程序最关键的地方在于必须能够表现三大特性：封装，继承，多态！
封装指的是类中的敏感数据在外界是不能访问的；继承指的是可以对已经存在的类
进行代码复用，并使得类之间存在父子关系；多态指的是相同的调用语句可以产生
不同的调用结果。因此，如果希望用 C 语言完成面向对象的程序，那么肯定的，

必须实现这三个特性；否则，最多只算得上基于对象的程序（程序中能够看到对象
的影子，但是不完全具备面向对象的 3 大特性）。

课程中通过 void* 指针保证具体的结构体成员是不能在外界被访问的，以
此模拟 C++ 中 private 和 protected。因此，在头文件中定义了如下的语句：
　　typedef void Demo;
　　typedef void Derived;
Demo 和 Derived 的本质依旧是 void， 所以，用 Demo* 指针和 Derived* 指针

指向具体的对象时，无法访问对象中的成员变量，这样就达到了“外界无法访问类
中私有成员”的封装效果！

　　继承的本质是父类成员与子类成员的叠加，所以在用 C 语言写面向对象程
序的时候，可以直接考虑结构体成员的叠加即可。课程中的实现直接将 struct
ClassDemo d 作为 struct ClassDerived 的第一个成员，以此表现两个自定义数
据类型间的继承关系。因为 struct ClassDerived 变量的实际内存分布就是由

struct ClassDemo 的成员以及 struct ClassDerived 中新定义的成员组成的，这

样就直接实现了继承的本质，所以说 struct ClassDerived 继承自 struct
ClassDemo。

　　下一步要实现的就是多态了！多态在 C++ 中的实现本质是通过虚函数表完
成的，而虚函数表是编译器自主产生和维护的数据结构。因此，接下来要解决的问
题就是如何在 C 语言中自定义虚函数表？课程中认为通过结构体变量模拟 C++
中的虚函数表是比较理想的一种选择，所以有了下面的代码：

struct VTable
{
　　int (*pAdd)(void*, int);
};

　　必须要注意的是，课程中由于复制粘贴的缘故，误将 pAdd 指针的类型定义成了
int (*)(Derived*, int) ， 这从 C 语言的角度算不上错误，因为 Derived* 的本质就
是 void* ， 所以编译运行都没有问题。但是，从面向对象的角度，这里可以说是
一种语义上的错误！因为 pAdd 必须可以指向父类中定义的 Add 函数版本，也可
以指向子类中定义的 Add 函数版本，所以说用 Derived* 作为第一个参数表示实
际对象并不合适，应该直接使用 void* 。

　　有了类型后就可以定义实际的虚函数表了，在 C 语言中用具有文件作用域
的全局变量表示实际的虚函数表是最合适的，因此有了下面的代码：

// 父类对象使用的虚函数表

static struct VTable g_Demo_vtbl =
{
　　Demo_Virtual_Add
};
// 子类对象使用的虚函数表
static struct VTable g_Derived_vtbl =
{
　　Derived_Virtual_Add
};

　　每个对象中都拥有一个指向虚函数表的指针，而所有父类对象都指向
g_Demo_vtbl，所以所有子类对象都指向 g_Derived_vtbl。当一切就绪后，实际
调用虚函数的过程就是通过虚函数表中的对应指针来完成的。