4.7 多态

拼命奔跑

已于 2023-06-13 17:22:59 修改

阅读量48

点赞数

分类专栏： C++核心编程文章标签： c++ 开发语言

于 2023-06-13 09:43:13 首次发布

本文链接：https://blog.csdn.net/qq_43593204/article/details/131181799

版权

C++核心编程专栏收录该内容

5 篇文章 0 订阅

订阅专栏

4.7.1 多态的基本概念

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

多态分为两类

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

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

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

下面通过案例进行讲解多态

#include<iostream>
using namespace std;
//多态：
//动物类：
class Animal {

public:
	virtual void speak() {
	
	
		cout << "动物在说话" << endl;
	
	}

};
//猫类：
class Cat :public Animal {

public:
	void speak() {
	
	
		cout << "小猫在说话" << endl;

	}


};
//猫类：
class Dog :public Animal {
public:
	//重写  函数返回值的类型  函数名   参数列表 完全相同
	void speak() {
	
	
		cout << "小狗在说话" << endl;
	}



};
//执行说话的函数:
//地址早绑定  在编译阶段确定了函数的地址
//如果想执行让猫说话，那么这个函数就不能提前绑定，需要在运行阶段进行，即地址晚绑定


//满足 动态多态的条件
//1.有继承关系；
//2.子类重写父类的虚函数；

//动态多态使用
//父类的指针或引用  指向子类对象
 void doSpeak(Animal &animal) { //  Animal &animal = cat;

	animal.speak();

}
void test126() { 


	Cat cat;
	doSpeak(cat);
	Dog dog;
	doSpeak(dog);
}
void test1261() {

	cout << "sizeof Animal = " << sizeof(Animal) << endl;


}
int main126() {

	cout<<sizeof(int*)<<endl;
	test1261(); 
	system("pause");
	return 0;
}

总结：

多态满足条件

有继承关系
子类重写父类中的虚函数

多态使用条件

父类指针或引用指向子类对象

重写：函数返回值类型函数名参数列表完全一致称为重写

4.7.2 多态案一-计算器类

案例描述：

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

多态的优点：

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

计算器类

#include<iostream>
using namespace std;

class Calculator {

public:
	int getResult(string oper,int m1,int m2) {
		this->m_Num1 = m1;
		this->m_Num2 = m2;
		if (oper == "+") {
		
			return m_Num1 + m_Num2;
		}
		else if (oper == "-") {
		
			return m_Num1 - m_Num2;
		}
		else if(oper=="*") {
			return m_Num1 * m_Num2;
		
		
		
		}
		else if(oper=="/") {
			return m_Num1 / m_Num2;
		
		}
		//如果想扩展新的功能，需要修改源码：
		//在真实开发中 提倡 开闭原则
		//开闭原则：对扩展进行开放，对修改进行关闭
	
	}
	int m_Num1;
	int m_Num2;



};
void test127() {

	Calculator c1;
	
	cout << c1.getResult("+", 1, 2) << endl;;
	cout << c1.getResult("-", 1, 2) << endl;;
	cout << c1.getResult("*", 1, 2) << endl;;
	cout << c1.getResult("/", 1, 2) << endl;;

}
//利用多态实现计算器：
// 使用多态带来的好处：
// 1.组织结构清晰：
// 
// 
//实现计算器抽象类：
class AbstractCalculator {

public:
	virtual int getResult() {
		return 0;
	
	
	}
	int m_Num1;
	int m_Num2;

};
//加法计算器类：
class AddCalculator :public AbstractCalculator {
public:
	virtual int getResult() {
		return m_Num1 + m_Num2;


	}

};
//减法计算器类：
class SubCalculator :public AbstractCalculator {
public:
	virtual int getResult() {
		return m_Num1 - m_Num2;


	}

};
//乘法计算器类：
class MulCalculator :public AbstractCalculator {
public:
	virtual int getResult() {
		return m_Num1 * m_Num2;


	}

};
void test1271() {
	//多态使用条件：
	//父类指针或引用指向子类对象

	//加法运算
	AbstractCalculator* abc = new AddCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->getResult() << endl;
	//用完记得释放：
	delete abc;
	//减法运算
	abc = new SubCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->getResult() << endl;
	delete abc;
	//乘法运算
	abc = new MulCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->getResult() << endl;
	delete abc;
}
int main127() {
	test1271();

	//test127();

	system("pause");
	return 0;
}

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

4.7.3 纯虚函数和抽象类

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

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

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

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

抽象类特点：

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

#include<iostream>
using namespace std;
class Base128 {

public:
	//纯虚函数：
	//只要有一个纯虚函数，这个类称为抽象类：
	//抽象类特点：
	//1.无法实例化对象
	//2.抽象类的子类  必须要重写父类中的纯虚函数，否则也属于抽象类；
	virtual void func128() = 0;


};
class Son128 :public Base128 {

public:
	void func128() {
	
		cout << "func函数调用" << endl;
	
	}

};
void test128() {

	//Base128 b;  抽象类无法实例化对象；
	//new Base128;抽象类无法实例化对象；

	Base128* base128 = new Son128;
	base128->func128();
}
int main128() {

	test128();

	system("pause");
	return 0;
}

4.7.4 多态案例二-制作饮品

案例描述：

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

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

#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 {

public:
	//煮水：
	virtual void Boil() {
	
	
		cout << "煮农夫山泉" << endl;
	};
	//冲泡
	virtual void Brew() {
	
	
		cout << "冲泡咖啡" << endl;
	

	};
	virtual void PourinCup() {
	
	
		cout << "倒入杯中" << endl;
	};
	virtual void PutSomething() {
	
	
	
		cout << "加入糖" << endl;
	};

};
class Tea :public AbstractDrinking {

public:
	//煮水：
	virtual void Boil() {


		cout << "煮矿泉水" << endl;
	};
	//冲泡
	virtual void Brew() {


		cout << "冲泡茶叶" << endl;


	};
	virtual void PourinCup() {


		cout << "倒入杯中" << endl;
	};
	virtual void PutSomething() {



		cout << "加入柠檬片" << endl;
	};

};
//制作函数：
void doWork(AbstractDrinking * abs) {//AbstractDrinking * abs = new Coffee

	abs->makeDrink();
	delete abs;

}
void test129() {
	//制作咖啡：
	doWork(new Coffee);
	//制作茶叶：
	doWork(new Tea);

}
int main129() {
	test129();

	system("pause");
	return 0;
}

4.7.5 虚析构和纯虚析构

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

解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性：

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

虚析构和纯虚析构区别：

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

虚析构语法：

virtual ~类名(){}

纯虚析构语法：

virtual ~类名() = 0;

类名::~类名(){}

#include<iostream>
using namespace std;
//虚析构和纯虚析构：
class Animal130 {
public:
	Animal130() {
	
	
	
		cout << "Animal的构造调用函数" << endl;
	}
	//利用虚析构可以解决  父类指针释放子类对象时不干净的问题
	//virtual ~Animal130() {



	//	cout << "Animal的虚析构函数" << endl;
	//}
	// 纯虚析构 需要声明也需要实现；
	//有了纯虚析构之后  ，这个类也是属于抽象类，无法实例化对象；
	virtual ~Animal130() = 0;
	//纯虚函数：
	virtual void speak() = 0;



};
Animal130::~Animal130() {



	cout << "Animal纯虚析构函数调用" << endl;
}
class Cat130 :public Animal130 {

public:
	Cat130(string name) {
		cout << "Cat的构造函数调用" << endl;
		 m_Name = new string(name);
	
	}
	void speak() {
	
		cout <<*m_Name<< "小猫在说话" << endl;
	

	}
	~Cat130() {
		if (m_Name != NULL) {
			cout << "cat的析构函数调用" << endl;
			delete m_Name;
			m_Name = NULL;
		}
	
	
	}
	string *m_Name;

};
void test130() {

	Animal130* animal = new Cat130("Tom");
	animal->speak();
	//父类指针在析构时  不会调用子类中的析构，导致子类如果有堆区属性，出现内存泄漏
	delete animal;


}
int main130() {
	test130();
	system("pause");
	return 0;

}

总结：

1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象

2. 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构

3. 拥有纯虚析构函数的类也属于抽象类

4.7.6 多态案例三-电脑组装

案例描述

电脑主要组成部件为 CPU（用于计算），显卡（用于显示），内存条（用于存储）

将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商

创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口

测试时组装三台不同的电脑进行工作

#include<iostream>
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* mem) {
	
	
		m_cpu = cpu;
		m_vc = vc;
		m_mem = mem;
	}
	//提供工作的函数：
	void work() {
		m_cpu->calculate();
		m_vc->display();
		m_mem->storage();
	

	
	}
	//提供析构函数  释放3个电脑的零件
	~Computer() {
	
		//释放CPU零件：
		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厂商
class IntelCpu :public CPU {

public:
	virtual void calculate() {
		cout << "Intel的cpu开始计算了" << endl;
	

	}


};
class IntelVideoCard :public VideoCard {

public:
	virtual void display() {
		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;
	

	}


};
void test131() {

	

	//第一台电脑的零件：

	CPU* intelCpu = new IntelCpu;
	VideoCard* intelCard = new IntelVideoCard;
	Memory * intelMem = new IntelMemory;
	//创建第一台电脑：
	Computer* computer1 = new Computer(intelCpu, intelCard, intelMem);
	computer1->work();
	delete computer1;
}
int main() {

	test131();  

	system("pause");
	return 0;
}

拼命奔跑

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
4.7 多态

将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商。多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码。在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容。利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶。静态多态: 函数重载和运算符重载属于静态多态，复用函数名。创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口。子类必须重写抽象类中的纯虚函数，否则也属于抽象类。
复制链接

扫一扫

专栏目录