上一篇博客中我们讲到 class 与 struct 遵循相同的内存对齐规则，class 中的成员函数与成员变量分开存放，使用 sizeof 求解的是成员变量的内存大小，不包含成员函数，成员函数在代码段中。
继承后子类的大小怎么计算呢？
1 继承对象模型
- 子类是由父类成员叠加子类新成员得到的
子类的大小就是父类的成员变量后面加上子类新添加的成员变量，再计算大小，下面我们用编程实验证明
编程实验：继承对象模型
// 36-1.cpp
#include<iostream>
using namespace std;
class Demo
{
protected:
int mi;
int mj;
public:
void print()
{
cout << "mi = " << mi << ", "
<< "mj = " << mj << endl;
}
};
class Derived : public Demo
{
public:
Derived(int i, int j, int k)
{
mi = i;
mj = j;
mk = k;
}
void print()
{
cout << "mi = " << mi << ", "
<< "mj = " << mj << ", "
<< "mk = " << mk << endl;
}
private:
int mk;
};
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);
d.print();
Test *p = reinterpret_cast<Test*>(&d);
p->mi = 10;
p->mj = 20;
p->mk = 30;
d.print();
return 0;
}
- 子类是由父类成员叠加子类新成员得到的，所以 Derived 是在类 Demo 成员的基础上叠加 mk。计算类对象大小时，计算的是成员变量的大小，成员函数保存在代码段，不计入对象大小。所以 Demo 大小为 8 个字节，Derived 为 12 个字节。
- class Derived 与 struct Test 的内存分布相同，可以使用 Test 指针指向 Derived 对象，这样就重新解释了这块内存，可以修改类对象的变量。
编译运行：
$ g++ 36-1.cpp -o 36-1
$ ./36-1
sizeof(Demo) = 8
sizeof(Derived) = 12
mi = 1, mj = 2, mk = 3
mi = 10, mj = 20, mk = 30
2 多态对象模型（虚函数）
2.1 C++ 多态的实现原理
- 声明虚函数时，编译器在类中生成一个虚函数表（存储成员函数地址的数据结构）
- 类中定义了虚函数时，每个对象都有一个指向虚函数表的指针
- 虚函数表是由编译器自动生成维护的
如下图所示：定义虚函数时，对象中除了成员变量外，还将包含一个指针，指向虚函数表，虚函数表中保存的是指向成员函数的指针。
注意：虚函数表的指针存在于对象实例中最前面的位置
2.2 虚函数表
一般继承（无虚函数覆盖）
下面来看看继承时的虚函数表，假设有如下所示的一个继承关系：
成员函数都是虚函数，在这个继承关系中，子类没有重载任何父类的函数。派生类中虚函数表如下所示：
我们可以看到：
- 虚函数按照其声明顺序放于表中
- 父类的虚函数在子类的虚函数前面
一般继承（有虚函数覆盖）
如果子类中有虚函数重载了父类的虚函数，虚函数表是什么样的呢？我们有下面这样的一个继承关系。
为了对比继承后的效果，类中只覆盖了父类的一个函数 f()，派生类的实例的虚函数表如下所示：
可以看到
- 覆盖的 f() 函数被放到了虚表中原来父类虚函数的位置
- 没有被覆盖的函数依旧
对象中保存的指向虚函数表的指针在内存中的最前面，下面用实验证明对象中指向虚函数表的指针的存在和指针的位置。
编程实验：对象中指向虚函数表的指针
我们修改一下上面的代码，将 Demo 中的 print() 函数定义为虚函数，在结构体 struct Test 的最前面加一个指针，我们这里证明类 class Derived 的内存与 struct Test 内存相同。
// 36-1.cpp
#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
{
public:
Derived(int i, int j, int k)
{
mi = i;
mj = j;
mk = k;
}
void print()
{
cout << "mi = " << mi << ", "
<< "mj = " << mj << ", "
<< "mk = " << mk << endl;
}
private:
int mk;
};
struct Test // 结构体中指针在最前面，和Derived内存布局相同
{
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);
d.print();
Test *p = reinterpret_cast<Test*>(&d);
p->mi = 10;
p->mj = 20;
p->mk = 30;
d.print();
return 0;
}
首先计算父类 class Demo 和子类 class Derived 的大小，对象中包含一个指向虚函数表的指针，指类大小为 8 字节，所以 Demo 大小为 16，Derived 大小为 24。
类对象中指向虚函数表的指针在最前面，内存布局和 struct Test 的相同，我们可以通过结构体的指针修改类中的成员变量。
编译运行：
$ g++ 36-1.cpp -o 36-1
$ ./36-1
sizeof(Demo) = 16
sizeof(Derived) = 24
mi = 1, mj = 2, mk = 3
mi = 10, mj = 20, mk = 30
Demo大小为 16字节，Derived大小为 24字节，证明了类对象中指针的存在，通过结构体指针可以修改类对象的数据，证明了类对象中成员的内存分布和结构体 Test 完全相同。
2.3 调用虚函数的过程
调用虚函数的过程如下图所示
类对象根据指针查找虚函数表，虚函数表中有指向虚函数的函数指针，根据函数指针就可以找到函数。
如果不是虚函数，编译器可以直接确定被调成员函数的地址。所以虚函数比普通成员函数效率低。
3 C 语言实现多态
该部分难度较大，用于了解多态的实现过程，了解即可
// Polymorphism1.h
#ifndef _POLYYMORPHISM_H_
#define _POLYYMORPHISM_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
// Polymorphism1.c
#include "Polymorphism.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);
}
// 36-2.c
#include<iostream>
#include"Polymorphism.h"
using namespace std;
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;
}
$ g++ 36-2.c Polymorphism1.c -o 36-2
$ ./36-2
pb->add(3) = 6
pd->add(3) = 336
r = 6
r = 336
4 小结
1、继承的本质就是父子间成员变量的叠加
2、C++ 的多态通过虚函数表实现（编译器自动维护）
3、虚函数效率低于普通成员函数
