第51课 - C++ 对象模型分析(下)
继承对象模型
- 在 C++ 编译器的内部类可以理解为结构体
- 子类是由父类成员函数叠加子类新成员得到的
class Derived : public Demo
{
int mk;
};
编程实验1 :继承对象模型初探
#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; // 12字节
cout << "sizeof(Derived) = " << sizeof(Derived) << endl; // 16字节
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;
}
编译环境:Linux 64位
输出:
sizeof(Demo) = 16
sizeof(Derived) = 20
sizeof(struct Test) = 20
Before changing ...
mi = 1, mj = 2, mk = 3
After changing ...
mi = 10, mj = 20, mk = 30
类里面有虚函数,编译的时候会在类里面生成一个指针
强行塞入一个指向虚函数表的指针!!放在最开始的四个字节的地方,放在其它地方内存排布是错位的
多态对象模型
C ++ 多态的实现原理
- 当类中声明虚函数时,编译器会在类中生成一个虚函数表
- 虚函数表是一个存储成员函数地址的数据结构
- 虚函数表是由编译器自动生成与维护的
- virtual 成员函数会被编译器放入虚函数表中
- 存在虚函数时,每个对象中都有一个指向虚函数表的指针
class Demo
{
int mi,mj;
public:
virtual int add(int value)
{
return mi + mj + value;
}
};
class Derived : public Demo
{
int mk;
public:
virtual int add(int value)
{
return mk + vakue;
}
};
void run(Demo *p, int v)
{
p->add(v);
}
编译过程
编译器确认 add() 是否为虚函数?
- Yes:编译器在对象 VPTR 所指向的虚函数表中查找 add() 地址
- No : 编译器直接可以确定被调用成员函数的地址
由图分析
调用效率:虚函数 < 普通成员函数
虚函数是通过牺牲效率来实现多态的,所以在写代码的时候需要考虑成员函数是否需要成为虚函数
虚函数的调用过程
通过P指针找到具体的对象(1),然后在找到对象里面的虚函数表指针(2),在通过虚函数指针找到虚函数表,在虚函数表内通过查找找到对应的地址(3),3次寻地址,效率不高
编程实验2: C 方式实现多态
思路
- 定义虚函数表指针
那么虚函数表指针类型是什么?虚函数表也是一种数据结构 - 定义虚函数表数据结构体,然后创建对应的虚函数表
- 虚函数表里面存储什么?
指向程序函数的指针 - 关联对象和虚函数表
- 分析具体的虚函数
- 定义虚函数表中指针指向的具体函数
// .h 文件
#ifndef __51_1_H__
#define __51_1_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
// .c 文件
#include <stdio.h>
#include <stdlib.h>
#include "51-1.h"
static int Demo_Virtual_Add(Demo *pThis, int value);
static int Derived_Virtual_Add(Derived *pThis, int value);
struct VTable
{
int (* pAdd)(void *pThis, int value);
};
struct class_Demo
{
struct VTable *vptr;
int mi;
int mj;
};
struct ClassDerived
{
struct class_Demo 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 class_Demo *ret = (struct class_Demo *)malloc(sizeof(struct class_Demo));
if(ret != NULL)
{
//ret->vptr.pAdd = Demo_Virtual_Add;
ret->vptr = &g_Demo_vtbl;
ret->mi = i;
ret->mj = j;
}
return ret;
}
int Demo_GetI(Demo* pThis)
{
struct class_Demo *obj = (struct class_Demo *)(pThis);
return obj->mi;
}
int Demo_GetJ(Demo* pThis)
{
struct class_Demo *obj = (struct class_Demo *)(pThis);
return obj->mj;
}
static int Demo_Virtual_Add(Demo *pThis, int value)
{
struct class_Demo* obj = (struct class_Demo*)pThis;
return obj->mi + obj->mj + value;
}
int Demo_Add(Demo* pThis, int value)
{
struct class_Demo *obj = (struct class_Demo *)(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);
}
// main.c 文件
#include "stdio.h"
#include "51-2.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;
}
小结
- 继承的本质就是父子间成员变量的叠加
- C++ 中的多态是通过虚函数表实现的
- 虚函数表是由编译器自动生成与维护的
- 虚函数的调用效率低于普通成员函数
补充说明
面向对象程序最关键的地方在于必须能表现三大特征:封装,继承,多态
- 封装
封装是类中的敏感数据在外界是不能访问的 - 继承
继承指的是可以对已经存在的类进行代码复用,并使得类之间存在父子关系 - 多态
多态指的是相同的语句可以产生不同的调用结果
如果 C 语言完成面向对象的程序,必须要实现上面 3 个特征,否则只能算是基于对象的程序(程序中能够看到对象的影子,但是不完全具备面向对象的3大特性)
实现方式
- 封装
通过 void * 指针保证具体的结构体成员是不能被外界访问的,以此模拟C++ 中 private 和 protected ,在头文件定义如下语句
typedef void Parent;
typedef void Derived;
Parent 和 Derived 的本质依旧还是 void ,所以用 Parent *指针和Derived *指针指向具体对象时,无法访问对象中的成员变量,达到 外界无法访问类中的私有成员的封装效果
- 继承
继承的本质还是父类成员和子类成员的叠加,在 C 中可以直接考虑结构体成员的叠加即可
struct class_Demo
{
struct VTable *vptr;
int mi;
int mj;
};
struct ClassDerived
{
struct class_Demo d;
int mk;
};
可以说 struct ClassDerived 继承 struct class_Demo
- 多态
多态在 C++ 中的实现本质还是通过虚函数表完成的,而虚函数表时通过编译器自主产生和维护的数据结构,如何使用C自定义虚函数表?通过结构体变量模拟C++中的虚函数表时比较好的一种选择
struct VTable
{
int (* pAdd)(void *pThis, int value);
};
有了类型之后就可以定义实际的虚函数表,在C语言中用具有文件作用域的全局变量表示实际的虚函数是最合适的,每个对象中都拥有一个指向虚函数表的指针,所有父类对象指针指向 g_Demo_vtbl, 所有子类对象指向 g_Derived_vtbl. 实际调用虚函数的过程就是通过虚函数表中对应指针来完成的。