多态的概念与定义
多态通俗来说就是多种形态,具体点就是当不同对象去完成某个任务时,会产生不同状态.在继承中要构成多态有两个条件
- 必须通过父类的指针或者引用调用虚函数
- 被调用的函数必须是虚函数,且派生类必须对基类的虚函数进行重写.
虚函数
被virtual修饰的非静态类成员函数就叫做虚函数,尽管是同一个关键字,虚函数和前面的虚继承没什么关系.
虚函数是可以进行重写的,在派生类中有一个跟基类完全相同的虚函数,则称子类的虚函数重写了基类的虚函数
class A
{
public:
virtual void fun()
{
cout << "fun_A" << endl;
}
};
class B : public A
{
public:
virtual void fun()
{
cout << "fun_B" << endl;
}
};
void Func(A& a)//虚函数要求必须通过父类对象指针或者引用进行调用
{
a.fun();
}
分别传入A类和b类对象,得到

可以看到,明明是同一个函数,却因为传入的对象不同发生了不同的调用.
如果去掉引用
void Func(A a)
{
a.fun();
}
无论传什么调用的就都是父类的函数了,此时不再构成多态
虚函数的重写要求:参数,返回值,函数名都要求相同,但是有两个例外
1.协变
协变指派生类重写基类虚函数时,与基类虚函数的返回值不同,但是直接改是不行的.协变要求返回类型为父子类的指针或者引用(只要是父子指针就可以)
class A
{
public:
virtual A* fun()
{
cout << "fun_A" << endl;
return this;
}
};
class B : public A
{
public:
virtual B* fun()
{
cout << "fun_B" << endl;
return this;
}
};
这玩意几乎很少用.
2.允许子类不使用virtual做修饰,依然构成多态(父类必须用virtual修饰)
class A
{
public:
virtual A* fun()
{
cout << "fun_A" << endl;
return this;
}
};
class B : public A
{
public:
B* fun()
{
cout << "fun_B" << endl;
return this;
}
};
但是这是不规范的,建议写上.
3.析构函数的重写
对于一个类的析构函数是需要写成虚函数的.
class A
{
public:
virtual ~A()
{
cout << "fun_A" << endl;
}
};
class B : public A
{
public:
virtual ~B()
{
cout << "fun_B" << endl;
}
};
这样写两个析构函数也是构成虚函数的,因为这两个函数的函数名虽然看似不同,但实际上是相同的继承,都会被处理成destructor.

先调用子类对象的析构函数,子类包含自己的部分和父类的部分,所以会调一次B的析构和A的析构,然后A析构.
现在再来考虑析构函数是否需要定义成virtual类型.我们如果不定义为virtual类型,此时两个析构函数不再构成多态,并且我们发现析构依然正常进行了,但实际上,在特定情况下会发生错误
int main()
{
A* a1 = new A;
delete a1;
A* a2 = new B;
delete a2;
return 0;
}
此时析构的结果为

此时就出现问题了.a2指向子类对象,却只调了父类的析构,这样就会导致内存泄漏.原因是a2是A类型的指针,此时调用delete只会调用A类的析构函数,但是a2却开辟了B类的空间.而我们希望的是指向什么类型就调用什么类型的析构,所以我们希望其构成多态,因此要给两个析构函数加上virtual.编译器也是这样想的,所以就把析构函数的名字都处理成destructor,以便于构成多态.
现在来看一个练习
class A
{
public:
virtual void func(int val = 1){ std::cout<<"A->"<< val <<std::endl;}
virtual void test(){ func();}
}
class B : public A
{
public:
void func(int val=0){ std::cout<<"B->"<< val <<std::endl; }
};
int main(int argc ,char* argv[])
{
B*p = new B;
p->test();
return 0;
}
该段代码执行结果为?答案是B->1
在调用p->test()时,实际上是test(p),而test()的定义实际上是test(A* this),而在test()中调用了this->func(),而func()是个虚函数,于是就满足了父类指针去调用虚函数,满足了多态的要求.而B类中对func进行了重写,而传入给func的指针是B类的p,于是就调用B类的func.那为什么不是B->0,因为继承并不对缺省值进行继承,所以缺省值还是父类的缺省值,重写的时候无论子类缺省值写什么都不会起作用.因此最终结果为B->1.
override和final
从上面可以看出,C++对函数的重写要求比较严格,于是C++11为我们提供了两个关键字来帮助用户检测是否构成多态.
final:修饰虚函数表示该虚函数不能够被重写.修饰类则表示该类不能被继承
而不能继承的类我们前面也提过继承,将构造函数私有即可,这是C++98的做法.
class A
{
public:
virtual A* fun() final
{
cout << "fun_A" << endl;
return this;
}
};
class B : public A
{
public:
B* fun()//err:无法重写final函数
{
cout << "fun_B" << endl;
return this;
}
};
override:用于检查子类虚函数是否重写父类虚函数
虚函数存在的意义就是用来重写构成多态,所以只要在函数后面加上override进行修饰,如果发现该函数没有构成重写就会报错
重载,重写,隐藏

抽象类
概念
在虚函数后面写上=0,则这个函数被称为纯虚函数.包含纯虚函数的类叫做抽象类(也叫接口类).抽象类不能实例化出对象,继承该类的子类也不能进行实例化,因为它把父类的纯虚函数继承下来了.
class Car {
public:
virtual void Drive() = 0;
};
int main()
{
Car car;//err:不允许使用抽象类型
}
如果想要能够实例化,就需要用另外一个类对该类进行继承,并重写纯虚函数.
class Car {
public:
virtual void Drive() = 0;
};
class Benz :public Car
{
virtual void Drive() {
}
};
纯虚函数的意义在于强制子类去进行重写.或者表示抽象类型.抽象指在现实中没有对应实体的物品,比如车是一个抽象的大类,只有具体到型号才有意义.
多态的原理
虚函数表
一个常见的练习:
class Base {
public:
virtual void Func()
{}
private:
int _b;
};
int main()
{
Base b;
cout<<sizeof(b)<<endl;
}
问输出是多少.常规情况下,我们认为是4,因为函数不会进行实例化,所以b里面实际上就只有一个int.但是实际上是

原因是它多了一个指针

这个指针叫做虚函数表指针.这个指针指向了一个表,这个表叫做虚(函数)表,存储了虚函数的地址.为什么不直接存到这个对象中?因为该对象可能存在多个虚函数.
多态的原理
class Base {
public:
virtual void Func()
{
cout << "Base" << endl;
}
private:
int _b;
};
class Child : public Base
{
public:
virtual void Func()
{
cout << "Child" << endl;
}
private:
int _c;
};
现在我们来看这样一段代码,对于Base类来说,大小为8字节(int+虚表指针).
对于Child类来说,继承了Base类,所以已经有了虚函数指针,自己就不再需要了,所以大小为12.
现在我们分别实例化一个父类对象和子类对象
int main()
{
Base b;
Child c;
}
在父类对象中,__vfptr存储的是父类的虚函数地址0x002e159b

而在子类对象中,__vfptr存储的是子类的虚函数地址0x002e155f

当我们满足多态条件时
void fun(Base& b)
{
b.Func();
}
这个指针如果是指向Base类,就调Base类的虚函数;如果是指向Child类,就调Child类的虚函数;它的实现是:我指向谁就通过虚表全部查找对应的虚函数,而虚表指向的位置早在创建对象的时候就确定了.而子类重写虚函数的本质,就是去修改继承的父类的虚表指针指向的位置.
那么如何实现指向谁调谁的?多态要求必须是父类指针去调用函数,如果传进来子类对象,会发生切割继承,这样就只留下了父类的部分,但是父类的虚表指针在子类对象重写虚函数的时候就已经被修改,于是就根据虚表指针去调用了子类的虚函数.
从进程地址空间角度来看,地址空间分为栈,堆,数据段,代码段,而所有的函数地址都被存储在数据段和代码段中,普通函数和虚函数都会被编译为指令后存储在代码段中,此外虚表也被存在代码段中
现在我们来这样做
class Base {
public:
virtual void Func1()
{
cout << "Base:Func1" << endl;
}
virtual void Func2()
{
cout << "Base:Func2" << endl;
}
void Func3()
{
cout << "Base:Func3" << endl;
}
private:
int _b;
};
class Child:public Base
{
public:
virtual void Func1()
{
cout << "Child" << endl;
}
private:
int _c;
};
父类有两个虚函数,子类继承父类,但是只重写其中一个虚函数,那么对于子类来说

由于继承,虚函数表会有父类的Func1和Func2,而Func1由于被重写,虚函数表指向了子类重写的Func1.由于Func3并不是虚函数,所以并不存在虚表中.
动态绑定与静态绑定
多态实际上分为两种,动态和静态,分别对应动态绑定和静态绑定.静态指编译期间已经确定了程序行为,比如函数重载;而动态指程序运行时根据程序具体实现来调用具体函数,比如我们前面写的多态.
void func(int i){};
void func(float i){};
这就是一种静态绑定,在编译过程中就已经确定参数内容了,而前面讲的多态,可以根据程序传参的不同调用不同函数,因此它是一种动态绑定
单继承和多继承的虚表
单继承的虚表
现在来看这样一种情况
class Base {
public:
virtual void Func1()
{
cout << "Base:Func1" << endl;
}
virtual void Func2()
{
cout << "Base:Func2" << endl;
}
void Func3()
{
cout << "Base:Func3" << endl;
}
private:
int _b;
};
class Derive : public Base
{
public:
virtual void Func1()
{
cout << "Derive:Func1" << endl;
}
virtual void Func3()
{
cout << "Derive:Func3" << endl;
}
virtual void Func4()
{
cout << "Derive:Fun4" << endl;
}
private:
int _c;
};
子类对父类的一个函数进行了重写,并且有另外两个函数

但是我们发现监视窗口并看不到func3和func4因为编译器做了处理,那么我们要怎么查看呢?我们可以直接打印整个虚函数表.
虚函数表本质上是个指针数组,这个数组存储的内容是函数指针,为了便于编写,我们可以定义一下函数指针
typedef void(*VF_PTR)();
这段代码实际上是把一个返回值和参数为空的函数指针起名为VF_PTR
虚表的末位是0,所以我们可以不用知道整个表的大小
void PrintVFT(VF_PTR* pTable)
{
for (size_t i = 0; pTable[i] != 0; i++)
{
printf("vfTable[%d]:%p,p->", i, pTable[i]);
pTable[i]();
}
}
int main()
{
Base b;
Derive c;
PrintVFT((VF_PTR*)(*(int*)&b));
printf("\n");
PrintVFT((VF_PTR*)(*(int*)&c));
}
解释下为什么这么写,第一步,取b的地址&b,第二步,强转为int*类型,由于虚地址表是一个指针,只有4位,所以把Base*类型强转为int*类型,然后进行解引用,就能获得b地址的前四位的空间,即虚表的地址.最后强转为函数指针类型,传入函数.


而对于多个子类继承同一个父类,那么多个子类会共享这一个虚表
多继承的虚函数表
现在我们把上面的代码转成多继承
class Base1 {
public:
virtual void Func1(){ cout << "Base:Func1" << endl; }
virtual void Func2(){ cout << "Base:Func2" << endl; }
private:
int _b1;
};
class Base2 {
public:
virtual void Func1(){ cout << "Base:Func1" << endl; }
virtual void Func2(){ cout << "Base: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 _d;
};
首先,Derive有多大?答案是20,现在Derive里面有一个Base1,有一个Base2,还有自己的内容.Base1和Base2各有一个int和虚表,所以都是8.这两个Base是独立的,所以各有一个虚表,继承给Derive后依然是两个虚表,不过自己的虚表就不需要了,所以只有一个int.最后加起来是20.
现在来打印虚表

结果是func1,func3被重写了,而func2没被重写.三者的虚表关系如下:

从这里可以看出,一个子类可以同时拥有多个虚表
总结
只要在类中定义了虚函数(而非继承),就会有一张虚表.对于单继承而言,如果无论是否对父类的虚函数进行改写,使用的都是父类的虚表;如果自己又定义了新的虚函数,子类才会出现新的虚表.对于多继承来说,同样使用的是父类的虚表,当自己定义了虚函数后才会创建子类的虚表.

