第五十一课 C++对象模型分析(下)
1.继承对象模型
在C++编译器的内部类可以理解为结构体
子类是由父类成员叠加子类新成员得到的
51-1 继承对象模型初探
#include <iostream> #include <string> using namespace std; class Demo { protected: int mi; int mj; }; 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 { int mi; int mj; int mk; }; int main() { cout << "sizeof(Demo) = " << sizeof(Demo) << endl; //8 cout << "sizeof(Derived) = " << sizeof(Derived) << endl; //12 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;
}
运行结果
sizeof(Demo) = 8
sizeof(Derived) = 12
Before changing…
mi = 1,mj = 2,mk = 3
After changing…
mi = 10,mj = 20,mk = 30
2.多态对象模型
C++多态的实现原理
当类中声明虚函数时,编译器会在类中生成一个虚函数表
虚函数表是一个存储成员函数地址的数据结构
虚函数表是由编译器自动生成与维护的
virtual成员函数会被编译器放入虚函数表中
存在虚函数时,每个对象中都有一个指向虚函数表的指针
51-2.c main.c 多态本质分析—C++是通过牺牲效率来实现虚函数的
C++中编写程序:51-2.cpp
#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; //8
cout << "sizeof(Derived) = " << sizeof(Derived) << endl; //12
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;
}
运行结果
sizeof(Demo) = 16
sizeof(Derived) = 24
Before changing...
mi = 1,mj = 2,mk = 3
After changing...
mi = 10,mj = 20,mk = 30
用C语言实现面向对象的代码,来实现多态,也是C++内部的原理
51-2.h
#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
51-2.c #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);//7.通过对象找到具体的虚函数表的指针vptr,通过指针找具体add函数,具体add函数的地址保存在pAdd成员里面,找到Demo_Virtual_Add } void Demo_Free(Demo* pThis) { free(pThis); } //8.开始完成子类的部分 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; //10.将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; } //9.在实际的虚函数中进行相加操作 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; } 运行结果 pb->add(3) = 6 pd->add(3) = 336 r = 6 //父类的调用版本 r = 336 //子类的调用版本
小结
继承的本质就是父子间成员变量的叠加
C++中的多态是通过虚函数表实现的
虚函数表是由编译器自动生成与维护的
虚函数的调用效率低于普通成员函数