1 多态的基本概念
多态是C++面向对象三大特性之一
多态分为两类：
- 静态多态：函数重载和运算符重载属于静态多态，复用函数名
- 动态多态：派生类和虚函数实现运行时多态
静态多态和动态多态的区别：
- 静态多态的函数地址早绑定 - 编译阶段确定函数地址（静态联编）
- 动态多态的函数地址晚绑定 - 运行阶段确定函数地址（动态联编）
动态多态的满足条件：
- 有继承关系
- 子类要重写父类的虚函数，子类可以不加关键字virtual
动态多态的使用：
父类的指针或者引用 指向子类对象
#include<iostream>
using namespace std;
class Animal
{
public:
virtual void Speak(){
cout<<"动物在说话"<<endl;
}
};
class Cat:public Animal
{
public:
void Speak(){
cout<<"小猫在喵喵叫"<<endl;
}
};
class Dog:public Animal
{
public:
void Speak(){
cout<<"小狗在汪汪叫"<<endl;
}
};
void DoSeak(Animal & animal){
animal.Speak();
}
void test01(){
Cat cat;
DoSeak(cat);
Dog dog;
DoSeak(dog);
}
int main()
{
test01();
return 0;
}
2 多态的好处
多态带来的好处：
- 组织结构清晰
- 可读性强
- 对于前期和后期的扩展和维护性高
3 纯虚函数和抽象类
在多态中，通常父类中的虚函数的实现是毫无意义的，主要都是调用子类重写的内容
因此可以将虚函数改为纯虚函数，其语法如下：
virtual 返回值类型 函数名 (参数列表)=0;
当类中有了纯虚函数，这个类也称为抽象类
抽象类特点：
- 无法实例化对象
- 子类必须重写抽象父类中的所有纯虚函数，否则也属于抽象类
以下为一个制作饮品的案例：
#include<iostream>
using namespace std;
class AbstractDrinking
{
public:
virtual void Boil()=0;
virtual void Brew()=0;
virtual void PourInCup()=0;
virtual void Putsth()=0;
void makedrink(){
Boil();
Brew();
PourInCup();
Putsth();
}
};
class Coffee:public AbstractDrinking
{
public:
void Boil(){
cout<<"煮农夫山泉"<<endl;
}
void Brew(){
cout<<"冲泡咖啡"<<endl;
}
void PourInCup(){
cout<<"倒入咖啡杯中"<<endl;
}
void Putsth(){
cout<<"加入糖和牛奶"<<endl;
}
};
class Tea:public AbstractDrinking
{
public:
void Boil(){
cout<<"煮百岁山"<<endl;
}
void Brew(){
cout<<"冲泡茶叶"<<endl;
}
void PourInCup(){
cout<<"倒入茶杯中"<<endl;
}
void Putsth(){
cout<<"加入枸杞"<<endl;
}
};
void doWork(AbstractDrinking* a){
a->makedrink();
delete a;
}
void test01(){
doWork(new Coffee);
cout<<"--------------"<<endl;
doWork(new Tea);
}
int main()
{
test01();
return 0;
}
4 虚析构和纯虚析构
多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码，会导致内存泄漏
解决方式：将父类中的析构函数改为虚析构或者纯虚析构
虚析构和纯虚析构的共性：
- 可以解决父类指针释放子类对象
- 都需要有具体的函数实现
虚析构和纯虚析构的区别：
- 如果是纯虚析构，该类就属于抽象类了，无法实例化对象
虚析构语法：
virtual ~类名(){...}
纯虚析构语法：
virtual ~类名()=0;
类名::~类名(){...}
以下为用虚析构构建的案例：
#include<iostream>
#include<string>
using namespace std;
class Animal
{
public:
Animal(){
cout<<"Animal构造函数调用"<<endl;
}
//虚析构
virtual ~Animal(){
cout<<"Animal虚析构函数调用"<<endl;
}
virtual void Speak()=0;//纯虚函数
};
class Cat:public Animal
{
public:
string* m_Name;
void Speak(){
cout<<*m_Name<<"小猫在喵喵叫"<<endl;
}
Cat(string name){
m_Name=new string(name);
cout<<"Cat构造函数调用"<<endl;
}
~Cat(){
cout<<"Cat析构函数调用"<<endl;
if(m_Name!=nullptr){
delete m_Name;
m_Name=nullptr;
}
}
};
void test01(){
Animal* animal=new Cat("Tom");
animal->Speak();
delete animal;
}
int main()
{
test01();
return 0;
}
如果是纯虚析构，核心代码如下：
class Animal
{
public:
Animal(){
cout<<"Animal构造函数调用"<<endl;
}
//纯虚析构
virtual ~Animal()=0;
virtual void Speak()=0;//纯虚函数
};
Animal::~Animal() {
cout<<"Animal纯虚析构函数调用"<<endl;
}
5 综合案例
#include<iostream>
using namespace std;
class CPU//CPU抽象类
{
public:
virtual void calculate()=0;
};
class VidoeCard//显卡抽象类
{
public:
virtual void display()=0;
};
class Memory//存储抽象类
{
public:
virtual void storage()=0;
};
class Computer//电脑类
{
public:
Computer(CPU* cpu,VidoeCard* vc,Memory* mem){
m_cpu=cpu;
m_vc=vc;
m_mem=mem;
}
~Computer(){
if(m_cpu!=nullptr){
delete m_cpu;
m_cpu=nullptr;
}
if(m_vc!=nullptr){
delete m_vc;
m_vc=nullptr;
}
if(m_mem!=nullptr){
delete m_mem;
m_mem=nullptr;
}
}
void Work(){
m_cpu->calculate();
m_vc->display();
m_mem->storage();
}
private:
CPU* m_cpu;
VidoeCard* m_vc;
Memory* m_mem;
};
//Intel厂商提供的不同电脑零件
class IntelCPU:public CPU
{
void calculate(){
cout<<"Intel的CPU开始计算了"<<endl;
}
};
class IntelVideoCard:public VidoeCard
{
void display(){
cout<<"Intel的VideoCard开始显示了"<<endl;
}
};
class IntelMemory:public Memory
{
void storage(){
cout<<"Intel的Memory开始存储了"<<endl;
}
};
//Lenove厂商提供的不同电脑零件
class LenoveCPU:public CPU
{
void calculate(){
cout<<"Lenove的CPU开始计算了"<<endl;
}
};
class LenoveVideoCard:public VidoeCard
{
void display(){
cout<<"Lenove的VideoCard开始显示了"<<endl;
}
};
class LenoveMemory:public Memory
{
void storage(){
cout<<"Lenove的Memory开始存储了"<<endl;
}
};
//测试案例，组装三台不同的电脑
void test01()
{
//第一台
CPU* Intelcpu=new IntelCPU;
VidoeCard* IntelCard=new IntelVideoCard;
Memory* Intelmem=new IntelMemory;
cout<<"第一台电脑开始工作了"<<endl;
Computer* computer1=new Computer(Intelcpu,IntelCard,Intelmem);
computer1->Work();
delete computer1;
cout<<"-------------------------"<<endl;
cout<<"第二台电脑开始工作了"<<endl;
Computer* computer2=new Computer(new LenoveCPU,new LenoveVideoCard,new LenoveMemory);
computer2->Work();
delete computer2;
cout<<"-------------------------"<<endl;
cout<<"第三台电脑开始工作了"<<endl;
Computer* computer3=new Computer(new LenoveCPU,new IntelVideoCard,new IntelMemory);
computer3->Work();
delete computer3;
}
int main()
{
test01();
return 0;
}
6 参考链接
