多态的基本语法
多态分为两类：
- 静态多态：函数重载和运算符重载属于静态多态，复用函数名
- 动态多态：派生类和虚函数实现运行时多态
静态多态和动态多态区别：
- 静态多态的函数地址早绑定：编译阶段确定函数地址
- 动态多态的函数地址晚绑定：运行阶段确定函数地址
动态多态满足条件：
- 有继承关系
- 子类要重写父类的虚函数
- 使用父类的指针或引用，执行子类对象
重写不同于函数重载：
- 函数返回值类型、函数名、参数列表完全相同
C++中父子之间的类型转换不需要做强制类型转换，父类的指针或引用可以直接指向子类对象
class A
{
public:
//虚函数
virtual void test()
{
cout << "A" << endl;
}
};
class B :public A
{
public:
void test()
{
cout << "B" << endl;
}
};
void test(A& a)
{
a.test();
}
int main()
{
B b;
test(b);//A & a = b;
return 0;
}多态的原理剖析
class A size(8):
+---
0 | {vfptr}
+---
A::$vftable@:
| &A_meta
| 0
0 | &A::test
class B size(8):
+---
0 | +--- (base class A)
0 | | {vfptr}
| +---
+---
B::$vftable@:
| &B_meta
| 0
0 | &B::testvfptr虚函数（表）指针：
- v-virtual
- f-function
- ptr-pointer
指向vftable虚函数表
- 表内记录虚函数地址
&A::test
- 表内记录虚函数地址
当子类重写父类虚函数，子类中的虚函数表，内部会替换成子类的虚函数地址
多态案例-计算器类
案例描述：分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类。
多态的优点：
- 代码组织结构清晰
- 可读性强
- 利于前期和后期的扩展和维护
在真实开发中，提倡开闭原则：
- 对拓展进行开放
- 对修改进行关闭
#include <iostream>
using namespace std;
//实现计算器抽象类
class Abstract
{
public:
virtual int result()
{
return 0;
}
int m_num1;
int m_num2;
};
//实现计算器加法类
class add :public Abstract
{
public:
virtual int result()
{
return m_num1 + m_num2;
}
};
//实现减法类
class subtraction :public Abstract
{
public:
virtual int result()
{
return m_num1 - m_num2;
}
};
int main()
{
//父类指针指向子类对象
Abstract* a = new add;
a->m_num1 = 10;
a->m_num2 = 10;
cout << a->result() << endl;
//用完记得销毁
delete a;
//a不需要再定义和初始化
a = new subtraction;
a->m_num1 = 10;
a->m_num2 = 10;
cout << a->result() << endl;
return 0;
}纯虚函数和抽象类
在多态中，通常父类中的虚函数实现是毫无意义的，主要都是调用子类重写的内容
因此可以将虚函数改为纯虚函数
纯虚函数语法：virtual 返回值类型 函数名(参数列表) = 0;
当类中有了纯虚函数，这个类也称为抽象类，特点：
- 无法实例化对象
- 子类必须重写抽象类中的纯虚函数，否则也属于抽象类
抽象类特点：
- 无法实例化对象
- 子类必须重写抽象类中的纯虚函数，否则也属于抽象类
#include <iostream>
using namespace std;
class AbstractDrinking
{
public:
virtual void Boil() = 0;//煮水
virtual void Brew() = 0;//冲泡
virtual void PourInCup() = 0;//倒入杯中
virtual void PutSomeThing() = 0;//添加佐料
void MakeDrink()//制作饮品
{
Boil();
Brew();
PourInCup();
PutSomeThing();
}
};
class Coffee :public AbstractDrinking
{
virtual void Boil()
{
cout << "煮矿泉水" << endl;
}
virtual void Brew()
{
cout << "冲泡咖啡" << endl;
}
virtual void PourInCup()
{
cout << "倒入杯中" << endl;
}
virtual void PutSomeThing()
{
cout << "添加牛奶" << endl;
}
};
class Tea :public AbstractDrinking
{
virtual void Boil()
{
cout << "煮矿泉水" << endl;
}
virtual void Brew()
{
cout << "冲泡茶叶" << endl;
}
virtual void PourInCup()
{
cout << "倒入杯中" << endl;
}
virtual void PutSomeThing()
{
cout << "添加枸杞" << endl;
}
};
void dowork(AbstractDrinking *a)
{
a->MakeDrink();
delete a;
}
int main()
{
AbstractDrinking* a = new Tea;
dowork(a);
return 0;
}虚析构和纯虚析构
多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
解决方法：将父类中的析构函数改为虚析构或者纯虚析构
虚析构和纯虚析构共性：
- 可以解决父类指针释放子类对象
- 都需要有具体的函数实现
虚析构和纯虚析构区别：
- 如果是纯虚析构，该类属于抽象类，无法实例化对象
虚析构语法：virtual ~类名() {};
纯虚析构语法：virtual ~类名() = 0;
总结：
- 虚析构和纯虚析构是用来解决通过父类指针释放子类对象
- 如果子类中没有堆区数据，可以不写为虚析构和纯虚析构
- 拥有纯虚析构的类也属于抽象类
#include <iostream>
using namespace std;
class A
{
public:
A()
{
m_name = new string("A");
}
virtual void speak()
{
cout << *m_name << endl;
}
//利用虚析构可以解决父类指针释放子类对象时不干净的问题
virtual ~A()
{
if (m_name != NULL)
{
cout << "A析构" << endl;
delete m_name;
m_name = NULL;
}
}
string* m_name;
};
class B :public A
{
public:
B()
{
m_name = new string("B");
}
virtual ~B()
{
if (m_name != NULL)
{
cout << "B析构" << endl;
delete m_name;
m_name = NULL;
}
}
};
int main()
{
A* a = new B;//先构造父类再构造子类
a->speak();
//父类指针在析构时，不会调用子类中析构函数，导致子类如果有堆区属性，会导致内存泄露
delete a;
return 0;
}#include <iostream>
using namespace std;
class A
{
public:
A()
{
m_name = new string("A");
}
virtual void speak()
{
cout << *m_name << endl;
}
//纯虚析构声明
//有了纯虚析构后，这个类也属于抽象类，无法实例化对象
virtual ~A() = 0;
string* m_name;
};
class B :public A
{
public:
B()
{
m_name = new string("B");
}
virtual ~B()
{
if (m_name != NULL)
{
cout << "B析构" << endl;
delete m_name;
m_name = NULL;
}
}
};
//纯虚析构实现
A::~A()
{
cout << "A纯虚析构" << endl;
}
int main()
{
A* a = new B;//先构造父类再构造子类
a->speak();
//父类指针在析构时，不会调用子类中析构函数，导致子类如果有堆区属性，会导致内存泄露
delete a;
return 0;
}多态案例-电脑组装
案例描述：
- 电脑主要组成部件为CPU、显卡、内存条
- 将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件
- 创建电脑类提供让电脑工作的函数，并且调用每个函数工作的接口
- 测试时组装三台不同的电脑进行工作
#include <iostream>
using namespace std;
//抽象不同零件类
//抽象CPU类
class CPU
{
public:
//抽象的计算函数
virtual void calculate() = 0;
};
//抽象显卡类
class VideoCard
{
public:
//抽象的显示函数
virtual void dispaly() = 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;
}
//提供析构函数，释放电脑的三个零件
~Computer()
{
if (m_cpu != NULL)
{
delete m_cpu;
m_cpu = NULL;
}
if (m_vc != NULL)
{
delete m_cpu;
m_vc = NULL;
}
if (m_mem != NULL)
{
delete m_cpu;
m_mem = NULL;
}
}
//提供工作函数
void work()
{
//让零件工作起来，调用接口
m_cpu->calculate();
m_vc->dispaly();
m_mem->storage();
}
private:
CPU* m_cpu;//CPU的零件指针
VideoCard* m_vc;//显卡的零件指针
Memory* m_mem;//内存条的零件指针
};
//具体厂商：Intel
class IntelCPU :public CPU
{
public:
virtual void calculate()
{
cout << "Intel的CPU开始计算了" << endl;
}
};
class IntelVideoCard :public VideoCard
{
public:
virtual void dispaly()
{
cout << "Intel的显卡开始显示了" << endl;
}
};
class IntelMemory :public Memory
{
public:
virtual void storage()
{
cout << "Intel的内存开始存储了" << endl;
}
};
//具体厂商：Lenovo
class LenovoCPU :public CPU
{
public:
virtual void calculate()
{
cout << "Lenovo的CPU开始计算了" << endl;
}
};
class LenovoVideoCard :public VideoCard
{
public:
virtual void dispaly()
{
cout << "Lenovo的显卡开始显示了" << endl;
}
};
class LenovoMemory :public Memory
{
public:
virtual void storage()
{
cout << "Lenovo的内存开始存储了" << endl;
}
};
int main()
{
//电脑零件
CPU* intelcpu = new IntelCPU;
VideoCard* intervc = new IntelVideoCard;
Memory* intermem = new IntelMemory;
//创建第一台电脑
Computer* computer1 = new Computer(intelcpu, intervc, intermem);
computer1->work();
delete computer1;
//创建第二台电脑
Computer* computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);
computer2->work();
delete computer2;
//创建第三台电脑
Computer* computer3 = new Computer(new LenovoCPU, new IntelVideoCard, new LenovoMemory);
computer3->work();
delete computer3;
return 0;
}
