【C++】类和对象-多态
目录
一、多态的基本概念
1、静态多态
2、动态多态
二、多态的原理剖析
三、多态案例 —— 计算器类
四、纯虚函数和抽象类
五、虚析构和纯虚析构
1、虚析构
2、纯虚析构
六、多态案例 —— 组装电脑
一、多态的基本概念
多态是C++面向对象三大特性之一
-
两类多态
- 静态多态：函数重载和运算符重载（复用函数名）
- 动态多态：派生类和虚函数实现运行时多态
-
静态和动态的多态区别：
- 静态多态的函数地址早绑定，编译阶段确定函数地址
- 动态多态的函数地址晚绑定，运行阶段确定函数地址
1、静态多态
测试代码：
#include
using namespace std;
class Person1
{
public:
void print(){
cout << "Person1" << endl;
}
};
class Person2 :public Person1
{
public:
void print(){
cout << "Person2" << endl;
}
};
void myPrint(Person1& p1){
p1.print();
}
int main(){
Person2 p2;
myPrint(p2); // 父类引用接受子类对象
system("pause");
return 0;
}
运行结果：
地址早绑定，编译阶段就确定了地址，无论传入的是子类的什么引用，调用的都是父类的函数。
-
想要调用子类的函数就要地址晚绑定（动态多态）
2、动态多态
在父类的函数前加关键字 virtual 让函数成为虚函数
测试代码：
#include
using namespace std;
class Person1 {
public:
// 虚函数
virtual void print() {
cout << "Person1" << endl;
}
};
class Person2 :public Person1 {
public:
void print() {
cout << "Person2" << endl;
}
};
void myPrint(Person1& p1) {
p1.print();
}
int main() {
Person2 p2;
myPrint(p2);
system("pause");
return 0;
}
运行结果：
根据传入对象执行类的函数，print() 函数不能提早确定。
-
动态多态满足条件
1、有继承关系
2、子类重写父类虚函数
（重写需要函数完全一致，参数列表，返回值，函数名，子类 virtual 可以写也可以不写）
二、多态的原理剖析
计算类中含有虚函数所占的空间大小
64bit 指针大小 8 字节
vs 开发者命令提示符工具，当子类继承父类虚函数
三、多态案例 —— 计算器类
描述：
利用多态技术，设计实现两个操作数进行运算的计算器类-
多态的优点
- 代码组织结构清晰
- 可读性强
- 利于前期和后期的拓展以及维护
-
实际开发中提倡 开闭原则
开闭原则：对拓展进行开放，对修改进行关闭
测试代码：
#include
using namespace std;
// 实现计算器抽象类
class AbstractCalculator {
public:
virtual int getResult(){
return 0;
}
int m_Num1;
int m_Num2;
};
// 乘法类
class MulCalculator :public AbstractCalculator{
public:
virtual int getResult(){
return m_Num1 * m_Num2;
}
};
// 加法类
class AddCalculator :public AbstractCalculator{
public:
virtual int getResult(){
return m_Num1 + m_Num2;
}
};
//
// 可继续添加
void test(){
AbstractCalculator* abc = new AddCalculator;
abc->m_Num1 = 10;
abc->m_Num2 = 10;
cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
}
int main(){
test();
system("pause");
return 0;
} 运行结果：
四、纯虚函数和抽象类
在多态中，通常父类中虚函数的实现是无意义的，主要都是调用子类重写的内容
-
因此可以将虚函数改为纯虚函数
-
纯虚函数语法：virtual 返回值类型 函数名（参数列表）= 0；
-
当类中有纯虚函数（父类），这个类称为 抽象类
-
抽象类特点：
- 无法实例化对象
- 子类必须重写抽象类中的纯虚函数，否则也属于抽象函数
测试代码：
#include
using namespace std;
// 抽象类
class Base{
public:
// 纯虚函数
virtual void func() = 0;
};
class Son1 :public Base{
public:
// 重写父类虚函数
virtual void func()
{
cout << "Son1::func 函数调用" << endl;
}
};
class Son2 :public Base
{
public:
// 重写父类虚函数
virtual void func()
{
cout << "Son2::func 函数调用" << endl;
}
};
void test()
{
// 通过父类指针调用不同子类的函数
Base* base1 = new Son1;
base1->func();
Base* base2 = new Son2;
base2->func();
}
int main(){
test();
system("pause");
return 0;
} 运行结果：
五、虚析构和纯虚析构
多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用子类的析构代码
-
解决方法：将父类中的析构函数改为虚析构或者纯虚析构
-
虚析构和纯虚析构共性：
- 解决父类指针释放子类对象
- 都要有具体函数实现
虚析构和纯虚析构区别：
- 类中有纯虚析构，该类属于抽象类，无法实例化
-
虚析构语法：virtual ~类名() { } ;
纯虚析构语法：virtual ~类名() { } = 0;
问题：父类指针在析构时候不会调用子类中的析构函数，导致子类如果有堆区属性，就会出现内存泄漏
1、虚析构
测试代码：
#include
#include
using namespace std;
class Person1 {
public:
// 构造
Person1() {
cout << "父类 构造函数调用" << endl;
}
// 纯虚函数
virtual void Print() = 0;
// 析构
~Person1() {
cout << "父类 析构函数调用" << endl;
}
};
class Person2 :public Person1 {
public:
// 构造
Person2(string name) {
cout << "子类 构造函数调用" << endl;
m_Name = new string(name);
}
// 重写
virtual void Print() {
cout << *m_Name << " 子类 中 Print" << endl;
}
// 析构函数释放堆区数据
~Person2() {
if (m_Name != NULL) {
cout << "子类 析构函数调用" << endl;
delete m_Name;
m_Name = NULL;
}
}
string* m_Name;
};
void test() {
// 父类指针指向子类对象，开辟堆区数据
Person1* p1 = new Person2("lihua");
p1->Print();
// 释放堆区数据
delete p1;
}
int main(){
test();
system("pause");
return 0;
} 运行结果：
修改：将父类的析构变成虚析构
2、纯虚析构
virtual ~Person1() = 0;如果纯虚析构只有声明会产生一个无法解析外部命令的错误（链接阶段的错误）
需要代码实现
class Person1 {
public:
// 纯虚析构
virtual ~Person1() = 0;
};
// 纯虚析构带代码实现
Person1::~Person1() {
cout << "Person1 下的纯虚析构函数" << endl;
}
类中含有纯虚函数这个类变为抽象类，无法实例化
六、多态案例 —— 组装电脑
代码：
#include
using namespace std;
// cpu 抽象类
class CPU{
public:
// cpu计算纯虚函数
virtual void calculator() = 0;
};
// gpu抽象类
class GPU{
public:
// gpu显示纯虚函数
virtual void display() = 0;
};
// 内存抽象类
class MEM{
public:
// memory存储纯虚函数
virtual void sterage() = 0;
};
// 继承 CPU 的子类，重写父类纯虚函数
class Intel_CPU :public CPU{
public:
// 重写
virtual void calculator(){
cout << "Inter_CPU" << endl;
}
};
// 继承 GPU 的子类，重写父类纯虚函数
class Intel_GPU :public GPU{
public:
// 重写
virtual void display(){
cout << "Inter_GPU" << endl;
}
};
// 继承 MEM 的子类，重写父类纯虚函数
class Intel_MEM :public MEM{
public:
// 重写
virtual void sterage(){
cout << "Inter_MEM" << endl;
}
};
class AMD_CPU :public CPU{
public:
// 重写
virtual void calculator(){
cout << "AMD_CPU" << endl;
}
};
class AMD_GPU :public GPU{
public:
// 重写
virtual void dispaly(){
cout << "AMD_GPU" << endl;
}
};
class AMD_MEM :public MEM
{
public:
// 重写
virtual void sterage(){
cout << "AMD_MEM" << endl;
}
};
// computer类
class Computer
{
public:
// 构造
Computer(CPU* cpu, GPU* gpu, MEM* mem){
m_cpu = cpu;
m_gpu = gpu;
m_mem = mem;
}
// 拼装函数
void work(){
m_cpu->calculator();
m_gpu->display();
m_mem->sterage();
}
// 析构
~Computer(){
if (m_cpu != NULL) {
delete m_cpu;
m_cpu = NULL;
}
if (m_gpu != NULL) {
delete m_gpu;
m_gpu = NULL;
}
if (m_mem != NULL) {
delete m_mem;
m_mem = NULL;
}
}
private:
CPU* m_cpu;
GPU* m_gpu;
MEM* m_mem;
};
void test(){
// 堆区创建配件
CPU* IntelCPU = new Intel_CPU;
GPU* IntelGPU = new Intel_GPU;
MEM* AMDMEM = new AMD_MEM;
// 实例化 Computer类 对象，传入指针
Computer* computer = new Computer(IntelCPU, IntelGPU, AMDMEM);
// 调用对象成员函数 - 拼装函数
computer->work();
// 销毁堆区数据
delete computer;
}
int main()
{
test();
system("pause");
return 0;
}