黑马教程学习笔记–多态

最新推荐文章于 2022-04-01 17:34:04 发布

几何zzx

最新推荐文章于 2022-04-01 17:34:04 发布

阅读量141

点赞数

文章标签：多态

本文链接：https://blog.csdn.net/weixin_51520361/article/details/116230690

版权

本文通过多个实例详细介绍了C++中的多态特性，包括基本语法、多态计算器、纯虚函数和抽象类的应用。通过动态绑定和抽象类的使用，展示了如何在代码中实现灵活的继承和函数重写，以实现更高效的设计和扩展。同时，文中还探讨了虚析构函数和电脑组装实例，进一步阐述了多态在实际问题解决中的作用。

摘要由CSDN通过智能技术生成

1.多态的基本语法

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

//动物类
class Animal
{
public:
	//虚函数
	virtual void speak()//添加virtual 可以执行子类函数，即小猫在说话
	{
		cout << "动物在说话" << endl;
	}
};


//猫类
class Cat :public Animal
{
public:
	//重写 函数返回值类型 函数名 函数列表 完全相同
	//void speak（）前加不加virtual都可以
	void speak()
	{
		cout << "小猫在说话" << endl;
	}
};

//执行说话的函数
//此时执行结果是动物在说话，因为地址早绑定 在编译阶段确定函数地址（即动物地址）
//如果想执行让猫说话（子类）函数，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定
//即地址晚绑定，在anima类中void speak（）前加virtual

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

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

void test01()
{
	Cat cat;
	doSpeak(cat);
}

int main()
{
	test01();

	system("pause");
	return 0;
}

2.多态计算器实例

#include<iostream>
#include<string>
using namespace std;
//分别利用普通写法和多态技术实现计算器

//普通写法
class Calculator
{
public:
	int getResult(string oper)
	{
		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;//操作数1
	int m_Num2;//操作数2
};

void test01()
{
	//创建计算器对象
	Calculator c;
	c.m_Num1 = 10;
	c.m_Num2 = 10;
	cout << c.m_Num1 << "+" << c.m_Num2 << "=" << c.getResult("+") << endl;
	cout << c.m_Num1 << "-" << c.m_Num2 << "=" << c.getResult("-") << endl;
	cout << c.m_Num1 << "*" << c.m_Num2 << "=" << c.getResult("*") << endl;
}

//利用多态实现计算器

//实现计算器抽象类

class AbstractCalculator
{
public:

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

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


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


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

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

	//本次：利用指针指向子类对象
	//加法运算
	AbstractCalculator *abc = new AddCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult() << endl;
	//用完后记得销毁
	delete abc;
	
	//减法运算
	abc = new SubCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << "-" << abc->m_Num2 << "=" << abc->getResult() << endl;
	//用完后记得销毁
	delete abc;

}
//利用引用指向子类对象
void getresult(AbstractCalculator&abc)
{
	abc.getResult();
}

void test03()
{
	AddCalculator abc;
	abc.m_Num1 = 10;
	abc.m_Num2 = 10;
	cout << abc.getResult() << endl;
}
int main()
{
	//test01();
	//est02();
	test03();
	system("pause");
	return 0;
}

3、纯虚函数和抽象类

#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 s;//子类必须重写父类中的纯虚函数 否则无法实例化对象
	Base *base = new Son;
	base->func();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

4、例子：制作饮品

#include<iostream>
#include<string>
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)
{
	abs->makeDrink();
	delete abs;
}

void test01()
{
	doWork(new Coffee);
	cout << "------------" << endl;
	doWork(new Tea);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

5、虚析构和纯虚析构

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

//虚析构和纯虚析构
class Animal
{
public:
	Animal()
	{
		cout << "Animal 构造函数调用" << endl;
	}
	//利用虚析构可以解决 父类指针释放子类对象时不干净的问题
	/*virtual ~Animal()
	{
		cout << "Animal 析构函数调用" << endl;
	}*/
	//纯虚析构 需要声明也需要实现
	//有了纯虚构之后 这个类 也属于抽象类 无法实例化对象
	virtual ~Animal() = 0;
	//纯虚函数
	virtual void speak() = 0;
};
Animal::~Animal()
{
	cout << "Animal纯虚析构函数调用" << endl;
}

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");
	return 0;
}
//虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
//如果子类中没有堆区数据 可以不写为虚析构或纯虚析构
//拥有纯虚构函数的类也属于抽象类

6、电脑组装实例

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

//抽象不同零件类

//抽象CPU
class CPU
{
public:
	//抽象的计算函数
	virtual void calculate() = 0;
};


//抽象内存条类
class Memory
{
public:
	//抽象的存储函数
	virtual void storage() = 0;
};
//抽象显卡类
class VideoCard
{
public:
	//抽象的计算函数
	virtual void display() = 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()
	{
		//释放内存条零件
		if (m_mem != NULL)
		{
			delete m_mem;
			m_mem = NULL;
		}
		//释放显卡零件
		if (m_vc != NULL)
		{
			delete m_vc;
			m_vc = NULL;
		}
		//释放CPU零件
		if (m_cpu != NULL)
		{
			delete m_cpu;
			m_cpu = NULL;
		}
	}
private:
	CPU * m_cpu;//CPU的零件指针
	VideoCard * m_vc;//显卡零件指针
	Memory * m_mem;//内存条零件指针
};

//具体厂商
//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;
	}
};

//联想厂商
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()
{
	cout << "第一台电脑开始工作：" << endl;
	//第一台电脑零件
	CPU * interCpu = new InterCPU;
	VideoCard*interCard = new InterVideoCard;
	Memory*interMem = new InterMemory;

	//创建第一台电脑
	Computer*computer1 = new Computer(interCpu, interCard, interMem);
	computer1->work();
	delete computer1;

	cout << "第二台电脑开始工作：" << endl;
	//第二台电脑零件
	Computer*computer2 = new Computer(new LenovoCPU, new LenovoVideoCard,new LenovoMemory);
	computer2->work();
	delete computer2;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

几何zzx

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
黑马教程学习笔记–多态

1.多态的基本语法#include<iostream>#include<string>using namespace std;//多态//动物类class Animal{public: //虚函数 virtual void speak()//添加virtual 可以执行子类函数，即小猫在说话 { cout << "动物在说话" << endl; }};//猫类class Cat :public Animal{publ
复制链接

扫一扫