2021-8-6 C++进阶学习 -＞ 4.7多态

最新推荐文章于 2024-07-12 10:45:15 发布

ice_cream_moon

最新推荐文章于 2024-07-12 10:45:15 发布

阅读量182

点赞数

分类专栏： C++实践文章标签： c++

本文链接：https://blog.csdn.net/ice_cream_moon/article/details/119429791

版权

C++实践专栏收录该内容

28 篇文章 1 订阅

订阅专栏

4.7.1多态的基本概念

地址早绑定在编译阶段就确定了函数的地址
如果想执行让猫说话，这个函数的地址就不能早绑定，需要在函数运行阶段绑定

动态多态满足关系
1、有继承关系
2、子类要重写父类中的虚函数

动态多态使用
父类指针或者引用执行子类对象

#include <iostream>
#include <string>
using namespace std;
//多态

//动物类

class animal
{
public:
	//虚函数
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};
//狗类
class dog :public animal
{
public:
	void speak()
	{
		cout << "小狗在说话" << endl;
	}
};
//猫类
class cat:public animal
{
public:
	//重写 函数返回值 函数名 参数列表 完全相同
	void speak()
	{
		cout << "小猫在说话" << endl;
	}
};

//执行说话的函数

//地址早绑定 在编译阶段就确定了函数的地址
//如果想执行让猫说话，这个函数的地址就不能早绑定，需要在函数运行阶段绑定

//动态多态满足关系
//1、有继承关系
//2、子类要重写父类中的虚函数

//动态多态使用
//父类指针或者引用 执行子类对象
void dospeak(animal &animal)
{
	animal.speak();
}

void test01()
{
	cat cat;
	dospeak(cat);

	dog dog;
	dospeak(dog);
}
int main() {
	test01();

	system("pause");
}

4.7.2多态案例一 --计算机类

多态的优点
1、代码组织结构清晰
2、可读性强
3、利于前期和后期的维护

#include <iostream>
#include <string>
using namespace std;

//多态的优点
//1、代码组织结构清晰
//2、可读性强
//3、利于前期和后期的维护

class Calculator
{
public:
	virtual int Getresult()
	{
		return 0;
	}
	int m_Num1;
	int m_Num2;
};
//加法
class AddCalculator : public Calculator
{
public:
	int Getresult()
	{
		return m_Num2 + m_Num1;
	}

};

//减法
class SubCalculator : public Calculator
{
public:
	int Getresult()
	{
		return m_Num1-  m_Num2;
	}

};

//乘法
class MulCalculator : public Calculator
{
public:
	int Getresult()
	{
		return m_Num1 * m_Num2;
	}

};

void test01()
{
	Calculator *abc = new AddCalculator;
	abc->m_Num1 = 100;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << "+" << abc->m_Num2 << " = " << abc->Getresult() << endl;;
	delete abc;

	abc = new SubCalculator; 
	abc->m_Num1 = 100;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << "-" << abc->m_Num2 << " = " << abc->Getresult() << endl;;
	delete abc;

	abc = new MulCalculator;
	abc->m_Num1 = 100;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << "*" << abc->m_Num2 << " = " << abc->Getresult() << endl;;
	delete abc;
}
int main() {

	test01();
	system("pause");
}

4.7.3纯虚函数和抽象类

纯虚函数
   只要有一个纯虚函数这个类就称为抽象类
   抽象类特点：
   1、无法实例化对象
   2、抽象类的子类必须重写父类中的纯虚函数否则也属于抽象类

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

#include <iostream>
#include <string>
using namespace std;

//纯虚函数和抽象类
class Base
{
public:

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

class son:public Base
{
public:
	virtual void func() {
		cout << "func函数调用" << endl;
	}

};
void test01()
{
	//Base b;//抽象类无法实例化对象
	//new Base;//抽象类无法实例化对象

	son b;//子类必须重写父类中的纯虚函数，否则无法实例化对象
	Base *base = new son;
	base->func();
	delete base;
}
int main() {

	test01();
	system("pause");
}

4.7.4多态案例二--制作饮品

#include <iostream>
#include <string>
using namespace std;

//多态案例2 制作饮品
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)
{
	abs->makeDrink();
	delete abs;//释放内存
}

void test01()
{
	//制作咖啡
	dowork(new Coffee);
	cout << "-----------------------------------" << endl;

	//制作茶叶
	dowork(new Tea);

}
int main() {

	test01();
	system("pause");
}

4.7.5虚析构和纯虚析构

纯虚析构需要声明也需要实现
有了纯虚析构之后这个类也属于抽象类无法实现实例化对象

父类指针在析构时候不会调用子类中析构函数导致子类如果有堆区属性出现内存泄露的情况

#include <iostream>
#include <string>
using namespace std;

//虚析构和纯虚析构

class Animal 
{
public:
	Animal()
	{
		cout << "Animal的构造函数调用" << endl;
	}
	virtual void speak() = 0;
	//virtual ~Animal()
	//{
	//	cout << "Animal的析构函数调用" << endl;
	//}

	//纯虚析构 需要声明也需要实现
	//有了纯虚析构之后 这个类也属于抽象类 无法实现实例化对象
	virtual ~Animal() = 0;
};
Animal::~Animal()
{

}


class Cat : public Animal
{
public:
	Cat(string name)
	{
		cout << "Cat的构造函数调用" << endl;
		m_Name = new string(name);
	}
	virtual 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();
	system("pause");
}

4.7.6多态案例三--电脑组装

#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 *mem)
	{
		m_cpu = cpu;
		m_vc = vc;
		m_mem = mem;

	}
	//提供工作函数
	void work()
	{
		m_cpu->calculate();

		m_vc->display();
		
		m_mem->storage();
	}
	~Computer()
	{
		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;
	VideoCard *m_vc;
	Memory * m_mem;

	
};

//具体厂商
//inter厂商
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 display()
	{
		cout << "Lenovo的显卡开始显示了" << endl;
	}
};

class LenovoMemory :public Memory
{
public:
	virtual void storage()
	{
		cout << "Lenovo的内存条开始存储了" << endl;
	}
};

void test01()
{
	//第一台电脑零件
	CPU *intelCpu = new IntelCPU;
	VideoCard * intelCard = new IntelVideoCard;
	Memory*intelMem = new IntelMemory;

	//创建第一台电脑
	cout << "第一台电脑开始工作" << endl;
	Computer *computer1 = new Computer(intelCpu, intelCard, intelMem);
	computer1->work();
	delete computer1;

	cout << "----------------------------------------------" << endl;
	cout << "第二台电脑开始工作" << endl;
	//创建第二台电脑
	Computer *computer2 = new Computer(new LenovoCPU, new  LenovoVideoCard, new  LenovoMemory);
	computer2->work();
	delete computer2;

	cout << "----------------------------------------------" << endl;
	cout << "第三台电脑开始工作" << endl;
	//创建第三台电脑
	Computer *computer3 = new Computer(new LenovoCPU, new  IntelVideoCard, new  IntelMemory);
	computer3->work();
	delete computer3;
}
int main() {

	test01();
	system("pause");
}

ice_cream_moon

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2021-8-6 C++进阶学习 -＞ 4.7多态

目录4.7.1多态的基本概念4.7.2多态案例一 --计算机类4.7.3纯虚函数和抽象类4.7.4多态案例二--制作饮品4.7.5虚析构和纯虚析构4.7.6多态案例三--电脑组装4.7.1多态的基本概念4.7.2多态案例一 --计算机类4.7.3纯虚函数和抽象类4.7.4多态案例二--制作饮品4.7.5虚析构和纯虚析构4.7.6多态案例三--电脑组装...
复制链接

扫一扫