(详细)一篇认识C++面向对象特性 —— 多态
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了(详细)一篇认识C++面向对象特性 —— 多态，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6654字，纯文字阅读大概需要10分钟。
内容图文
之前介绍了C++面向对象的一大特性 —— 继承, 今天我们就来看看另外的一大特性 —— 多态. 话不多说, 直接进入正题.
文章目录
多态的概念
简单来说，多态就是一个行为、多种状态。
举个栗子：买火车票，都是买票这一行为，普通人只能买成人票，而我们大学生持有学生证就可以买学生票。
再比如：想必大家都玩过抽卡的游戏吧，非酋和欧皇都懂吧，那我就不多说了，这也是多态。
多态的定义及实现
1.实现多态的条件
多态的前提是继承
调用函数产生多态的行为 :
1. 函数必须为虚函数 virtual 函数
2. 虚函数需要在子类中重写
3. 调用虚函数时, 必须用父类指针或者引用调用
上述是三个多态实现的条件，缺一不可
2. 虚函数及虚函数的重写
虚函数：被virtual修饰的类成员函数称为虚函数
虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。
3. 代码示例
父类和子类的定义:
//父类
class Person {
public:
virtual void buyTicket() {
cout << "普通票 -- 全价" << endl;
}
};
//子类
class Student : public Person {
public:
//子类进行虚函数的重写
virtual void buyTicket() {
cout << "学生票 -- 半价" << endl;
}
};
多态和非多态的对比. 父类引用也可,由于引用和普通对象作为参数时, 传参会发生矛盾,故没有给出引用类型
//父类指针调用虚函数, 构成多态
void func(Person* p) {
p->buyTicket();
}
//父类对象调用虚函数, 不构成多态
void func(Person p) {
p.buyTicket();
}
测试函数:
void test() {
Person p;
Student s;
Person* pp = &p;
Student* ps = &s;
//这就是用指针调了一下对应的函数而已, 不是多态
pp->buyTicket();
ps->buyTicket();
cout << endl;
// 多态 : 看对象
func(&p);
func(&s);
cout << endl;
// 非多态 : 看类型
func(p);
func(s);
cout << endl;
}
运行结果如下:
可见三组结果, 第一组结果是用对应的指针调用了一下函数而已,与多态无关, 第二组结果是调用func(Person*)函数, 参数不同结果也不同, 明显构成多态. 第三组调用func(Person)函数, 参数不同, 结果相同, 不构成多态.
多态 --- 看对象
func(Person*)函数构成多态
传入父类对象, 就执行父类函数逻辑
传入子类对象, 就执行子类函数逻辑
非多态 --- 看类型
func(Person)函数不构成多态
传入父类对象, 参数匹配, 执行父类函数逻辑
传入子类对象, 参数不匹配, 发生切片操作, 得到的结果还是父类对象, 所以还是执行父类函数逻辑
通过这个栗子想必大家对多态也有了一定的了解
这里说一个不规范的例子:
父类加virtual, 子类不加, 子类构成多态
这是不规范的, 但是我们要知道它也构成多态, 题中人家可能这么写
还有一种情况:
父类不加virtual, 子类加了, 这时子类不构成多态
这里应该没有什么疑问吧, 父类都没有虚函数那必定不构成多态
这里子类加上virtual是为了后面还有类继承它的时候可以构成多态
所以我们自己写代码的时候, 尽量都写出来, 出题人给我们挖坑就算了, 我们自己不要给自己挖坑
4. 虚函数重写的的特殊形式(协变)
上面我们说虚函数重写要满足 — 子类虚函数和父类接口完全相同的函数 (函数名, 参数, 返回值都相同)
但是这里存在一种特殊情况 — 协变(返回值可以不同), 但返回值必须是构成父子继承关系的指针/引用
光说概念不好理解, 我们直接上一段代码, 让大家更好的理解
//先有一对父子继承关系的类
class AA { };
class BB : public AA { };
class Person {
public:
//返回值AA* , 是父类的指针
virtual AA* buyTicket() {
cout << "普通票 -- 全价" << endl;
return &AA();
}
};
class Student : public Person {
public:
//返回值BB*, 是子类的指针
virtual BB* buyTicket() {
cout << "学生票 -- 半价" << endl;
return &BB();
};
测试函数:
void func(Person* p) {
p->buyTicket();
}
void func(Person p) {
p.buyTicket();
}
void test() {
Person p;
Student s;
Person* pp = &p;
Student* ps = &s;
// 多态 : 看对象
func(&p);
func(&s);
cout << endl;
}
测试结果如下 :
可以看到, 也是可以构成多态的
值得一提的是, 一般情况下也不使用协变来构成多态, 但是我们要知道这个知识点
5. 关键字 final & override
final关键字 : 修饰的虚函数, 在子类中不能再被重写 (体现了实现继承, 我继承下来直接用, 不必重写)
override : 强制子类的函数必须重写父类的一个虚函数 (体现了接口继承, 我只用你的接口, 不用你的逻辑)
一般用于重写函数, 加一个以便自己区分是隐藏还是重写
class A {
public:
//final关键字: 修饰的虚函数,在子类中不能再被重写(体现了实现继承)
virtual void func() final {
cout << "A::func()" << endl;
}
virtual void func2() {
cout << "A::func2()" << endl;
}
};
class B : public A {
public:
//override: 强制子类的函数必须重写父类的一个虚函数(体现了接口继承)
virtual void func2() override {
cout << "B::func2()" << endl;
}
};
析构函数与虚函数
首先先来看一个概念
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。
大概意思就是: 只要父类的析构函数定义为虚函数, 无论如何子类的析构一定是重写了父类的析构, 虽然函数名不尽相同, 编译器在底层会把他们的函数名处理成一样的.
这么做的目的就是为了实现多态.
那为什么非要构成多态呢? 下面会告诉大家 !
这里我们就是回顾一下继承的知识了
首先: 调用子类的构造函数时, 会自动先调用父类的构造, 构造父类.
析构与构造正好相反, 调用子类的析构时, 先调用子类析构, 再调用父类析构, 释放各自的资源
当然, 正常情况下的析构函数调用是没有问题的.
问题就发生在切片的时候, 我们想用父类指针/引用指向子类
如果不把父类的析构函数定义为虚函数, 这时候只能调用父类的析构函数, 但凡子类中有资源, 就会造成内存泄漏.
反之, 如果定义成虚函数, 那么构成多态, 我们知道多态看对象, 此时是父类指针指向子类对象, 实际还是子类对象, 这时就会调用子类的析构. (调用子类析构之后会自动调用父类析构, 保证不会出现内存泄漏)
多态: 看对象 --> 子类对象 --> 子类析构
下面通过代码理解
class A {
public:
//析构尽量写成虚函数
virtual ~A() {
cout << "~A()" << endl;
}
};
class B : public A {
public:
//重写父类的析构函数 : 因为底层的函数名是相同的, 接口完全一致 (这么设计就是为了实现多态)
virtual ~B() {
cout << "~B()" << endl;
}
};
void test2() {
//切片: 有内存泄漏的风险 (析构不是多态)
//多态: 看对象 --> 子类对象 --> 子类析构
//用父类指针/引用 指向继承体系中的对象
A* pc = new B;
delete pc; //只调用父类析构, 如果子类中有资源, 会造成内存泄漏, 子类的资源不会被释放
// 如果父类析构写成虚函数, 就解决了问题 ()
}
我们可以看到调用了子类析构之后又调用了父类的析构
如果不把析构函数写成虚函数, 在进行测试
可以看到只调用了父类的析构, 这时如果子类中有资源, 就会造成内存泄漏
纯虚函数与抽象类
纯虚函数: 虚函数没有函数体, 在参数列表后加 = 0
抽象类 : 包含纯虚函数的类
- 抽象类不能实例化 (因为成员不完整)
- 子类继承了抽象类, 必须实现纯虚函数, 如果不实现, 也是一个抽象类, 不能实例化
class A {
public:
//纯虚函数 (没有函数体)
//抽象类: 包含纯虚函数的类
virtual void func4() = 0;
};
class B : public A {
public:
//重写父类中的纯虚函数
virtual void func4() {
cout << "B::func4()" << endl;
}
};
接口继承与实现继承
普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。
内容总结
以上是互联网集市为您收集整理的(详细)一篇认识C++面向对象特性 —— 多态全部内容，希望文章能够帮你解决(详细)一篇认识C++面向对象特性 —— 多态所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。