1、多态的基本概念
多态是C++面向对象三大特性之一
多态分为两类
- 静态多态:函数重载和运算符重载属于静态多态,复用函数名
- 动态多态:派生类和虚函数实现运行时多态
静多态和动多态的区别:
- 静态多态的函数地址早绑定—编译阶段确定函数地址
- 动态多态的函数地址晚绑定—运行阶段确定函数地址
动态多态满足条件
- 有继承关系
- 子类重写父类的虚函数
动态多态的使用
父类的指针或者引用 指向子类对象
指针:
(new什么对象下一行就执行该对象里的对应函数)
引用:
多态的优点
- 代码组织结构清晰
- 可读性强
- 利于前期和后期的扩展和维护
虚函数
在函数前加virtual关键字,函数变成虚函数,那么编译器在编译的时候就不能确定函数调用了(在编译时就不能绑定地址)
函数重写
返回值类型、函数名、参数列表完全相同
案例:
问题:
//由于传入对象不同,要多种形态调用公共接口
#include <iostream>
using namespace std;
//动物类
class Animal{
public:
void speak()
{
cout<<"动物在说话 "<<endl;
}
};
//猫类
class Cat:public Animal
{
public:
void speak()
{
cout<<"小猫在说话"<<endl;
}
};
//执行说话的函数
//地址早绑定 在编译阶段确定函数地址
void doSpeak(Animal &animal)
//父类的引用指向子类对象
//c++中允许父子之间的类型转换
//Animal & animal=cat;
{
animal.speak();
//问题:执行的是Animal中的speak函数还是cat中的speak说话
//执行Animal中的speak函数
//因为地址早绑定 在编译阶段确定函数地址
}
void test01()
{
Cat cat;
doSpeak(cat);
}
int main(){
system("pause")
teturn 0;
}
执行的speak函数是Animal中的speak函数
因为地址早绑定 在编译阶段确定函数地址
如果想让cat执行Cat中的speak函数,那么这个函数地址就不能提前绑定,需要在运行阶段绑定,地址晚绑定
方法:
在Animal的speak函数前加上virtual关键字
加上关键字后cat执行cat中的speak,dog执行dog中的speak,实现动态多态
2、多态的原理剖析
用sizeof来查看Animal类只占一个字节,因为只有非静态成员函数属于类的对象上,所以speak这个非静态成员函数不属于Animal这个类的对象上,相当于一个空类,占用一个字节
但是将speak函数加上virtual关键字变成动态多态之后Animal这个类占四个字节,因为类内多了一个指针,虚函数(表)指针(vfptr)
该指针指向vftable(虚函数表,记录虚函数地址)
如果子类中不重写函数,那么只是执行了简单的继承,子类也会将父类中的vfptr指针继承下来并且指向父类的虚函数列表
如果发生了重写,子类中的虚函数内部会替换成子类的虚函数地址(从父类中继承下来的,且父类中的虚函数表)
当父类的指针或者引用指向子类对象时(Animal &animal = cat;),执行spaek函数,会执行cat中的speak函数,发生多态
案例1:
计算器类
普通实现:
如果要提供新的运算,需要修改源码
多态实现:
- 代码组织结构清晰
- 可读性强
- 利于前期和后期的扩展和维护
#include <iostream>
using namespace std;
#include <string>
//实现计算器类抽象
class AbstactCaluculator
{
public:
virtual int getResult()//1、父类中的函数写为虚函数
{
return 0;
}
int m_Num1;
int m_Num2;
};
//加法计算器
//2、继承抽象计算器类
class AddCaculator :public AbstractCalculat
{
public:
int getResult()
{
return m_Num1+m_Num2;
}
};
//减法计算器(继承抽象计算器类)
class subCaculator :public AbstractCalculat
{
public:
int getResult()
{
return m_Num1-m_Num2;
}
};
void test02(
{
//加法运算
//父类指针或者引用指向子类对象
AbstractCalculator * abc=new AddCalculator;//堆区创建内存
abc->m_Num1=10;
abc->m_Num2=10;
cout<<abc->m_Num1<<"+"<<abc->m_Num2<<"="<<abc->getResult()<<endl;
delete abc;//用完后记得释放堆区内存
//减法运算
abc=new subCalculator;
abc->m_Num1=10;
abc->m_Num2=10;
cout<<abc->m_Num1<<"-"<<abc->m_Num2<<"="<<abc->getResult()<<endl;
}
int main(){
test02();
system("pause");
return 0;
}
3、纯虚函数和抽象类函数
在多态中,通常父类中的虚函数的实现是毫无意义的,主要都是调用子类重写的内容
因此,可以将虚函数改为纯虚函数
纯虚函数语法:
virtual 返回值类型 函数名 (参数列表)=0;
抽象类
当类中有了纯虚函数,这个类也称为抽象类
抽象类特点:
- 无法实例化对象
- 子类必须重写抽象类中的纯虚函数,否则也属于抽象类
示例:
1、无论在栈区还是堆区实例化对象都会报错
2、子类中没有重写函数func,子类也属于抽象类,无法创建对象,编译器报错
(son因没有重写父类中的纯虚函数,也属于抽象函数,无法实例化出对象s)
4、虚析构和纯虚析构
语法:
虚析构:
virtual ~类名(){};
纯虚析构:
virtual ~类名()=0;
类名::类名(){};
问题:
多态使用时,如果子类中有属性开辟到堆区,那么父类指针在释放时无法调用到子类的析构代码(造成堆区内存泄漏)
(父类的指针或引用指向子类对象,但是父类指针无法释放子类对象)
(在释放父类时并没有执行子类的析构函数)
解决:
将父类中的析构函数改为虚析构或纯虚析构
虚析构解决:
纯虚析构解决:
将父类中的析构函数改为纯虚析构函数
但是编译器报错,因为该函数没有具体实现
(如果父类中开辟了数据到堆区,则需要使用父类中的析构函数)
解决:
在内声明,类外写出析构函数的具体实现
注意:
- 纯虚析构需要声明也需要实现
- 含有纯虚析构的类也属于抽象类,无法实例化对象
- 如果子类中没有堆区数据,可以不写为虚析构或纯虚析构
- 都需要有具体函数实现
虚析构和纯虚析构共性:
- 可以解决父类指针释放子类对象
- 都需要有具体函数实现
虚析构和纯虚析构的区别:
如果是纯虚析构,该类属于抽象类,无法实例化对象(纯虚函数也无法实例化对象)
案例:电脑组装
#include <iostream>
using namespace std;
//抽象不同零件的类
//抽象cpu类
class CPU
{
public:
//抽象的计算函数
virtual void caculate()=0;
};
//抽象的显卡类
class VideoCard
{
public:
//抽象的显示函数
virtual void display()=0;
};
//抽象的内存条类
class Memory
{
public:
//抽象的存储函数
virtual void storage()=0;
};
//电脑类
class Computer
{
public:
Computer(CPU *cpu,VideoCard *vc,Memory *mem)
{
//将三个指针进行接收
m_cpu=cpu;
m_vc=vc;
m_mem=mem;
}
//提供工作函数
voide work()
{
//让零件工作起来,调用接口(父类指针调用接口,根据传入不同的子类实现不同的函数,多态)
m_cpu->caculate();
m_vc->display();
m_mem->storage();
}
//析构函数 释放三个电脑零件
~Computer()
{
if(m_cpu!=NULL){
delete m_cpu;
m_cpu=NULL;
}
if(m_vc!=NULL){
delete m_vc;
m_vc=NULL;
}
if(m_mem!=NULL){
delete m_mem;
m_mem=NULL;
}
}
private:
//父类指针
CPU *m_cpu;//CPU零件指针
VideoCard *m_vc;//显卡零件指针
Memory *m_mem;//内存条指针
};
//具体厂商
//Intel厂商
//CPU类的子类
class IntelCPU:public CPU
{
public:
virtual void caculate()
{
cout<<"interl的CPU开始计算了"<<endl;
}
};
//显卡
class IntelVideoCard:public VideoCard
{
public:
virtual void display()
{
cout<<"interl的显卡开始显示了"<<endl;
}
};
//interl的内存条
class IntelMemory:public Memory
{
public:
virtual void storage()
{
cout<<"interl的内存条开始储存了"<<endl;
}
};
//Lenovo厂商
//CPU类的子类
class LenovoCPU:public CPU
{
public:
virtual void caculate()
{
cout<<"Lenovo的CPU开始计算了"<<endl;
}
};
//显卡
class LenovoVideoCard:public VideoCard
{
public:
virtual void display()
{
cout<<"Lenovo的显卡开始显示了"<<endl;
}
};
//interl的内存条
class LenovoMemory:public Memory
{
public:
virtual void storage()
{
cout<<"Lenovo的内存条开始储存了"<<endl;
}
};
void test01()
{
//组装不同的电脑
//第一台电脑零件
//父类指针指向子类对象(多态)
CPU *intelCpu=new IntelCPU;
VideoCard *interlCard=new IntelVideoCard;
Memory *interlMem=new IntelMemory;
//创建第一台电脑
Computer *computer1 = new Computer(intelCpu,interlCard,interlMem)
computer1->work();
delete computer1;
//需要将父类中的析构函数写成虚析构函数或者纯虚析构函数
//因为这三个零件指针是在Computer类中进行维护的
//否则父类对象在释放时不会将子类对象(电脑零件)释放
}
int main(){
test01();
system("pause");
return 0;
}