一、多态的概念
多态,通俗讲就是多种形态。在C++中,不同类型的对象去调用同一种方法或函数,会产生不同的结果,这种情况就称为多态。
例如,抢微信红包。不同人(不同对象),抢同一个红包(同一种方法),但是抢到金额不同(不同的结果)。
二、多态的分类
多态分为两种:静态多态和动态多态。
静态多态:指的是函数重载和运算符重载。
动态多态:指的是通过虚函数和派生类实现运行时多态。
下面将详细地加以解释
三、静态多态
静态多态就是函数重载和运算符重载。
所谓重载,就是同名,但是由于返回值类型或者参数不同,调用时产生不同的结果。
为什么是静态呢?因为静态多态是在编译期间实现的。编译器在编译过程中,就已经确定了函数的地址(定下了执行同名函数中的哪一个)。因为编译器会根据函数形参的类型直接判断出要调用哪个函数,并且固定下来。
请看代码:
#include<iostream>
using namespace std;
class animal {
public:
void speak() {
cout << "动物在说话" << endl;
}
};
class cat :public animal {
public:
void speak() {
cout << "小猫在说话" << endl;
}
};
void dospeak(animal& L) {
L.speak();
}
void test1() {
cat L;
dospeak(L);
}
int main() {
test1();
system("pause");
return 0;
}
执行结果如下:
从执行结果可以看到,调用的是animal类的speak函数。这是因为dospeak()函数形参是指向animal类型的引用,编译器在编译中发现了这一点,从而固定了dospeak()函数中调用的speak函数的地址,使他始终调用animal类中的speak函数。
由于函数地址固定,所以称为静态多态。
四、动态多态
一、引入
从上面的代码可以看到,静态多态不够灵活。我们既然创建了一个cat类的对象,就想让dospeak函数中调用cat类的speak函数,然而静态多态做不到这一点。所以,由此引入了动态多态。有了动态多态,便可以根据输入参数的类型来调用不同的同名函数。
二、动态多态条件
动态多态的实现借助继承和虚函数。要求:
1、必须通过基类的指针或引用调用函数
2、被调用的函数必须是虚函数,并且在派生类中对虚函数进行了重写
实际上这也是对动态多态的语法要求。
理解条件:
1、必须通过基类的指针或者引用来调用:
即:参数是基类的指针或者引用。在实际调用时,可以输入此基类的派生类的指针或者引用。
2、被调用的函数必须是虚函数,并且在派生类中对虚函数进行了重写:
这个同名函数必须在基类中被声明为虚函数,并且派生类中重写这个函数
三、虚函数
虚函数:被virtual修饰的函数。
虚函数语法为:virtual 返回值类型 函数名(){函数体}
一旦定义了虚函数,该基类的派生类中的同名函数都成虚函数,无论是否用virtual修饰。当然,还需要基类派生类中同名函数返回值类型,形参表都相同。
虚函数只能是类中的成员函数,不能是普通函数或者静态函数。
写虚函数时常见错误:
1、无意的重写:在派生类中声明一个与基类某个虚函数具有相同签名(同返回值类型,形参表,const属性)的成员函数。
class animal {
public:
virtual void speak() {
cout << "动物在说话" << endl;
}
};
class cat :public animal {
public:
void speak() {
cout << "小猫在说话" << endl;
}
};
在上面的代码中,我们不想让cat类中的speak函数成为虚函数,但是由于基类定义了同标签的函数为虚函数,cat类中的speak函数被迫成为虚函数。
2、虚函数签名不匹配:
class animal {
public:
virtual void speak() {
cout << "动物在说话" << endl;
}
};
class cat :public animal {
public:
virtual void speak(int a) {
cout << "小猫在说话" << endl;
}
};
我们本意是cat类中speak重写虚函数,但是由于形参不同,导致创建了一个新的虚函数,两个speak函数之间没有关联。
针对上述问题,解决方法:
1、函数声明后加上override,明确表面这个派生类的虚函数重写基类虚函数。这时如果签名不匹配就会报错提醒(override写在派生类函数声明)
class animal {
public:
virtual void speak() {
cout << "动物在说话" << endl;
}
};
class cat :public animal {
public:
virtual void speak(int a) override{
cout << "小猫在说话" << endl;
}
};
这里表示cat类中的虚函数是对基类虚函数的重写
2、关键字final 往往写在基类成员函数声明中,表明不希望这个虚函数被重写。这时如果在派生类中重写虚函数就会报错
补充:final也可以用在类中,表示不希望这个类被继承
class animal final {
public:
virtual void speak() final {
cout << "动物在说话" << endl;
}
};
class cat :public animal {
public:
virtual void speak(int a) {
cout << "小猫在说话" << endl;
}
};
这里final表示不希望animal类被继承,不希望虚函数被重写
四、虚函数重写
虚函数重写:派生类中有一个与基类完全相同(返回值、形参、const属性都相同)的虚函数,则称派生类的虚函数重写了基类的虚函数。
通过对虚函数的重写,就实现了动态多态。
请看代码:
#include<iostream>
using namespace std;
class animal {
public:
virtual void speak() {
cout << "动物在说话" << endl;
}
};
class cat :public animal {
public:
virtual void speak() {
cout << "小猫在说话" << endl;
}
};
class dog :public animal {
public:
virtual void speak() {
cout << "小狗在说话" << endl;
}
};
void dospeak(animal& L) {
L.speak();
}
void test1() {
cat L;
dospeak(L);
}
void test2() {
dog L;
dospeak(L);
}
int main(){
test1();
test2();
system("pause");
return 0;
}
运行结果如下:
可以发现,这一次cat类对象和dog类对象都调用了自己类中的方法,实现了多态。
五、虚函数重写的例外
1、协变:基类函数与派生类函数返回值类型不同的情况。
前面讲到,虚函数重写要求基类和派生类虚函数签名必须是匹配的。但不绝对,有例外。协变就是其中一种。当基类虚函数返回值类型是基类的引用或指针,并且派生类虚函数返回值类型是该派生类的引用或指针,那么仍然可以实现多态
强调:返回值类型可以协变,但是参数必须一样。
可以看一段代码:
#include<iostream>
using namespace std;
class animal {
public:
virtual animal* speak(animal &L) {
cout << "动物在说话" << endl;
return this;
}
};
class cat :public animal {
public:
virtual cat* speak(cat &L) {
cout << "小猫在说话" << endl;
return this;
}
};
class dog :public animal {
public:
virtual dog* speak(dog &L) {
cout << "小狗在说话" << endl;
return this;
}
};
void dospeak(animal& L) {
L.speak(L);
}
void test1() {
cat L;
dospeak(L);
}
void test2() {
dog M;
dospeak(M);
}
int main() {
test1();
test2();
system("pause");
return 0;
}
这段代码和之前差别不大,只是修改了speak函数返回值类型,并且对应地对dospeak函数作了修改,但函数作用没变。执行后仍然实现了多态。
2、析构函数的重写:这是基类与派生类虚函数不同名的情况
如果基类的虚构函数是虚函数,那么对于派生类,只要定义了析构函数,无论是否用virtual关键字修饰,析构函数都重写了基类的析构函数,尽管他们的函数名不同。
对于普通对象(通过类名 对象名 直接定义)而言,无论我们是不是声明虚函数,无论是不是多态,都可以正确调用。
对于动态申请的对象,必须声明是虚函数
请看下面的代码:
#include<iostream>
using namespace std;
class animal {
public:
virtual ~animal() {
cout << "~animal()" << endl;
}
};
class cat :public animal {
public:
virtual ~cat() {
cout << "~cat()" << endl;
}
};
class dog :public animal {
public:
virtual ~dog() {
cout << "~dog()的调用" << endl;
}
};
int main(){
animal L;
cat M;
animal *p1 =new animal;
animal *p2 =new cat;
delete p1;
delete p2;
return 0;
}
运行结果如下:
普通对象
动态申请的,并且如果将派生类对象地址赋值给基类类型的指针。这种情况下如果不声明virtual,对于派生类对象只析构基类的部分而不析构派生类的部分,造成内存泄漏,故而必须声明虚函数
六、动态多态原理
动态多态实现原理:加上关键字virtual之后,该成员函数成为虚函数,同时基类中多出一个指针vfptr(虚函数指针)。vfptr指向基类中的vftable(虚函数表),虚函数表中存储着基类中虚函数的地址。如果派生类没有重写这个虚函数,那么继承时就会继承基类的vfptr,指向的是基类的vftable,也就是基类的虚函数。如果派生类重写虚函数,那么派生类的vftable(原先是基类的虚函数地址)会被替换为派生类的虚函数地址。
五、抽象类
概念:如果在虚函数的后面写上=0,那么这个函数就是纯虚函数。含有纯虚函数的类成为抽象类
virtual void speak()=0;
抽象类不能实例化对象。它的派生类继承后也不能实例化对象。如果想实例化对象,必须重写纯虚函数。(重写时不必写=0)
这体现的是接口继承。