C++学习系列（9）——类和对象（七：多态）

最新推荐文章于 2024-07-12 10:56:01 发布
最新推荐文章于 2024-07-12 10:56:01 发布
阅读量76 收藏
点赞数
分类专栏： C++学习 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48905043/article/details/108050976
版权

C++学习系列（9）——类和对象（七：多态）

⑦多态：
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 test01()
{
	Cat cat;
	doSpeak(cat);

	Dog dog;
	doSpeak(dog);
}

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

总结：
动态多态满足条件：

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

动态多态使用：

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

重写：函数返回值类型 函数名 参数列表完全相同

内部剖析：
在这里插入图片描述
7.2多态案例1-计算器类

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

多态的优点：

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

普通写法：

#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 = 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;
}

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

多态写法：

#include<iostream>
#include<string>

using namespace std;

//利用多态实现计算器

//实现计算器抽象类
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*abs = new AddCalculator;
	abs->m_Num1 = 100;
	abs->m_Num2 = 100;

	cout << abs->m_Num1 << " + " << abs->m_Num2 << " = " << abs->getResult() << endl;
	//用完后记得销毁
	delete abs;

	//减法运算
	abs = new SubCalculator;
	abs->m_Num1 = 100;
	abs->m_Num2 = 50;

	cout << abs->m_Num1 << " - " << abs->m_Num2 << " = " << abs->getResult() << endl;
	delete abs;

	//乘法运算
	abs = new MulCalculator;
	abs->m_Num1 = 100;
	abs->m_Num2 = 50;

	cout << abs->m_Num1 << " * " << abs->m_Num2 << " = " << abs->getResult() << endl;
	delete abs;

}

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

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

7.3纯虚函数和抽象类

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

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

纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0；virtual void func() = 0

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

抽象类特点：

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

7.4多态案例2-制作饮品
案例描述：
制作饮品的大致流程为：煮水-冲泡-倒入杯中-加入辅料

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

#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 PuySomething() = 0;

	//制作饮品
	void makeDrink()
	{
		Boil();
		Brew();
		PourInCup();
		PuySomething();
	}
};

//制作咖啡
class Coffee :public AbstractDrinking
{
public:
	//煮水
	virtual void Boil()
	{
		cout << "煮自来水" << endl;
	}
	//冲泡
	virtual void Brew() 
	{
		cout << "冲泡咖啡" << endl;
	}
	//导入杯中
	virtual void PourInCup()
	{
		cout << "倒入杯中" << endl;
	}

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

//制作茶叶
class Tea :public AbstractDrinking
{
public:
	//煮水
	virtual void Boil()
	{
		cout << "煮矿泉水" << endl;
	}
	//冲泡
	virtual void Brew()
	{
		cout << "冲泡茶叶" << endl;
	}
	//导入杯中
	virtual void PourInCup()
	{
		cout << "倒入杯中" << endl;
	}

	//辅助作料
	virtual void PuySomething()
	{
		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;
}

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

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

虚析构和纯虚析构共性：

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

虚析构和纯虚析构的区别：

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

虚析构语法：virtual~类名（）{}
纯虚析构语法：virtual~类名（）=0；
具体实现： 类名：：~类名（）{}

#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;
}

总结：

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

7.6多态案例3-电脑组装
案例描述：
电脑主要组成部件为CPU，显卡，内存条
将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商
创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
测试时组装三台不同电脑进行工作

分析：
在这里插入图片描述
实现：

#include<iostream>
#include<string>

using namespace std;


//抽象不同零件类
//抽象CPU类
class CPU
{
public:
	//抽象的计算函数
	virtual void calcuate() = 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->calcuate();

		m_vc->display();

		m_mem->storage();
	}

	//提供析构函数 释放3个电脑零件
	~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;//CPU指针
	VideoCard*m_vc;//显卡指针
	Memory*m_mem;//内存条指针
};

//具体厂商
//Intel厂商

class IntelCPU :public CPU
{
public:
	virtual void calcuate()
	{
		cout << "Intel的CPU开始计算" << endl;
	}
};

class IntelVideoCard :public VideoCard
{
public:
	virtual void display()
	{
		cout << "Intel的GPU开始显示" << endl;
	}
};

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

//Lenovo厂商
class LenovoCPU :public CPU
{
public:
	virtual void calcuate()
	{
		cout << "Lenovo的CPU开始计算" << endl;
	}
};

class LenovoVideoCard :public VideoCard
{
public:
	virtual void display()
	{
		cout << "Lenovo的GPU开始显示" << 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;

	//创建第一台电脑
	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 IntelCPU, new LenovoVideoCard, new LenovoMemory);
	computer3->work();
	delete computer3;
}

int main()
{
	test01();
	system("pause");
	return 0;
}
意境阑珊处
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++学习系列（8）——类和对象（六：继承）
意境阑珊处的博客
08-16 190
C++学习系列（8）——类和对象（六：继承） ⑥：继承 继承是面向对象三大特征之一 有些类与类之间存在特殊的关系，如下： 我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。 这个时候我们就可以考虑利用继承的技术，减少重复代码 6.1 继承的基本语法 例如我们看到的很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同，接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义以及好处。 子类->派生类 父类->基类 派生类中的成
C++ 类和对象（八）多态
yty的博客
12-07 170
C++ 类和对象（八）多态 文章目录C++ 类和对象（八）多态1. 多态的原理剖析2. 多态案例一 --- 计算器类3. 纯虚函数和抽象类4. 多态案例二 --- 制作饮品5. 虚析构和虚纯析构6.多态案例三 --- 电脑组装 多态是C++面向对象三大特性之一 1. 多态的原理剖析 多态的分为两类： 静态多态： 函数重载和运算符重载属于静态多态，复用函数名 多态就是多种形态：函数重载函数名相同但是参数类型，传入顺序，参数个数不同来实现函数的多种表现形态，运算符重载可以实现多种类型的数据进行操作，也表现
C++程序设计 —— 实验二：继承和多态
DreamWendy的博客
11-03 1197
一、继承访问权限测试 设计类A具有public, protected, private等不同属性的成员函数或变量； 类B通过public, protected, private等不同方式继承A，在类B的成员函数中测试访问A的成员函数或变量； 在类B中添加public, protected, private等不同属性的成员函数或变量，在外部测试访问B的各个成员函数或变量； B以private方式继承A，尝试把A中的部分public成员提升为public。 二、友元类继承测试 设计类A含有私有变量a，在类A中友
C++系列——————类和对象（上）
2301_80774875的博客
05-27 2361
在学习C语言你可能听到过，C语言是面向过程的语言，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成代码如下（示例）也可以将关键字struct替换为关键字class(可以将class看作struct的升级版)struct为定义类的关键字，stack为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。类中的变量称为类的属性或成员变量;类中的函数称为类的方法或者成员函数。
c++入门学习⑦——继承和多态（超级详细版）
2301_79328557的博客
02-20 2345
基类：被继承的类，又称为“父类”派生类：继承其他类的类，又称为“子类”简单来说：普通的成员前加上一个static关键字，就被称为静态成员。当我们声明类的成员为静态时，这意味着无论创建多少个类的对象，静态成员都只有一个副本。被关键字virtual修饰的类成员函数，而且子类中要重写虚函数（可加virtual也可不加）同一作用城，同名函教，参数的顺序，个数，类型不同都可以重载。函数的返回值类型不能作为重载条件（函数重载，运算行重载）有继承，子类重定义父亲的同名函数（非虚函数。
类的多态练习_C++_类的多态练习_
09-29
在C++编程语言中，"类的多态性"（Polymorphism）是面向对象编程的三大特性之一，另外两个是封装和继承。多态性允许我们使用一个接口来表示不同的类型，使得代码更加灵活，易于扩展。在这个“类的多态练习”中，我们...
cpp代码-c++学习笔记——类与对象
07-14
总结起来，C++的类和对象是面向对象编程的核心，它们通过封装、继承和多态等机制，使得代码更加模块化、易于理解和维护。在实际编程中，正确地设计和使用类与对象能够显著提高软件的可扩展性和复用性。
C++经典实例——体现继承和多态
07-30
在C++编程语言中，继承和多态是面向对象编程（OOP）的两大核心概念。这个名为“C++经典实例——体现继承和多态”的资源显然是为了帮助开发者深入理解和应用这两个关键特性。下面我们将详细探讨这两个主题以及它们在...
C++基础入门：面相对象编程C++中的封装、继承和多态.docx
08-06
总结来说，C++的面向对象特性——封装、继承和多态，为程序设计提供了更灵活、更具表达力的方式。封装确保数据安全，继承促进代码重用，多态则允许灵活的接口处理。在实际编程中，熟练掌握这三个概念及其应用，能...
C++ 多态
wxk2227814847的博客
07-10 762
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
初始C++
2302_81016149的博客
07-08 803
在C语言我们学习函数的时候，我们学习过生命周期这个概念。那么，什么是生命周期呢？生命周期通常指的是一个对象或变量从创建到销毁所经历的时间段。那么，命名空间是什么？咱们可以这样理解：在这个空间的生命周期内，对这个空间内的全部标识符起一个名字，可对其进行引用，可类似与C语言中的结构体。#include<stdlib.h>//此处不包此头文件代码可正常运行，那该如何解决此处情况呢？int main()//此处编译不通过原因为：在不包头文件前为变量，包含后为函数。return 0;
C++初探究（2）
Frenemy__的博客
07-09 1472
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 1012
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
C语言操作符详解
z317920的博客
07-11 529
目录一、操作符分类二、算术操作符三、赋值操作符四、关系操作符 五、条件操作符六、⼆进制和进制转换1.二进制 2.进制转换(1)2进制转10进制(2)10进制转2进制(3)2进制转8进制(4)2进制转16进制七、原码、反码、补码 八、移位操作符1.左移操作符2.右移操作符 九、位操作符1.按位与 &2.按位或 |3.按位异或 ^ 4.按位取反 ~ 十、单目操作符1.逻辑非操作符 ！ 2.自增++、自减-- 3.取地址符&、解引用符*、sizeof 3.1.取地址符& 3.2.解引
C++：CV::Point函数简介
Ethan_Rich的博客
07-08 448
cv::Point是 OpenCV 库中用于表示二维坐标系下点的一个基本数据类型。它提供了在图像处理、计算机视觉等领域中定位和操作点的能力。以下是关于cv::Point。
C++：哈希表
最新发布
m0_61088872的博客
07-12 410
如果我们想要搜索这个数据，直接计算出这个数据的下标，然后就可以直接访问数组对应的位置，所以可以用O(1)的复杂度直接找到数据。当这个哈希表越满，我们查找数据的效率就越低，甚至说：如果查找一个不存在的数据，我们可能要用O(N)的复杂度遍历整个哈希表.因此我们因该把哈希表的负载率控制在一定值，当超过一定值，我们就要进行扩容操作。闭散列，也叫做开放定址法，当发生哈希冲突时，如果哈希表没有被装满，说明哈希表中还有空位置，那么我们可以把发生冲突的数据放到下一个空位置去。转化的函数，被写为了一个模板，而这个。
深入解析【C++ list 容器】：高效数据管理的秘密武器
小李很执着的博客
07-09 930
C++ 中的 list 容器是一个基于双向链表的序列式容器，适用于需要频繁插入和删除操作的场景，但不支持随机访问。list 提供了多种构造方法和丰富的操作接口，包括插入、删除、访问等。与 vector 相比，list 在插入和删除操作上更高效，但在随机访问和空间利用率上较差。
Python的异常处理（与C++对比学习）
2302_76941579的博客
07-09 955
通过C++的基础来学习Python的异常处理
LIUNX /SYS/CLASS/GPIO捕获IO输入状态 C语言
星羽空间
07-09 345
LIUNX /SYS/CLASS/GPIO捕获IO输入状态 C语言
面向对象程序设计-多态.ppt
06-21
第9页和第10页重点讨论了实现多态的条件，必须满足以下几点：函数必须被声明为虚函数（通过`virtual`关键字），子类需要重写父类的虚函数（`override`关键字），并且通过对象指针或引用进行调用。这样，程序才能在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值