C++学习笔记day--17多态

最新推荐文章于 2024-04-30 16:41:40 发布
最新推荐文章于 2024-04-30 16:41:40 发布
阅读量211 收藏
点赞数
分类专栏： C++ 文章标签： 多态 抽象类 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41704516/article/details/107954354
版权

1、多态的基本概念

#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 = act;
{
	animal.speak();
}
void test01()
{
	Cat cat;
	doSpeak(cat);

	Dog dog;
	doSpeak(dog);
}
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;
	int m_Num2;
};

void test01()
{
	Calculator c;
	c.m_Num1 = 20;
	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;
	
}

//利用多态实现计算器
//多态好处：
//1、组织结构清晰
//2、可读性强
//3、对于前期和后期以及维护性强
//实现计算器基类
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;
	}
};
//class DeCalculator :public AbstractCalculator
//{
//public:
//	int getResult()
//	{
//		if (m_Num2 == 0)
//		{
//			return NULL;
//		}
//		else
//		{
//			
//			return m_Num1 / m_Num2;
//			
//		}
//	}
//};
void test02()
{

	//多态使用条件
	//父类指针或者引用指向子类对象
	AbstractCalculator *abc = new AddCalculator;
	abc->m_Num1 = 100;
	abc->m_Num2 = 20;
	cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult() << endl;
	//用完后记得销毁
	delete abc;
	//减法运算
	abc = new SubCalculator;
	abc->m_Num1 = 100;
	abc->m_Num2 = 20;
	cout << abc->m_Num1 << "-" << abc->m_Num2 << "=" << abc->getResult() << endl;
	//用完后记得销毁
	delete abc;

	//乘法运算
	abc = new MulCalculator;
	abc->m_Num1 = 100;
	abc->m_Num2 = 20;
	cout << abc->m_Num1 << "*" << abc->m_Num2 << "=" << abc->getResult() << endl;
	//用完后记得销毁
	delete abc;
	//abc = new DeCalculator;
	//abc->m_Num1 = 100;
	//abc->m_Num2 = 0;
	//cout << abc->m_Num1 << "/" << abc->m_Num2 << "=" << abc->getResult() << endl;
	用完后记得销毁
	//delete abc;
};

int main()
{
	test02();
	system("pause");
	return 0;
}

3、纯虚函数和抽象类

#include<iostream>
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、多态案例2-制作饮品

#include<iostream>
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
{
	//煮水
	virtual void Boil()
	{
		cout << "煮农夫山泉" << endl;
	}

	//冲泡
	virtual void Brew()
	{
		cout << "冲泡咖啡" << endl;
	}

	//倒入杯中
	virtual void PourInCup()
	{
		cout << "导入杯中" << endl;

	}

	//加入辅料
	virtual void PutSomething()
	{
		cout << "加入糖和牛奶" << endl;
	}

};

//制作茶叶
class Tea :public AbstractDrinking
{
	//煮水
	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;

//虚析构和纯虚析构
//1、虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
//2、如果子类中没有堆区数据，可以不写为虚析构或纯虚析构
//3、拥有纯虚析构函数的类也属于抽象类
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);
	}
	~Cat()
	{
		if (m_Name != NULL)
		{
			cout << "Cat析构函数调用" << endl;
			delete m_Name;
			m_Name = NULL;
		}
	}
	virtual void speak()
	{
		cout<<*m_Name << "小猫在说话" << endl;
	}
	string *m_Name;
};

void test01()
{
	Animal*animal = new Cat("Tom");
	animal->speak();
	//父类指针在析构时候 不会调用子类中析构函数 导致子类中如果有堆区属性，出现泄漏
	delete animal;
}
int main()
{
	test01();
	system("pause");
	return 0;

 }

6、多态案例3-配电脑

#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_cpu;
			m_vc = NULL;
		}
		//释放内存条零件
		if (m_mem != NULL)
		{
			delete m_cpu;
			m_mem = NULL;
		}
	}

private:
	CPU *m_cpu;
	VideoCard *m_vc;
	Memory *m_mem;
};

//具体厂商
//Intel厂商
class IntelCPU :public CPU
{

public:
	virtual void calculate()
	{
		cout << "Interl的CPU开始计算了！" << endl;
	}
};
class IntelVideoCard :public VideoCard
{

public:
	virtual void display()
	{
		cout << "Interl的显卡开始显示了！" << endl;
	}
};
class IntelMemory :public Memory
{

public:
	virtual void storage()
	{
		cout << "Interl的内存条开始存储了！" << 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 LenovoMemory);
	computer3->work();
	delete computer3;



}

int main()
{
	test01();
	system("pause");
	return 0;
}
不将就w
关注
专栏目录
C++学习笔记-多态
漫夜星辰
07-06 296
多态
c++学习笔记五(多态)
qq_41827817的博客
02-21 116
#include <iostream> using namespace std; class Father{ public: virtual void Func(){ cout << "Father::Func()" << endl; } }; class Son:public Father{ //覆...
cpp多态
06-23
cpp 多态
Cpp_多态
Jerry的专栏
02-29 2614
一、虚函数、覆盖和多态如果将基类中的某个成员函数声明为虚函数，那么其子类中与该函数具有相同原型的成员函数就也是虚函数，并且对基类中的版本形成覆盖。这时，通过指向子类对象的基类指针，或者引用子类对象的基类引用，调用虚函数，实际被执行的将是子类中的覆盖版本，而非基类中的原始版本，这种语法现象被称为多态。二、虚函数覆盖的条件1.只有类的成员函数才能被声明为虚函数，全局函数和类的静态成员函数都不能被声明为虚
多态_cpp
apt1203JN的博客
11-11 467
一、什么是多态？ 1.多态的概念 在面向对象方法：向不同的对象发送同一个消息，不同的对象在接收的时会产生不同的行为（即方法） 在C++中，多态性的表现形式之一：具有不同功能的函数可用同一个函数名，这样就可以实现用一个函数名调不同内容的函数。 用现实生活中的例子来说一下动态，比如说：学校开学，不同身份的人会有不同的反应。比如老师要备课上课
C++的多态.cpp
东哥的博客
01-05 275
/*多态包括模板/重载和虚函数 *其中模板和重载属于静态多态虚函数属于动态多态 */# include using namespace std;//定义模板类template class Base {public: Base():x_(0){}; Base(T n):x_(n){};    ~Base(){ cout }; virtual T Get() { //虚函数，当基类指针指向派生
CPP-基础：关于多态
dixiongbi7761的博客
08-14 218
类的多态特性是支持面向对象的语言最主要的特性，有过非面向对象语言开发经历的人，通常对这一章节的内容会觉得不习惯，因为很多人错误的认为，支持类的封装的语言就是支持面向对象的，其实不然，Visual BASIC 6.0 是典型的非面向对象的开发语言，但是它的确是支持类，支持类并不能说明就是支持面向对象，能够解决多态问题的语言，才是真正支持面向对象的开发的语言，所以务必提醒有过其它非面...
[学习笔记]c++基础-day01
x_0711的博客
08-05 162
目录 1、面向对象程序设计： 1.1概述：对象、类、消息传递、方法 1.2基本特征： 1.3语言:c#、java、c++ 2、c++基本语法 2.1编写一个hello world程序 2.2单行注释和多行注释 2.3变量（c++中所有数据都存放在内存中） 2.4常量：用于记录程序中不可更改的数据 2.5关键字： 2.6标识符命名规则 3、数据类型 3.1整型： 3.2浮点型（表示小数） 3.3转义字符: 3.4字符型：单个字符 ’’，只占用一个字符 3.5字符串型：一串字符
100-day-code
03-31
在"100-day-code-master"这个压缩包中，很可能包含了项目的所有源代码、笔记、教程和练习。 C++是一种多范式编程语言，它支持过程化编程、面向对象编程和泛型编程。以下是一些你在"100-day-code"中可能会遇到的关键...
Python100Days学习笔记---Day8面向对象编程基础
迷途可达C的博客
03-30 317
面向对象编程基础 活在当下的程序员应该都听过"面向对象编程"一词，也经常有人问能不能用一句话解释下什么是"面向对象编程"，我们先来看看比较正式的说法。 “把一组数据结构和处理它们的方法组成对象（object），把相同行为的对象归纳为类（class），通过类的封装（encapsulation）隐藏内部细节，通过继承（inheritance）实现类的特化（specialization）和泛化（gene...
C++ 核心编程 学习笔记
最新发布
05-11
### C++核心编程学习笔记知识点概述 #### 一、内存分区模型 在C++中，内存被分为四个主要部分：代码区、全局区、栈区和堆区。 1. **代码区**： - **作用**：存放函数体的二进制代码。 - **特点**：由操作系统...
C++学习笔记（day3）持续更新中
XITMan的博客
06-28 181
运算符重载 可以利用局部函数和全局函数进行运算符+的重载 只能利用全局函数进行左移运算符的重载 cout的数据类型是ostream 继承的好处：减少重复代码 语法：class 子类：继承方式 父类 子类页称为派生类 父类也称为基类 派生类的成员包含基类继承过来的和自己增加的成员（体现了共性和个性） 父类中的私有内容 子类不能继承 公共继承父类中的保护内容和公共内容原封不动的继承给子类 保护继承 公共的内容会变为保护内容传给子类 私有继承 公共和保护的内容都会变成私有的传给子类 父类中所以非静态的成员属性都会
C实现-CPP的-多态
bingfengyiqie的专栏
04-22 610
#include #include /** 多态的本质：子类保留对父类的引用实现继承、 同时通过改变父类的函数指针的值、 来实现调用不同的方法。 */ struct Student { void(*p)(); // 通过改变函数指针的值、来实现调用不同的方法。 }; struct MiddleStudent { struct Student stu; void(*p)()
cpp学习笔记：多态
ohhjack的博客
11-01 742
cpp学习
cpp中的多态及其实现原理自述
Template Code
08-04 1262
用于自我学习和成长
cpp中的多态，虚函数
be happy
05-13 917
/* * test.cpp * * Created on: 2013-5-13 * Author: Administrator */ #include /* * 要实现多态，要有俩个必要条件： * 1.使用指针和new产生动态变量，并且将父类指针指向子类的变量 * 2.使用父类指针调用*虚函数*，非虚函数不能实现多态 * * 多态的结果是：使用父类指针，调用子
cpp中三种多态
惜兰blog
07-08 918
cpp中三种多态 多态（Polymorphism）是一个大家耳熟能详的概念。在传统的C++教学中，我们通常认为“多态”是函数在类继承体系中所表现出来的一种行为。比如，在下面的例子中， template <typename T> T convertFromInt(int v); void f1() { convertFromInt<float>(5); convertFromInt<double>(5); } struct Base { virt
【c++】cpp多态
hutaotaotao的博客
04-30 894
c++多态知识与原理
C++学习笔记：编程理解与入门指南
"C++学习笔记，涵盖从基础到高级的主题，旨在帮助初学者理解编程概念，而不仅仅是学习C++语言的语法。笔记作者强调基础的重要性，并以个人理解和实践经验为基础进行阐述，可能会与传统教材有所不同。" C++学习笔记...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值