C++之多态（上）

C++之多态

多态的概念

多态(polymorphism)的概念：通俗来说，就是多种形态。多态分为编译时多态(静态多态)和运⾏时多 态(动态多态)，这⾥我们重点讲运⾏时多态，编译时多态(静态多态)和运⾏时多态(动态多态)。编译时 多态(静态多态)主要就是我们前⾯讲的函数重载和函数模板，他们传不同类型的参数就可以调⽤不同的 函数，通过参数不同达到多种形态，之所以叫编译时多态，是因为他们实参传给形参的参数匹配是在 编译时完成的，我们把编译时⼀般归为静态，运⾏时归为动态。

运⾏时多态，具体点就是去完成某个⾏为(函数)，可以传不同的对象就会完成不同的⾏为，就达到多种 形态。⽐如买票这个⾏为，当普通⼈买票时，是全价买票；学⽣买票时，是优惠买票(5折或75折)；军 ⼈买票时是优先买票。再⽐如，同样是动物叫的⼀个⾏为(函数)，传猫对象过去，就是”(>^ω<) 喵“，传狗对象过去，就是"汪汪"。

多态的定义及实现

多态的构成条件

多态是⼀个继承关系的下的类对象，去调⽤同⼀函数，产⽣了不同的⾏为。⽐如Student继承了 Person。Person对象买票全价，Student对象优惠买票。

实现多态还有两个必须重要条件：

• 必须指针或者引⽤调⽤虚函数
• 被调⽤的函数必须是虚函数。

说明：要实现多态效果，第⼀必须是基类的指针或引⽤，因为只有基类的指针或引⽤才能既指向基类也能派⽣ 类对象；第⼆派⽣类必须对基类的虚函数重写/覆盖，重写或者覆盖了，派⽣类才能有不同的函数，多 态的不同形态效果才能达到。

虚函数

类成员函数前⾯加virtual修饰，那么这个成员函数被称为虚函数。注意⾮成员函数不能加virtual修 饰。

class Person 
{public:};virtual void BuyTicket() { cout << "买票全价" << endl;}

虚函数的重写/覆盖

虚函数的重写/覆盖：派⽣类中有⼀个跟基类完全相同的虚函数(即派⽣类虚函数与基类虚函数的返回值 类型、函数名字、参数列表完全相同)，称派⽣类的虚函数重写了基类的虚函数。

注意：在重写基类虚函数时，派⽣类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承 后基类的虚函数被继承下来了在派⽣类依旧保持虚函数属性)，但是该种写法不是很规范，不建议这样 使⽤，不过在考试选择题中，经常会故意买这个坑，让你判断是否构成多态。

 class Person {public:virtual void BuyTicket() { cout << "买票全价" << endl; } };class Student : public Person {public:virtual void BuyTicket() { cout << "买票打折" << endl; }};void Func(Person* ptr){// 这⾥可以看到虽然都是Person指针Ptr在调⽤BuyTicket // 但是跟ptr没关系，⽽是由ptr指向的对象决定的。ptr->BuyTicket();}int main(){Person ps;Student st;Func(&ps);Func(&st);return 0;}

 class Animal{public:virtual void talk() const{}};class Dog : public Animal 
{public:virtual void talk()  const{ 
std::cout << "汪汪" << std::endl;}};class Cat : public Animal
{public:virtual void talk() const{ 
std::cout << "(>^ω^<)喵" << std::endl; 
}};void letsHear(const Animal& animal){animal.talk();}int main(){Cat cat;Dog dog;letsHear(cat);letsHear(dog);return 0;}

多态场景的⼀个选择题

以下程序输出结果是什么（）

A: A->0 B:B->1 C:A->1 D:B->0 E:编译出错 F:以上都不正确

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是子类，去找子类发现没有子类没有，然后会去继承的父类里面去找，这里也构成多态的关系，这里面有陷阱，满足多态的情况下，调用子类重写的虚函数

所以答案是B

虚函数重写的⼀些其他问题

协变(了解)

派⽣类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引 ⽤，派⽣类虚函数返回派⽣类对象的指针或者引⽤时，称为协变。协变的实际意义并不⼤，所以我们 了解⼀下即可。

class A {};class B : public A {};class Person {public:virtual A* BuyTicket() 
{ 
cout << "
买票
全价
" << endl;return nullptr;}};class Student : public Person {public:virtual B* BuyTicket() 
{ 
cout << "
买票
打折
" << endl;return nullptr;}};void Func(Person* ptr){ptr->BuyTicket();}int main(){Person ps;Student st;Func(&ps);Func(&st);return 0;}

析构函数的重写

基类的析构函数为虚函数，此时派⽣类析构函数只要定义，⽆论是否加virtual关键字，都与基类的析 构函数构成重写，虽然基类与派⽣类析构函数名字不同看起来不符合重写的规则，实际上编译器对析 构函数的名称做了特殊处理，编译后析构函数的名称统⼀处理成destructor，所以基类的析构函数加了 vialtual修饰，派⽣类的析构函数就构成重写。

下⾯的代码我们可以看到，如果~A()，不加virtual，那么deletep2时只调⽤的A的析构函数，没有调⽤ B的析构函数，就会导致内存泄漏问题，因为~B()中在释放资源。

注意：这个问题⾯试中经常考察，⼤家⼀定要结合类似下⾯的样例才能讲清楚，为什么基类中的析构 函数建议设计为虚函数。

 class A{public:virtual ~A(){cout << "~A()" << endl;}};class B : public A {public:~B(){ 
cout << "~B()->delete:"<<_p<< endl;delete _p;}protected:int* _p = new int[10];};int main(){A* p1 = new A;A* p2 = new B;// 只有派⽣类Student的析构函数重写了Person的析构函数，下⾯的delete对象调⽤析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调⽤析构函数。delete p1;delete p2;return 0;}

override 和final关键字

从上⾯可以看出，C++对函数重写的要求⽐较严格，但是有些情况下由于疏忽，⽐如函数名写错参数写 错等导致⽆法构成重载，⽽这种错误在编译期间是不会报出的，只有在程序运⾏时没有得到预期结果 才来debug会得不偿失，因此C++11提供了override，可以帮助⽤⼾检测是否重写。如果我们不想让派 ⽣类重写这个虚函数，那么可以⽤final去修饰。

 // error C3668: “Benz::Drive”: 包含重写说明符“override”的⽅法没有重写任何基类⽅法class Car {public:virtual void Dirve(){}};class Benz :public Car {public:virtual void Drive() override { cout << "Benz舒适" << endl; }};int main(){return 0;}

// error C3248: “Car::Drive”: 声明“final”的函数⽆法被“Benz::Drive”重写class Car{public:virtual void Drive() final {}};class Benz :public Car{public:};int main(){return 0;virtual void Drive() { cout << "Benz舒适" << endl; }

重载/重写/隐藏的对⽐

注意：这个概念对⽐经常考，⼤家得理解记忆⼀下

三个概念对比：

重载

1.两个函数在同一作用域

2.函数相同，参数不同，参数的类型或者个数不同，返回值可同，可不同

重写/覆盖

1.两个函数分别在继承体系的父类和子类不同作用域

2.函数名，参数，返回值都必须相同，协变例外

3.两个函数都必须是虚函数

隐藏

1.两个函数分别在继承体系的父类和子类不同作用域

2.函数名相同

3.两个函数只要不构成重写，就是隐藏

4.父子类的成员变量相同也叫隐藏

纯虚函数和抽象类

在虚函数的后⾯写上=0，则这个函数为纯虚函数，纯虚函数不需要定义实现(实现没啥意义因为要被 派⽣类重写，但是语法上可以实现)，只要声明即可。包含纯虚函数的类叫做抽象类，抽象类不能实例 化出对象，如果派⽣类继承后不重写纯虚函数，那么派⽣类也是抽象类。纯虚函数某种程度上强制了 派⽣类重写虚函数，因为不重写实例化不出对象。

 class Car{public:virtual void Drive() = 0;};class Benz :public Car{public:virtual void Drive(){cout << "Benz舒适" << endl;}};
class BMW :public Car{public:virtual void Drive(){cout << "BMW操控" << endl;}};int main(){// 编译报错：error C2259: “Car”: ⽆法实例化抽象类 
Car car;Car* pBenz = new Benz;pBenz->Drive();Car* pBMW = new BMW;pBMW->Drive();return 0;}