继承对象模型

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

class Dervied : public Demo
{
    int mk;
};

编程实验： 继承对象模型初探

#include <iostream>

using namespace std;

class Demo
{
protected:
    int mi;
    int mj;
};

class Derived : public Demo
{
private:
    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
{
    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 << "Befor changeing ..." << endl;
    
    d.print();
    
    p->mi = 10;                               // 注意这里！ 
    p->mj = 20;
    p->mk = 30;
    
    cout << "After changeing ..." << endl;
    
    d.print();
    
    return 0;
}

输出：
sizeof(Demo) = 8
sizeof(Derived) = 12
Befor changeing ...
mi = 1, mj = 2, mk = 3
After changeing ...
mi = 10, mj = 20, mk = 30

结论：
子类是由父类成员叠加子类新成员得到的

多态对象模型

• C++ 多态的实现原理

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

多态：面向对象理论中的概念，与程序设计语言无关
虚函数：C++ 中实现多态的唯一方式

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

==>

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

==>

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

编译器确认 add() 是否为虚函数？

• Yes -> 编译器在对象 VPTR 所指向的虚函数表中查找 add() 的地址
• No -> 编译器可以直接确定被调成员函数的地址

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

编程实验：多态对象模型初探

#include <iostream>

using namespace std;

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

class Derived : public Demo
{
private:
    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 << "Befor changeing ..." << endl;
    
    d.print();
    
    p->mi = 10;
    p->mj = 20;
    p->mk = 30;
    
    cout << "After changeing ..." << endl;
    
    d.print();
    
    return 0;
}

输出：
sizeof(Demo) = 12
sizeof(Derived) = 16
Befor changeing ...
mi = 1, mj = 2, mk = 3
After changeing ...
mi = 10, mj = 20, mk = 30

虚函数表指针位于对象最开始的 4 个字节处（32位平台）

编程实验： 多态本质分析

C 写面向对象、继承与多态
Demo.h

#ifndef _DEMO_H_
#define _DEMO_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);
int 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

Demo.c

#include <malloc.h>
#include "Demo.h"

static int Demo_Virtual_Add(Demo* pThis, int value);
static int Derivate_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;
};

// 定义 Demo 类虚函数表，并存储虚函数地址
struct VTable g_Demo_vptr = 
{
    Demo_Virtual_Add
};

// 定义 Derivate 类虚函数表，并存储虚函数地址
struct VTable g_Derivate_vptr = 
{
    Derivate_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_vptr;  // 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. 定义虚函数表中指针所指向的具体函数
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));
}

int 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_Derivate_vptr;
        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; 
}

int Derivate_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); 
}

main.c

#include <stdio.h>
#include "Demo.h"

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

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

输出：
pb->add(3) = 6
pd->add(3) = 336
r = 6
r = 336

深度分析：

面向对象程序最关键的地方在于必须能够表现三大特性：封装，继承，多态！封装指的是类中的敏感数据在外界是不能访问的；封装指的是类中的敏感数据在外界是不能访问的；多态指的是相同的调用语句可以产生不同的调用结果。 因此，如果希望用 C 语言完成面向对象的程序，那么肯定的，必须实现这三个特性；否则，最多只算得上基于对象的程序（程序中能够看到对象的影子，但是不完全具备面向对象的 3 大特性）。
++++++++++++++++
课程中通过 void* 指针保证具体的结构体成员是不能在外界被访问的，以此模拟 C++ 中 private 和 protected。 因此，在头文件中定义了如下的语句：

typedef void Demo;
typedef void Derived;

Demo 和 Derived 的本质依旧是 void， 所以，用 Demo 指针和 Derived 指针指向具体的对象时，无法访问对象中的成员变量，这样就达到了“外界无法访问类中私有成员” 的封装效果！
++++++++++++++++
继承的本质是父类成员与子类成员的叠加，所以在用 C 语言写面向对象程序的时候，可以直接考虑结构体成员的叠加即可。课程中的实现直接将 structClassDemo d 作为 struct ClassDerived 的第一个成员，以此表现两个自定义数据类型间的继承关系。 因为 struct ClassDerived 变量的实际内存分布就是由struct ClassDemo 的成员以及 struct ClassDerived 中新定义的成员组成的，这样就直接实现了继承的本质，所以说 struct ClassDerived 继承自 structClassDemo。
++++++++++++++++
下一步要实现的就是多态了！多态在 C++ 中的实现本质是通过虚函数表完成的，而虚函数表是编译器自主产生和维护的数据结构。因此，接下来要解决的问题就是如何在 C 语言中自定义虚函数表？课程中认为通过结构体变量模拟 C++中的虚函数表是比较理想的一种选择，所以有了下面的代码：

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

有了类型后就可以定义实际的虚函数表了，在 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。当一切就绪后，实际调用虚函数的过程就是通过虚函数表中的对应指针来完成的。

小结

• 继承的本质就是父子间成员变量的叠加
• C++ 中的多态是通过虚函数表实现的
• 虚函数表是由编译器自动生成与维护的
• 虚函数的调用效率低于普通函数

以上内容参考狄泰软件学院系列课程，请大家保护原创！