C++ 类和对象（八）多态
文章目录
多态是C++面向对象三大特性之一
1. 多态的原理剖析
多态的分为两类：
- 静态多态： 函数重载和运算符重载属于静态多态，复用函数名
多态就是多种形态：函数重载函数名相同但是参数类型，传入顺序，参数个数不同来实现函数的多种表现形态，运算符重载可以实现多种类型的数据进行操作，也表现了多态性
- 动态多态：子类和虚函数实现运行时多态
• 通常说多态的都是着这种多态
静态多态和动态多态区别：
• 静态多态的函数地址早绑定 — 编译阶段确定函数地址
• 动态多态的函数地址晚绑定 — 运行阶段确定函数地址
C++中允许父类子类间的类型转换，不需要做强制类型转换，父类的引用或者指针就可以直接指向子类对象
地址早绑定，在编译阶段就确定了函数地址
如果想执行子类函数，那么就需要晚绑定
加关键字 virtual 虚函数
重写： 函数返回值 函数名 参数列表完全相同 不同的只有函数体里面的内容
动态多态的使用：
父类的引用或者指针 指向 子类对象
动态多态的满足条件：
- 有继承关系
- 子类重写父类的虚函数
案例：
class Animal {
public:
//虚函数
virtual void speak()
{
cout << "animal is speaking" << endl;
}
};
class Cat : public Animal {
public:
//子类重写父类的虚函数
void speak()
{
cout << "cat is speaking" << endl;
}
};
//地址早绑定，在编译阶段就确定了函数的地址
//如果 想执行cat的函数，就需要动态多态，即地址晚绑定
void doSpeak(Animal& animal) //Animal &animal = cat;
{
animal.speak();
}
void func()
{
Cat cat;
doSpeak(cat);
}
多态的函数模型
animal类不加虚函数 是 1 个字节
加了虚函数 变为 4 个字节 指针也是4个字节
原理剖析：
父类的类模型
子类没重写虚函数的类模型
子类重写虚函数后的类模型
当父类指针或引用指向子类对象时候，发生多态
Animal &animal = cat;
animal.speak();
因为创建的是子类对象，当调用公共接口speak()时候
回去子类里面找这个接口
2. 多态案例一 — 计算器类
案例描述：
分别用普通写法和多态，设计实现两个操作数进行运算的计算器类
多态的优点：
• 代码组织结构清晰
• 可读性强
• 方便前期和后期的扩展和维护
new一个相当于创建了一个加法计算器的对象，用父类的指针指向这个子类的对象，这个时候已经发生了多态了
用完后记得释放
//普通写法
class Calculator {
public:
int getResult(string op)
{
if (op == "+")
return m_Num1 + m_Num2;
else if (op == "-")
return m_Num1 - m_Num2;
else if (op == "*")
return m_Num1 * m_Num2;
}
int m_Num1;
int m_Num2;
};
void func()
{
Calculator c1;
c1.m_Num1 = 10;
c1.m_Num2 = 10;
cout << c1.m_Num1 << " + " << c1.m_Num2 << " = " <<c1.getResult("+") << endl;
cout << c1.m_Num1 << " - " << c1.m_Num2 << " = " << c1.getResult("-") << endl;
cout << c1.m_Num1 << " * " << c1.m_Num2 << " = " << c1.getResult("*") << endl;
}
想要扩展新的功能， 需要求改源码，在真的开发中，提倡开闭原则
即： 对扩展进行开放，对修改进行关闭
//多态写法
//计算器的父类
class AbstractCalculator {
public:
//虚函数
virtual int getResult(){
return 0;
}
int m_Num1;
int m_Num2;
};
//子类， 加法类
class AddCalculate : public AbstractCalculator {
//重写父类的虚函数
int getResult()
return m_Num1 + m_Num2;
};
//减法
class SubCalculate : public AbstractCalculator {
//重写父类的虚函数
int getResult()
return m_Num1 - m_Num2;
};
class MulCalculate : public AbstractCalculator {
//重写父类的虚函数
int getResult()
return m_Num1 * m_Num2;
};
void func1()
{
//多态的使用，父类的指针或者引用指向子类的对象
AbstractCalculator *c;
//加法
c = new AddCalculate;
c->m_Num1 = 100;
c->m_Num2 = 100;
cout << c->m_Num1 << " + " << c->m_Num2 << " = " << c->getResult() << endl;
//释放创建在堆区的数据
delete c;
//减法
c = new SubCalculate;
c->m_Num1 = 100;
c->m_Num2 = 100;
cout << c->m_Num1 << " - " << c->m_Num2 << " = " << c->getResult() << endl;
//释放创建在堆区的数据
delete c;
//乘法
c = new MulCalculate;
c->m_Num1 = 100;
c->m_Num2 = 100;
cout << c->m_Num1 << " * " << c->m_Num2 << " = " << c->getResult() << endl;
//释放创建在堆区的数据
delete c;
}
一个错误：
AbstractCalculator *c;
c->m_Num1 = 100;
c->m_Num2 = 100;
c = new AddCalculate;
刚开始是这样写的，
这样会报错，因为声明了一个指针，但是没给指针初始化，是野指针,是不允许的
你一样能看懂别人写的代码，不是因为你厉害，而是写代码的这人强😂
3. 纯虚函数和抽象类
在多态中，通常父类中的虚函数的实现是毫无意义的，主要都是调用子类重写的内容
因此可以将虚函数改为 纯虚函数
纯虚函数语法
virtual 返回值类型 函数名(参数列表) = 0；
当类有了这个纯虚函数，这个类也就称为了抽象类
抽象类特点：
• 无法实例化对象
• 子类必须重写抽象类中的虚函数，否则该子类也属于抽象类
示例：
class Base {
public:
//纯虚函数
virtual void func() = 0;
};
class Son : public Base {
public:
//子类重写虚函数
void func() {
cout << "Son 的func()函数重写" << endl;
}
};
void func()
{
//Base b;//报错，抽象类不能实例化
Base* b = new Son;
b->func();
}
4. 多态案例二 — 制作饮品
案例描述：
制作饮品的大致流程： 煮水， 冲泡， 倒入杯中， 加辅料
利用多态实现本案例，提供了抽象制作饮品的基类，提供子类制作咖啡和茶叶
冲咖啡：
- 煮水
- 冲泡咖啡
- 倒入杯中
- 加糖和牛奶
冲茶叶：
- 煮水
- 冲泡茶叶
- 倒入杯中
- 加柠檬
多态： 接口都一样，一个接口有多种形态，根据传入的对象不一样，执行不一样的操作
class AbstractDrinking {
public:
//煮水
virtual void Boil() = 0;
//冲泡
virtual void Brew() = 0;
//倒入杯中
virtual void PoorInCup() = 0;
//加入辅料
virtual void AddSomething() = 0;
void makeDrink()
{
Boil();
Brew();
PoorInCup();
AddSomething();
}
};
class Coffee : public AbstractDrinking
{
public:
void Boil()
{
cout << "煮冲咖啡的开水" << endl;
}
void Brew()
{
cout << "冲泡咖啡" << endl;
}
void PoorInCup()
{
cout << "咖啡倒入杯中" << endl;
}
void AddSomething()
{
cout << "咖啡加牛奶和糖" << endl;
}
};
class Tea : public AbstractDrinking
{
public:
void Boil()
{
cout << "煮冲茶叶的开水" << endl;
}
void Brew()
{
cout << "冲泡茶叶" << endl;
}
void PoorInCup()
{
cout << "茶倒入杯中" << endl;
}
void AddSomething()
{
cout << "加入柠檬" << endl;
}
};
//制作的函数
//AbstrackDrinking *abs = new Coffee;
void doWork(AbstractDrinking* abs) {
abs->makeDrink();
delete abs;//释放内存，防止堆区内存泄漏
}
void func()
{
cout << "make coffee: " << endl;
doWork(new Coffee);
//AbstractDrinking* makeCoffe;
//makeCoffe = new Coffee;
//makeCoffe->makeDrink();
//delete makeCoffe;
cout << "---------------------------" << endl;
cout << "make tea: " << endl;
//AbstractDrinking* makeTea;
//makeTea = new Tea;
//makeTea->makeDrink();
//delete makeTea;
doWork(new Tea);
}
5. 虚析构和虚纯析构
多态使用时候，如果子类中有属性开辟到堆区，那么父类指针在释放时候无法调用子类的析构代码
(子类没有堆区数据，可以不写虚析构或纯虚析构函数的）
解决方式：
将父类中的析构函数改为虚析构或者纯虚析构
虚析构和纯虚析构的共性：
• 解决父类指针释放时候无法调用子类析构函数的问题
• 都需要有具体的函数实现
虚析构和纯虚析构区别：
• 如果是纯虚析构，该类属于抽象类，无法实例化对象
虚构语法：
virtual ~类名(){}
纯虚析构语法：
virtual ~类名() = 0;
示例：
class Animal {
public:
Animal() {
cout << "Animal的构造函数" << endl;
}
~Animal() {
cout << "Animal的析构函数" << endl;
}
virtual void speak() = 0;
};
class Cat : public Animal {
public:
Cat(string str) {
cout << "Cat的构造函数" << endl;
m_Name = new string(str);
}
~Cat() {
cout << "Cat的析构函数" << endl;
if (m_Name != NULL)
{
delete m_Name;
m_Name = NULL;
}
}
void speak() {
cout << *m_Name << "小猫在说话" << endl;
}
string *m_Name;
};
void func()
{
Animal* a = new Cat("Tom");
a->speak();
delete a;
}
没有调用子类的析构函数
父类指针在析构时候，不会调用子类中的析构函数，导致子类如果有堆区属性，出现内存泄漏
利用虚析构可以解决父类指针释放子类对象不干净的问题
//虚析构
virtual ~Animal() {
cout << "Animal的析构函数" << endl;
}
class Animal{
...
//函数内部声明
virtual ~Animal() = 0;
};
//类外还需要实现的
Animal::~Animal() {
cout << "Animal的纯虚析构" << endl;
}
6.多态案例三 — 电脑组装
案件描述：
电脑主要组成部件为： CPU(用于计算)，显卡(用于显示)，内存条(用于存储)
将每个零件封装出抽象基类，并提供给不同的厂商生产不同的零件，比如Inter和Lenovo
创建电脑类提供让电脑工作的函数，并调用每个零件工作的接口
测试时组装三台不同的电脑工作
//CPU类
class CPU {
public:
virtual void calculator() = 0;
};
//显卡类
class DiaplayCard {
public:
virtual void diaplay() = 0;
};
//内存条类
class Memory {
public:
virtual void storage() = 0;
};
//电脑类
class Computer {
public:
Computer(CPU *c, DiaplayCard *dc, Memory *m) {
m_Cpu = c;
m_Diaplaycard = dc;
m_Memory = m;
}
//电脑工作的函数
void doWork() {
m_Cpu->calculator();
m_Diaplaycard->diaplay();
m_Memory->storage();
}
~Computer()
{
cout << "释放内存" << endl;
if (m_Cpu != NULL)
{
delete m_Cpu;
m_Cpu = NULL;
}
if (m_Diaplaycard != NULL)
{
delete m_Diaplaycard;
m_Diaplaycard = NULL;
}
if (m_Memory != NULL)
{
delete m_Memory;
m_Memory = NULL;
}
}
private:
CPU* m_Cpu;
DiaplayCard* m_Diaplaycard;
Memory* m_Memory;
};
//具体零件商Inter
class InterCPU : public CPU {
public:
//重写虚函数
void calculator() {
cout << "Inter CPU 在计算" << endl;
}
};
class InterDiaplayCard : public DiaplayCard {
public:
void diaplay() {
cout << "Inter 显卡 在显示图像" << endl;
}
};
class InterMem : public Memory {
public:
void storage() {
cout << "Inter 内存 在存储" << endl;
}
};
//Lenovo
class LenovoCPU : public CPU {
public:
void calculator() {
cout << "Lenovo CPU 在计算" << endl;
}
};
class LenovorDiaplayCard : public DiaplayCard {
public:
void diaplay() {
cout << "Lenovo 显卡 在显示图像" << endl;
}
};
class LenovorMem : public Memory {
public:
void storage() {
cout << "Lenovo 内存 在存储" << endl;
}
};
//组装电脑
void func()
{
cout << "第一台电脑： " << endl;
InterCPU* interCPU = new InterCPU;
InterDiaplayCard* interDc = new InterDiaplayCard;
InterMem* interM = new InterMem;
Computer *c1 = new Computer(interCPU, interDc, interM);
c1->doWork();
delete c1;
cout << "------------------------------" << endl;
cout << "第二台电脑： " << endl;
Computer* c2 = new Computer(new LenovoCPU, new LenovorDiaplayCard, new LenovorMem);
c2->doWork();
delete c2;
cout << "------------------------------" << endl;
cout << "第三台电脑： " << endl;
Computer* c3 = new Computer(new LenovoCPU, new InterDiaplayCard, new LenovorMem);
c3->doWork();
delete c3;
}
6726
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
