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

C++之多态（上）

article 2024/11/2 9:16:24

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.kler.cn/a/375633.html

相关文章：

  • GNSS和PTP时间同步的基础原理介绍
  • gitee 使用 webhoot 触发 Jenkins 自动构建
  • 蓝牙MCU蓝牙医疗检测相关案例
  • 汽车免拆诊断案例 | 2010款起亚赛拉图车发动机转速表指针不动
  • 浅谈鸿蒙生态崛起的机遇
  • 健康之路押注医药零售：毛利率下滑亏损扩大，医疗咨询人次大幅减少
  • [实时计算flink]CREATE TABLE AS（CTAS）语句
  • 部署服务器监控集群之“Prometheus Grafana Alertmanager“
  • 智慧城市：未来城市的蓝图
  • Jupyter Notebook 打开指定文件夹
  • Straightforward Layer-wise Pruning for More Efficient Visual Adaptation
  • 用示波器如何测量信号的相位差？
  • 鸿蒙系统不断发展的看法
  • Python实现Lucas-Lehmer测试
  • Android 滴滴面经
  • No.22 笔记 | WEB安全 - 任意文件绕过详解 part 4
  • 深入理解数据库的三范式
  • OpenCV—HoughLines中的theta角度理解
  • ArcGIS Pro SDK （二十一）渲染
  • CSP/信奥赛C++刷题训练：经典差分例题（3）：洛谷P5542 ：[USACO19FEB] Painting The Barn S
  • fastboot相关的命令大全
  • 计算机后台服务-更新下载，重启————未来之窗行业应用跨平台架构
  • Notepad++检索包含多个关键字的行
  • 【django】RESTful API 设计指南
  • Hadoop-006-集群运维常见报错及解决方案
  • NGPT：在超球面上进行表示学习的归一化 Transformer