当前位置：首页 > news >正文

C++之多态（上）

news 2024/11/2 0:55:34

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;}

查看全文

http://www.mrgr.cn/news/63695.html