1. 多态的实现原理
1.1虚函数表和vptr指针
- 当类中声明虚函数时，编译器会在类中生成一个虚函数表；
- 虚函数表是一个存储类成员函数指针的数据结构；
- 虚函数表是由编译器自动生成与维护的；
- virtual成员函数会被编译器放入虚函数表中；
- 存在虚函数时，每个对象中都有一个指向虚函数表的指针(vptr指针)。
class Parent
{
public:
virtual void func(int a,int b){
cout<<"Parent:func(int a,int b)..."<<endl;
}
virtual void func(int a){
cout<<"Parent:func(int a)..."<<endl;
}
void func(int a,int b,int c){
cout<<"Parent:func(int a,int b,int c)..."<<endl;
}
private:
int a;
};
class Child:public Parent
{
public:
virtual void func(int a,int b){
cout<<"Child:func(int a,int b)..."<<endl;
}
virtual void func(int a){
cout<<"Child:func(int a)..."<<endl;
}
/*
void func(int a,int b,int c){
cout<<"Child:func(int a,int b,int c)..."<<endl;
}
*/
private:
int b;
};
int main(void)
{
Parent *p = new Child;//父类指针指向了子类对象
p->func(10,20);//此时发生了多态，这里调了Child::print();
//编译器会通过p指针，找到p指针所指向内存块的vptr指针，根据vptr指针再去匹配的函数
p->func(10,20,30);//这里调用父类的！//静态联编
p->func(20,30);//动态联编
return 0;
}
1.png
2.png
1.2说明
- 通过虚函数表指针VPTR调用重写函数是在程序运行时进行的，因此需要通过寻址操作才能确定真正应该调用的函数。而普通成员函数是在编译时就确定了调用的函数。在效率上，虚函数的效率要低很多。
- 出于效率考虑，没有必要将所有成员函数都声明为虚函数
- C++编译器，执行run函数，不需要区分是子类对象还是父类对象,而是直接通过p的VPTR指针所指向的对象函数执行即可。
2.证明vptr指针的存在
class Parent
{
public:
void func(int a,int b){
cout<<"Parent func()....."<<endl;
}
private:
int a;
}
class Parent2
{
public:
virtual void func(int a,int b){
cout<<"Parent2 func..."<<endl;
}
private:
int a;
};
int main(void)
{
Parent p1;
Parent2 p2;
cout<<"sizeof(p1):"<<sizeof(p1)<<endl;//4
cout<<"sizeof(p2):"<<sizeof(p2)<<endl;//4
//给Parent2的func方法单独加上virtual 后，输出：8
//vptr指针我们访问不了，vptr指针指向的是Parent2类的虚函数表
//此表中目前有一个虚函数func(int a,int b)的入口地址!
return 0;
}
2.1vptr指针的分步初始化(面试题)
//本例只做示范，不要在构造函数中调用成员函数
class Parent
{
public:
Parent(int a){
cout<<"Parent(int a)...."<<endl;
this->a = a;
print();//这个print打印的是Parent还是Child的？
//是父类的print()
}
//虚函数
virtual void print(){
cout<<"Parent::print()..."<<a<<endl;
}
private:
int a;
};
class Child:public Parent
{
public:
Child(int a,int b):Parent(a){
//在此处之前，是构造父类的内存空间，此时child还没有构造完毕，vptr指针是指向的是父类的虚函数表
cout<<"Child..."<<endl;
this->b = b;
print();//vptr转移指向子类的虚函数表，所以是调用子类的print
}
//重写了父类的虚函数
virtual void print(){
cout<<"Child::print()..."<<a<<","<<b<<endl;
}
private:
int b;
};
int main(void)
{
Parent *p = new Child(10,20);//在此调用child的构造函数
p->print();//此时发生多态
delete p;
return 0;
}
2.2父类指针和子类指针的步长
class Parent
{
public:
Parent(int a){
this->a =a;
}
virtual void print(){
cout<<"Parent::print().."<<a<<endl;
}
private:
int a;
};
class Child:public Parent
{
public:
Child(int a):Parent(a){
}
virtual void print(){
cout<<"Child::print()..."<<a<<end;
}
private:
//加个int b 步长就不一样了
};
int main(void)
{
Child array[] = {Child(0),Child(1),Child(2)};//array[0],array[1],array[2]
Child *cp = &array[0];
Parent *pp = &array[0];
cp->print();//Child
pp->print();//Child 发生多态！
cout<<"......................................."<<endl;
cp++;
pp++;
cp->print();//Child
pp->print();//Child
//cp和pp步长只是恰巧相等！！sizeof(Class)刚好等于sizeof(Parent)而已！
//加个私有变量就不同了！
int i;
for(i = 0,pp = &array[0];i<3;i++,pp++){
pp->print();
}
return 0;
}
3.有关多态的理解
多态的实现效果
多态：同样的调用语句有多种不同的表现形态；
多态实现的三个条件
有继承、有virtual重写、有父类指针（引用）指向子类对象。
多态的C++实现
virtual关键字，告诉编译器这个函数要支持多态；不是根据指针类型判断如何调用；而是要根据指针所指向的实际对象类型来判断如何调用
多态的理论基础
动态联编PK静态联编。根据实际的对象类型来判断重写函数的调用。
多态的重要意义
设计模式的基础是框架的基石。
多态的原理探究
虚函数表和vptr指针。
