前奏—虚函数表
虚函数表是通过一块连续内存来存储虚函数的地址.
这张表解决了继承、 虚函数(重写)的问题
在有虚函数的对象实例中都存在一张虚
函数表,虚函数表就像一张地图指
明了实际应该调用的虚函数函数
1.什么是多态 ?
所谓多态性就是不同对象收到相同的消息时,产生不同的动作。直观来说,多态性是指用一个名字定义不同的函数,这些函数执行不同但又类似的操作,从而可以使用相同的方式来调用这些具有不同功能的同名函数。简单的说:就是用基类的引用指向子类的对象。
多态的分类:
编译时的多态性。编译时的多态性是通过重载来实现的。
运行时的多态性。动态多态就是通过继承重写基类的虚函数实现的多态,因为是在运行时决议确定,所以称为动态多态。
实现多态的方法:虚函数,抽象类,覆盖,模板。
构成多态的条件:
1.要有继承 。
2.要有虚函数的重写。
3.父类的指针/引用调用虚函数。
构成多态时,和类型无关,和调用的对象有关。
使用多态的好处:
多态性机制不仅增加了面向对象软件系统的灵活性,进一步减少了冗余信息,而且显著提高了软件的可重用性和可扩充星星。多态的应用可以使编程显得更简便.更便利。
多态的应用:
#include<iostream>
using namespace std;
class A
{
public:
virtual void fun1()
{
cout << "A::fun1() "<< endl;
}
};
class B :public A
{
public:
virtual void fun1()
{
cout << "B::fun1()" << endl;
}
};
int main()
{
A a;
B b;
A* p = &a;
p->fun1();
p = &b;
p->fun1();
system("pause");
return 0;
}
上述实例中父类A的指针指向父类对象时,则调用父类的函数fun1(),当指针指向子类时,则调用子类fun1().
单继承对象模型
class Base
{
public:
virtual void func1()
{
cout << "Base::func1" << endl;
}
virtual void func2()
{
cout << "Base::func2" << endl;
}
private:
int a;
};
class Derive :public Base
{
public:
virtual void func1()
{
cout << "Derive::func1" << endl;
}
virtual void func3()
{
cout << "Derive::func3" << endl;
}
virtual void func4()
{
cout << "Derive::func4" << endl;
}
private:
int b;
};
typedef void(*FUNC) ();
void PrintVTable(int* VTable)
{
cout << " 虚表地址>" << VTable << endl;
for (int i = 0; VTable[i] != 0; ++i)//虚表内虚函数地址以0作为结束标志
{
printf(" 第%d个虚函数地址 :0X%x,->", i, VTable[i]);
FUNC f = (FUNC)VTable[i];
f();
}
cout << endl;
}
int main()
{
Base b1;
Derive d1;
int* VTable1 = (int*)(*(int*)&b1);//拿到b1的首地址,把它强转成int*,让他读取到前4个字节的内容(也就是指向虚表的地址),再然后对那个地址解引用,我们已经拿到虚表的首地址了,但是此时这个变量的类型解引用后是int,不能够传入函数,所以我们再对他进行一个int*的强制类型转换,这样我们就传入参数了,开始函数执行了,我们一切都是在可控的情况下使用强转,使用强转你必须要特别清楚的知道内存的分布结构。
int* VTable2 = (int*)(*(int*)&d1);
PrintVTable(VTable1);
PrintVTable(VTable2);
system("pause");
return 0;
}
首先子类的func1()重写了父类的func1(),虚表里存的是子类的func1(),接下来父类的func2(),子类的func3(),func4()都是虚函数,所以虚表里会有4个元素,分别为子类的fun1(),父类fun2(),子类fun3(),子类fun4()。
多继承对象模型
class Base1
{
public:
virtual void func1()
{
cout << "Base1::func1" << endl;
}
virtual void func2()
{
cout << "Base1::func2" << endl;
}
private:
int b1;
};
class Base2
{
public:
virtual void func1()
{
cout << "Base2::func1" << endl;
}
virtual void func2()
{
cout << "Base2::func2" << endl;
}
private:
int b2;
};
class Derive : public Base1, public Base2
{
public:
virtual void func1()
{
cout << "Derive::func1" << endl;
}
virtual void func3()
{
cout << "Derive::func3" << endl;
}
private:
int d1;
};
typedef void(*FUNC) ();
void PrintVTable(int* VTable)
{
cout << " 虚表地址>" << VTable << endl;
for (int i = 0; VTable[i] != 0; ++i)
{
printf(" 第%d个虚函数地址 :0X%x,->", i, VTable[i]);
FUNC f = (FUNC)VTable[i];
f();
}
cout << endl;
}
int main()
{
Derive d1;
int* VTable = (int*)(*(int*)&d1);
PrintVTable(VTable);
VTable = (int *)(*((int*)&d1 + sizeof (Base1) / 4));
PrintVTable(VTable);
system("pause");
return 0;
}
监视显示有Base1和Base2两个虚表,但是在监视中我们并没有发现子类的func3函数!!!!
调试结果显示func3()没有自己开辟虚函数表,也没有存在Base2的虚函数表中,而是存在了Base1的虚函数表中,由此我们得出当涉及多继承时,子类的虚函数会存在先继承的那个类的虚函数表里。
对象模型–菱形虚拟继承
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
class Base1
{
public:
virtual void fun1()
{
cout << "Base1::fun1" << endl;
}
public:
int _a;
};
class Base2 :virtual public Base1
{
public:
virtual void fun1()
{
cout << "Base2::fun1" << endl;
}
virtual void fun2()
{
cout << "Base2::fun2 " << endl;
}
public:
int _b;
};
class Base3 :virtual public Base1
{
public:
virtual void fun1()
{
cout << "Base3::fun1" << endl;
}
virtual void fun2()
{
cout << "Base3::fun2" << endl;
}
public:
int _c;
};
class Base4 : public Base2, public Base3
{
public:
virtual void fun1()
{
cout << "Base4::fun1" << endl;
}
virtual void fun2()
{
cout << "Base4::fun2" << endl;
}
public:
int _d;
};
typedef void(*FUNC) ();
void PrintVTable(int* VTable)
{
cout << " 虚表地址>" << VTable << endl;
for (int i = 0; VTable[i] != 0; ++i)
{
printf(" 第%d个虚函数地址 :0X%x,->", i, VTable[i]);
FUNC f = (FUNC)VTable[i];
f();
}
cout << endl;
}
int main()
{
Base4 a;
a.Base2::_a = 1;
a.Base3::_a = 2;
a._b = 3;
a._c = 4;
a._d = 5;
PrintVTable(*((int**)&a));
PrintVTable(*((int**)((char*)&a + sizeof(Base2)-sizeof(Base1))));
PrintVTable(*((int**)((char*)&a + sizeof(Base2)+sizeof(Base3)-2 * sizeof(Base1)+4)));
system("pause");
return 0;
}
Base2 Base3 中重写了Base1中的fun1() Base4继承了 Base2 and Base3 重写了fun1() fun2()
调试结果