【C++核心编程 4】——类和对象——4.7 多态

最新推荐文章于 2024-07-24 14:05:37 发布

mycsdn3657

最新推荐文章于 2024-07-24 14:05:37 发布

阅读量196

点赞数

分类专栏： C++学习文章标签： c++

本文链接：https://blog.csdn.net/myCSDN3657/article/details/128962237

版权

C++学习专栏收录该内容

25 篇文章 0 订阅

订阅专栏

4.7 多态

4.7.1 多态的基本概念

多态是C++面向对象三大特性之一

多态分为两类：

静态多态：函数重载和运算符重载属于静态多态，复用函数名
动态多态：子类和虚函数实现运行时多态

静态多态和动态多态区别：

静态多态的函数地址早绑定 - 编译阶段确定函数地址
动态多态的函数地址晚绑定 - 运行阶段确定函数地址

地址早绑定 - 编译阶段确定函数地址，执行Animal类中的speak()

#include<iostream>
using namespace std;
//多态
//动物类
class Animal {
public:
	void speak() {
		cout << "动物说话技能" << endl;
	}
};
class Cat :public Animal {
public:
	void speak() {
		cout << "小猫说话：喵喵喵" << endl;
	}
};
//执行说话的函数
//地址早绑定 - 编译阶段确定函数地址，执行Animal类中的speak()
void doSpeak(Animal &animal) {
	animal.speak();
}
void test01() {
	Cat cat;
	doSpeak(cat);//Animal &animal=cat;
  //输出——动物说话技能
}
int main() {
	test01();
	return 0;
}

如果想执行Cat类中的speak()，这个函数地址就不能早绑定，需要地址晚绑定 - 运行阶段确定函数地址

做法：在Animal类中的speak()前加关键字virtual

#include<iostream>
using namespace std;
//多态
//动物类
class Animal {
public:
  //此处加关键字virtual  虚函数
	virtual void speak() {
		cout << "动物说话技能" << endl;
	}
};
class Cat :public Animal {
public:
	void speak() {
		cout << "小猫说话：喵喵喵" << endl;
	}
};
class Dog :public Animal {
public:
	void speak() {
		cout << "小狗说话：汪汪汪" << endl;
	}
//执行说话的函数
//地址早绑定 - 编译阶段确定函数地址，执行Animal类中的speak()
//如果想执行Cat类中的speak()，这个函数地址就不能早绑定，需要地址晚绑定 - 运行阶段确定函数地址
//做法：在Animal类中的speak()前加关键字virtual
  
  //动态多态的使用:父类的指针或者引用 执行子类对象
void doSpeak(Animal &animal) {
	animal.speak();
}

void test01() {
	Cat cat;
	doSpeak(cat);//输出——小猫说话：喵喵喵
  	Dog dog;
	doSpeak(dog);//输出——小狗说话：汪汪汪
}
int main() {
	test01();
	return 0;
}

动态多态满足条件：

有继承关系
子类要重写父类中的虚函数（重写：函数返回值类型函数名参数列表完全相同）

动态多态的使用：

父类的指针或者引用执行子类对象

—–—多态原理剖析

查看开发人员验证工具
在这里插入图片描述

#include<iostream>
using namespace std;
//多态
//动物类
class Animal {
public:
	void speak() {
		cout << "动物说话技能" << endl;
	}
};
void test02() {
	cout << "sizeof Animal=" << sizeof(Animal) << endl;//sizeof Animal=1
}
int main() {
	test02();
	return 0;
}

在这里插入图片描述

#include<iostream>
using namespace std;
//多态
//动物类
class Animal {
public:
	virtual void speak() {
		cout << "动物说话技能" << endl;
	}
};
void test02() {
	cout << "sizeof Animal=" << sizeof(Animal) << endl;//sizeof Animal=8
}
int main() {
	test02();
	return 0;
}

在这里插入图片描述

多态原理
在这里插入图片描述

当子类重写父类的虚函数后，子类中的虚函数表会将原本的 &Animal :: speak 替换成子类的虚函数地址 &Cat :: speak

当父类的指针或者引用指向子类对象时，发生多态

VS工具验证：

子类未进行重写时，vftable中的数据是 &Animal :: speak
在这里插入图片描述

子类进行重写之后，vftable中的数据是 &Cat :: speak
在这里插入图片描述

4.7.2 多态案例——计算器类

案例描述：

分别利用普通写法和多态写法，设计实现两个操作数进行运算的计算器类

多态的优点：

代码组织结构清晰
可读性强
利于前期和后期的扩展以及维护

示例：

普通写法：

#include<iostream>
#include<string>
using namespace std;
//普通写法
class Calculator {
public:
	int getResult(string oper) {
		if (oper == "+") {
			return num1 + num2;
		}else if (oper == "-") {
			return num1 - num2;
		}else if (oper == "*") {
			return num1 * num2;
		}
		//如果想要扩展新的功能，需要修改源码
		//在真实的开发过程中，提倡 开闭原则：对扩展进行开放，对修改进行关闭
	}
	int num1;
	int num2;
};
void test01() {
	Calculator c;
	c.num1 = 10;
	c.num2 = 20;
	cout << c.num1 << "+" << c.num2 << "=" << c.getResult("+") << endl;
	cout << c.num1 << "-" << c.num2 << "=" << c.getResult("-") << endl;
	cout << c.num1 << "*" << c.num2 << "=" << c.getResult("*") << endl;
}
int main() {
	test01();
	return 0;
}

在真实的开发过程中，提倡开闭原则：对扩展进行开放，对修改进行关闭

多态技术：

#include<iostream>
#include<string>
using namespace std;
//多态技术
class AbstractCalculator {
public:
	virtual int getResult() {
		return 0;
	}
	int num1;
	int num2;
};
//加法计算器类
class AddCalculator:public AbstractCalculator {
	int getResult() {
		return num1 + num2;
	}
};
//减法计算器类
class SubCalculator :public AbstractCalculator {
	int getResult() {
		return num1 - num2;
	}
};
//乘法计算器类
class MultiCalculator :public AbstractCalculator {
	int getResult() {
		return num1 * num2;
	}
};
void test01() {
	//多态使用条件：父类指针或者引用指向子类对象
	//加法运算
	AbstractCalculator* abc = new AddCalculator;
	abc->num1 = 10;
	abc->num2 = 20;
	cout << abc->num1 << "+" << abc->num2 << "=" << abc->getResult() << endl;
	//堆区数据用完释放
	delete abc;

	//减法运算
	abc = new SubCalculator;
	abc->num1 = 30;
	abc->num2 = 20;
	cout << abc->num1 << "-" << abc->num2 << "=" << abc->getResult() << endl;
	delete abc;

	//乘法运算
	abc = new MultiCalculator;
	abc->num1 = 20;
	abc->num2 = 20;
	cout << abc->num1 << "*" << abc->num2 << "=" << abc->getResult() << endl;
	delete abc;
}
int main() {
	test01();
	return 0;
}

多态的好处：

组织结构清晰
可读性强
对于前期和后期扩展以及维护性高

C++开发提倡利用多态设计程序架构，因为多态优点很多

4.7.3 纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容

因此，可以将虚函数改为纯虚函数

纯虚函数语法：virtual 返回值类型函数名 (参数列表)=0;

当类中有了纯虚函数，这个类也称为抽象类

抽象类特点：

抽象类无法实例化对象
子类必须重写抽象类中的纯虚函数，否则也属于抽象类

示例：

#include<iostream>
using namespace std;
//纯虚函数
class Base {
public:
	virtual void func() = 0;
};
class Son :public Base {
public:
	void func() {
		cout << "func函数调用" << endl;
	}
};
void test01() {
	//Base b; 抽象类是无法实例化对象
	//new Base;抽象类是无法实例化对象
	Base* b = new Son;
	b->func();
}
int main() {
	test01();
	return 0;
}

4.7.4 多态案例二 - 制作饮品

案例描述：

制作饮品的大致流程为：煮水 - 冲泡 - 倒入杯中 - 加入辅料

利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶

在这里插入图片描述

#include<iostream>
using namespace std;
class AbstractDrink {
public:
	//煮水
	virtual void Boil() = 0;
	//冲泡
	virtual void Brew() = 0;
	//倒入杯中
	virtual void PutIntoCup() = 0;
	//加入辅料
	virtual void AddSomething() = 0;

	void makeDring() {
		Boil();
		Brew();
		PutIntoCup();
		AddSomething();
	}
};
class Coffee :public AbstractDrink {
public:
	virtual void Boil() {
		cout << "加入纯净水烧开" << endl;
	};
	virtual void Brew() {
		cout << "加入香浓咖啡份" << endl;
	};
	virtual void PutIntoCup() { 
		cout << "倒入咖啡杯中" << endl; 
	};
	virtual void AddSomething() { 
		cout << "加入咖啡伴侣" << endl; 
	};
};
class Tea :public AbstractDrink {
public:
	virtual void Boil() {
		cout << "加入纯净水烧开" << endl;
	};
	virtual void Brew() {
		cout << "加入高级茶叶" << endl;
	};
	virtual void PutIntoCup() {
		cout << "倒入青花瓷杯中" << endl;
	};
	virtual void AddSomething() {
		cout << "加入食盐" << endl;
	};

};
void doWork(AbstractDrink* ad) {
	ad->makeDring();
	delete ad;//释放堆区数据
}
void test01() {
	//制作咖啡
	doWork(new Coffee);
	//制作茶
	doWork(new Tea);
}
int main() {
	test01();
	return 0;
}

4.7.5 虚析构和纯虚析构

多态使用时，如果子类中有属性开辟倒堆区，那么父类指针在释放时无法调用倒子类的析构代码

示例：

#include<iostream>
#include<string>
using namespace std;
//虚析构和纯虚析构
class Animal {
public:
	Animal() {
		cout << "Animal构造函数调用" << endl;
	}
	
	~Animal() {
		cout << "Animal析构函数调用" << endl;
	}
	virtual void speak() = 0;
};
class Cat :public Animal {
public:
	Cat(string name) {
		cout << "Cat构造函数调用" << endl;
		m_Name = new string(name);
	}
	void speak() {
		cout <<*m_Name<< "小猫说话喵喵喵" << endl;
	}

	~Cat() {
		if (m_Name != NULL) {
			cout << "Cat析构函数调用" << endl;
			delete m_Name;
			m_Name = NULL;
		}
	}
	string* m_Name;
};
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() {
		cout << "Animal虚析构函数调用" << endl;
	}
	virtual void speak() = 0;
};

在这里插入图片描述

纯虚析构示例：

class Animal {
public:
	Animal() {
		cout << "Animal构造函数调用" << endl;
	}
	
	//纯虚析构  需要声明，也需要实现
	//有了纯虚析构 之后，这个类也属于抽象类，无法实例化对象
	virtual ~Animal() = 0;
	virtual void speak() = 0;
};
//纯虚析构 实现
Animal::~Animal() {
	cout << "Animal纯虚析构函数调用" << endl;
}

虚析构和纯虚析构共性：

都可以解决父类指针释放子类对象
都需要有具体的函数实现

虚析构和纯虚析构区别：

如果是纯虚析构，该类属于抽象类，无法实例化对象

语法：

虚析构语法：virtual ~类名（）{}

纯虚析构语法：virtual ~类名（）=0； 类名::~类名(){}

总结：

虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
如果子类中没有堆区数据，可以不写虚析构或纯虚析构
拥有纯虚析构函数的类也属于抽象类

4.7.6 多态案例三 - 电脑组装

案例描述：

电脑主要组成部件为 CPU（用于计算），显卡（用于显示），内存条（用于存储）
将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Inter厂商和Lenovo厂商
创建电脑类提供让电脑工作的函数，并且调用好每个零件工作的接口
测试时组装三台不同的电脑进行工作

#include<iostream>
#include<string>
using namespace std;
//抽象不同零件类
//抽象CPU类
class CPU {
public:
	//抽象的计算函数
	virtual void calculate() = 0;
};
//抽象显卡类
class VideoCard {
public:
	//抽象的显示函数
	virtual void display() = 0;
};
//抽象内存条类
class Memory {
public:
	//抽象的显示函数
	virtual void storage() = 0;
};

//电脑类
class Computer {
public:
	Computer(CPU* cpu, VideoCard* vc, Memory* me) {
		m_cpu = cpu;
		m_vc = vc;
		m_me = me;
	}
	//提供工作的函数
	void work() {
		m_cpu->calculate();
		m_vc->display();
		m_me->storage();
	}
	//提供析构函数，释放3个电脑零件
	~Computer() {
		if (m_cpu != NULL) {
			delete m_cpu;
			m_cpu = NULL;
		}
		if (m_vc != NULL) {
			delete m_cpu;
			m_vc = NULL;
		}
		if (m_me != NULL) {
			delete m_cpu;
			m_me = NULL;
		}
	}
private:
	CPU* m_cpu;
	VideoCard* m_vc;
	Memory* m_me;
};

//具体厂商
//Inter厂商
class InterCPU :public CPU{
public:
	virtual void calculate() {
		cout << "Inter的CPU开始计算了" << endl;
	}
};
class InterVideoCard :public VideoCard {
public:
	virtual void display() {
		cout << "Inter的显卡开始显示了" << endl;
	}
};
class InterMemory :public Memory {
public:
	virtual void storage() {
		cout << "Inter的内存条开始存储了" << endl;
	}
};
//Lenovo厂商
class LenovoCPU :public CPU {
public:
	virtual void calculate() {
		cout << "Lenovo的CPU开始计算了" << endl;
	}
};
class LenovoVideoCard :public VideoCard {
public:
	virtual void display() {
		cout << "Lenovo的显卡开始显示了" << endl;
	}
};
class LenovoMemory :public Memory {
public:
	virtual void storage() {
		cout << "Lenovo的内存条开始存储了" << endl;
	}
};
void test01() {
	//第一台电脑零件
	CPU *interCPU = new InterCPU;
	VideoCard *interVideoCard = new InterVideoCard;
	Memory *interMemory = new InterMemory;
	//创建第一台电脑
	cout << "第一台电脑:" << endl;
	Computer* cp1 = new Computer(interCPU, interVideoCard, interMemory);
	cp1->work();
	delete cp1;

	//创建第二台电脑
	cout << "第二台电脑:" << endl;
	Computer* cp2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);
	cp2->work();
	delete cp2;

	//创建第三台电脑
	cout << "第三台电脑:" << endl;
	Computer* cp3 = new Computer(new LenovoCPU, new InterVideoCard, new LenovoMemory);
	cp3->work();
	delete cp3;
}
int main() {
	test01();
	return 0;
}