6月20日多态

最新推荐文章于 2024-09-02 23:29:10 发布
最新推荐文章于 2024-09-02 23:29:10 发布
阅读量1k 收藏 14
点赞数 23
文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ghyghufyu/article/details/139820166
版权

4.7多态
4.7.1多态的概念
多态是c++面向对象三大特性之一
多态分两类
静态多态：函数重载和运算符重载属于静态多态，复用函数名
动态多态：派生类和虚函数实现运行时多态
静态多态和动态多态区别：
静态多态的函数地址早绑定-编译阶段确定函数地址
动态多态的函数地址晚绑定-运行阶段确定函数地址

#include<iostream>
using namespace std;
//动物类
class Animal
{
public:
	//虚函数
	//动态多态满足条件
	//1.有继承关系
	//2.子类要重写父类的虚函数（函数返回值的类型，函数名称，参数列表完全相同）
	 
	//动态多态的使用
	//父类的指针或者引用 执行子类对象

	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};
class Cat :public Animal
{
public:
	 void speak()
	{
		cout << "小猫在说话" << endl;

	}
};
class Dog :public Animal
{
	void speak()
	{
		cout << "小狗在说话" << endl;
	}
};

void doSpeak(Animal& animal)
{
	animal.speak();//函数的地址早绑定，在编译阶段确定了函数的地址
	//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定

}
void test01()
{
	Cat cat;
	doSpeak(cat);
	Dog dog;
	doSpeak(dog);
}
int main()
{
	test01();
	return 0;
}

4.7.2多态的原理

#include<iostream>
using namespace std;
//动物类
class Animal
{
public:
	//虚函数
	//动态多态满足条件
	//1.有继承关系
	//2.子类要重写父类的虚函数（函数返回值的类型，函数名称，参数列表完全相同）
	 
	//动态多态的使用
	//父类的指针或者引用 执行子类对象

	 virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};
class Cat :public Animal
{
public:
	 void speak()
	{
		cout << "小猫在说话" << endl;

	}
};
class Dog :public Animal
{
	void speak()
	{
		cout << "小狗在说话" << endl;
	}
};

void doSpeak(Animal& animal)
{
	animal.speak();//函数的地址早绑定，在编译阶段确定了函数的地址
	//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定

}
void test01()
{
	Cat cat;
	doSpeak(cat);
	Dog dog;
	doSpeak(dog);
}
void test02()
{
	cout << "sizeof Animal=" << sizeof(Animal) << endl;
}
int main()
{
	//test01();
	test02();
	return 0;
}

在这里插入图片描述
在这里插入图片描述
多态的底层原理涉及到虚函数（virtual function）和虚表（vtable）的概念。下面我来简单解释一下：

  1. 虚函数（virtual function）：

    • 在面向对象的编程中，虚函数是一个在基类中声明的函数，它可以在派生类中被重写（override）。
    • 虚函数的关键特性是它可以通过基类的指针或引用来调用派生类中的方法。这意味着在运行时，程序可以根据对象的实际类型来调用适当的函数。

  2. 虚表（vtable）：

    • 每个含有虚函数的类（即有虚函数的类）都会有一个对应的虚表。虚表是一个存储了类的虚函数地址的表格（或者指针数组）。
    • 对象的每个实例都包含一个指向虚表的指针（通常是作为对象的隐藏成员存在）。
    • 虚表中的每个条目对应一个虚函数，通常是指向实际函数代码的指针。这样，当通过基类的指针或引用调用虚函数时，实际上是通过虚表来找到正确的函数实现。

  3. 多态的实现机制：

    • 当通过基类的指针或引用调用虚函数时，编译器会根据对象的实际类型来确定调用哪个函数。具体步骤如下：
      • 根据对象的实际类型找到对应的虚表。
      • 在虚表中查找函数的地址。
      • 调用该地址处的函数。
    • 这种动态绑定（dynamic binding）的过程使得程序在运行时能够根据对象的实际类型来决定调用哪个函数，从而实现了多态性。

总结来说，多态的底层原理就是通过虚函数和虚表来实现的，它允许程序在运行时根据对象的实际类型调用适当的函数，从而实现了基于继承和重写的多态性特性。
4.7.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 = 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();
	return 0;
}

4.7.3利用多态实现计算器

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

}
//利用多态实现计算机
//实现计算器抽象类

class AbstractCalculator
{
public:
	virtual int getResult()
	{
		return 0;
	}
	int m_Num1;
	int m_Num2;
};
//加法计算器类
class AddCalculator :public AbstractCalculator
{
	int getResult()
	{
		return m_Num1 + m_Num2;
	}
};
//减法计算器类
class SubCalculator :public AbstractCalculator
{
	int getResult()
	{
		return m_Num1 - m_Num2;
	}
};
class MulCalculator :public AbstractCalculator
{
	int getResult()
	{
		return m_Num1 * m_Num2;
	}
};
//多态好处
//1.组织结构清晰
//2.可读性强
//3.对于前期和后期扩展以及维护性高
void test02()
{
	//多态使用条件
	//父类指针或者引用指向子类对象

	//加法运算
	AbstractCalculator* 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;
	abc = new MulCalculator;
	abc->m_Num1 = 100;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << "*" << abc->m_Num2 << "=" << abc->getResult() << endl;

}
int main()
{
	//test01();
	test02();
	return 0;
}

4.7.3纯虚函数和抽象类
在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的类容，因此可以将虚函数改为纯虚函数
纯虚函数语法：virtual 返回值类型 函数名 （参数列表）=0；
当类中有了纯虚函数 ，这个类也称为抽象类
抽象类特点：
无法实例化对象
子类必须重写抽象类中的虚函数，否则也属于抽象类

#include<iostream>
using namespace std;
//纯虚函数和抽象类
class Base
{
public:
	//只要有一个纯虚函数，这个类称为抽象类
	//抽象类特点：
	//1.无法实例化对象
	//2.抽象类的子类必须重写父类中的纯虚函数，否则也属于抽象类
	virtual void func() = 0;

};

class Son :public Base
{
public:
	void func()
	{
		cout << "func函数的调用" << endl;
	}
	
};
void test01()
{
	//Base b;//抽象类无法实例化对象
	//Son s;//子类必须重写父类中的纯虚函数，否则无法实例化对象
	Base* base = new Son;
	base->func();
}
int main()
{
	test01();
	return 0;
}

4.7.4多态案例二.制作饮品
案例描述
制作饮品的大致流程为:煮水，冲泡，倒入杯中，加入辅料
利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶

#include<iostream>
using namespace std;
class AbstractDring
{
public:
	//煮水
	virtual void Boil() = 0;
	//冲泡
	virtual void Brew() = 0;
	//倒入杯中
	virtual void PourCup() = 0;
	//加入辅助佐料
	virtual void PutSomething() = 0;
	void makeDrink()
	{
		Boil();
		Brew();
		PourCup();
		PutSomething();
	}
};
//具体的制作
class Coffee :public AbstractDring
{
	void Boil() 
	{
		cout << "煮农夫山泉" << endl;
	 }
	void Brew()
	{
		cout << "冲泡咖啡" << endl;
	 }
	void PourCup()
	{
		cout << "倒入杯中" << endl;
	}
    void PutSomething()
	{
		cout << "加入糖和牛奶" << endl;
	}

};
class Tea :public AbstractDring
{
	void Boil()
	{
		cout << "煮矿泉水" << endl;
	}
	void Brew()
	{
		cout << "冲泡茶叶" << endl;
	}
	void PourCup()
	{
		cout << "倒入茶杯中" << endl;
	}
	void PutSomething() 
	{
		cout << "加入柠檬" << endl;
	}

};
void dowork(AbstractDring* abs)
{
	abs->makeDrink();
	delete abs;
}
void test01()
{
	dowork(new Coffee);
	
	dowork(new Tea);
}
int main()
{
	test01();
	return 0;
}

4.7.5虚析构和纯虚构
多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
解决方式，将父类中的析构函数改为虚析构或者纯虚构
虚析构和纯虚构共性
1.可以解决父类指针释放子类对象
2.都需要有具体的函数实现
虚析构和纯析构区别：
如果是虚析构，该类属于抽象类，无法实例化对象

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

#include<iostream>
#include<string>
using namespace std;
class Animal
{
public:
	 Animal()
	{
		cout << "Animal的构造函数调用" << endl;
	}
	 //利用虚析构可以解决父类指针释放子类对象时不干净的问题
	/*virtual ~Animal()
	{
		cout << "Aniaml的析构函数的调用" << endl;
	}*/
	 virtual ~Animal() = 0;//纯虚析构
	virtual void speak() = 0;
	
};
//纯虚析构需要声明也需要实现
//有了纯虚析构之后，这个类也属于抽象类，无法实例化对象
Animal:: ~Animal()
{
	cout << "Aniaml的纯虚析构析构函数的调用" << 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;
		}
	}
	void speak()
	{
		cout << *m_Name<<"小猫在说话" << endl;
	}
	string* m_Name;
};
void test01()
{
	Animal* animal = new Cat("Tom");
	animal->speak();
	//父类指针在析构时候 不会调用子类中的析构函数，导致子类中如果有堆区属性，出现内存泄露情况
	delete animal;
}
int main()
{
	test01();
	return 0;
}

4.7.6多态案例三-电脑组装
案例描述：
电脑主要组成部分为CPU（用于计算），显卡（用于显示），内存条（用于存贮），将每个零件封装出抽象类，并且提供不同的厂商生产不同的零件，例如inter厂商和lenovo厂商，创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
测试组装三台不同的电脑进行工作

#include<iostream>
using namespace std;
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;
};
//具体厂商
class InterCPU :public CPU
{
public:
	 void calculate()
	{
		cout << "inter的cpu开始计算了" << endl;
	}
};
class IntervoidyCard :public VideoCard
{
	void display()
	{
		cout << "Inter的显卡开始显示了" << endl;
	}
};
class InterMemory :public Memory
{
public:
	void storage()
	{
		cout << "Inter的内存条开始存储了" << endl;
	}
};
class LenovoCPU :public CPU
{
public:
	void calculate()
	{
		cout << "lenovo的cpu开始计算了" << endl;
	}
};
class LenovoidyCard :public VideoCard
{
	void display()
	{
		cout << "Lenovo的显卡开始显示了" << endl;
	}
};
class LenovoMemory :public Memory
{
public:
	void storage()
	{
		cout << "Lenovo的内存条开始存储了" << endl;
	}
};
void test01()
{
	CPU* interCPU = new InterCPU;
	VideoCard* interCard = new IntervoidyCard;
	Memory* interMemory = new InterMemory;
	Computer* computer1 = new Computer(interCPU, interCard, interMemory);
	computer1->work();
	delete computer1;
}
void test02()
{
	Computer* computer2 = new Computer(new LenovoCPU, new LenovoidyCard, new LenovoMemory);
	computer2->work();
	delete computer2;
}
int main()
{
	test01();
	test02();
	return 0;
}
YMH.
关注
  • 23
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA封装继承多态案例分析_java基础，封装，继承，多态，集合的综合案例
weixin_28917337的博客
02-27 1130
最近学习了java基础中的封装、继承、多态和集合，写了一个简单地案例。对于不太懂这方面的新手希望会有助于你们理解，如果是大神可以提出改进意见，谢谢。关于这方面的概念性的东西我也解释不好，所以就不多说了。本案例没有用到和抽象类接口。简单介绍一下这个案例：《宠物商店》功能，宠物商店可以进购宠物，可以出售宠物。宠物具有吃东西和玩耍的能力，宠物主人可以在宠物商店购买宠物，可以给宠物起名字，可以陪宠物玩，喂...
多态、抽象类、接口、方法的重载重写
weixin_44283061的博客
12-20 402
多态 什么是多态  同一个对象，在不同时刻表现出来的不同形态.  我们可以说猫是猫：猫 cat = new 猫();  我们也可以说猫是动物：动物 animal = new 猫();  这里猫在不同的时刻表现出来了不同的形态，这就是多态 多态的前提  要有继承/实现关系  要有方法的重写  要有父类引用指向子类对象 多态的特点：  需要有继承关系  方法重写  父类引用执行子类对象 public static void main(String[] args) { //
6月20日周测
M19950519的博客
06-21 139
第一部分：编程题/*@作者名：冒蔡静*@版本号：2018.6.20*@类名：Person**/public class Person { /**  *私有字段name  *私有字段age  */ protected String name; protected int age;  /**  *空参构造器   */ public Person(){}  /**  *有参构造器 给name int 赋...
构造函数、继承、多态
weixin_44023129的博客
09-09 308
一：构造函数 Demo 先看一段代码 public class InitialTime { int age = 18; String name = "guang"; public InitialTime() { this.age = 100; this.name = "java"; init(); service(); destroy(); } public void init() {
2018年6月20日 周测
博客
06-20 345
package com.dodoke2; /** * 类名 Person *@author 邱银 *@version 2018年6月20号 * */ public class Person { private String name; private int age; /** * 空构造器 */ public Person() { } /** * ...
Java 接口和多态
chan_1030261721的博客
02-14 258
一、接口 1.1 接口的概述 接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的类 。 接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。 1.2 接口的格式&amp;使用 1.2.1 接口的格式 与定义类的 class 不同，接口定义时需要使用 interface 关键字。 定义...
java 和c 多态比较_多态在 Java 和 C 编程语言中的实现比较
weixin_35850219的博客
02-24 81
2011 年 12 月 22 日发布众所周知，多态是面向对象编程语言的重要特性，它允许基类的指针或引用指向派生类的对象，而在具体访问时实现方法的动态绑定。C++ 和 Java 作为当前最为流行的两种面向对象编程语言，其内部对于多态的支持到底是如何实现的呢，本文对此做了全面的介绍。注意到在本文中，指针和引用会互换使用，它们仅是一个抽象概念，表示和另一个对象的连接关系，无须在意其具体的实现。Java ...
继承，多态
d12111789789789的博客
10-10 127
继承，多态 1. 继承的介绍-OOP三大特性之一 **生活中的继承：**继承遗产、继承家产、继承皇位 老的把东西留给小的，留给后代。一种传承。 面向对象思想中的继承(extend)：继承可以使得子类具有父类的属性和方法或者重新定义、追加属性和方法等。 2. 继承的作用 /** * 狗类 * @author Charles7c * 2019年10月9日 下午1:50:08 */ public...
【转】Java接口与多态
xieganyu3460的博客
07-09 166
转自：https://www.cnblogs.com/yoke/p/7453864.html接口1.1 接口的概述接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的”类”。接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。1.2 接口的格式&amp;使用1.2.1 接口的格式与定义类的class...
6月20日日常考试答案（150道题）.docx
06-20
这些题目涉及了Java编程语言中的多个核心知识点，包括类的初始化、对象创建、异常处理、泛型、集合框架、继承与多态、以及设计模式。下面将逐一详细解释： 1. 类的初始化顺序：静态代码块先于非静态代码块和非静态...
progetto-OOP：存储库progetto programmazione OO 2月20日
02-12
标题中的“progetto-OOP”很可能是一个面向对象编程（OOP）项目，而“progetto programmazione OO febbraio 2021”表明这是一个2021年2月进行的面向对象编程课程或作业。提到的标签是“HTML”，这暗示项目可能涉及到...
(精华2020年6月3日更新) TypeScript中类的使用(封装，继承，多态)
热门推荐
一点一滴
06-03 1万+
基本使用 class Cat { name:string; color:string; constructor(name1:string,color:string){ this.name = name1; this.color= color } eat(){ console.log('eat'); } } var c1 = new Cat('哈哈','黄色'); 继承 class Animal { n
C语言操作符详解1（含进制转换，原反补码）
hdxbufcbjuhg的博客
09-02 1318
左移操作符对一个十进制整数的影响是有规律的，无论正负数，都可以对原数值起到乘以2的移位次方的作用，比如将10左移了1位，那么就对原数值乘以了2的一次方，变成了20，依次类推，如果是-10左移了1位，那么就会变成-20对一个无符号数进行右移操作，会对它进行除以2的移位次方，比如将10右移一位，就对它除以了2的一次方，最后变成了5，那如果这个数不是偶数怎么办呢？比如123向右移一位，它除以2就是61.5，最后结果会返回这个数两边较小的整数，61.5的两边分别是61和62，最终得到小的那个数61，所以综上，
【C++】深入理解C++模板：从基础到进阶
2403_86785171的博客
09-01 661
模板是C++中用于泛型编程的工具。它允许你编写可以处理任意类型的函数和类，而不必重复编写相似的代码。函数模板和类模板。
【C++】智能指针——auto_ptr，unique_ptr，shared_ptr
2301_79796701的博客
09-01 1270
1.智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错 乱了。旧的智能指针的会转移给新的智能指针，而旧的智能指针的会被置空。解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了，weak_ptr不会增加引用计数，代码示意。该问题是有类似于链表节点的结构引起的，当外部的智能指针都释放了，就拿不内部的智能指针，那么节点就不会释放。使用方法参考官方文档。
Linux C 内核编程 /proc 编程例子
最新发布
yong1585855343的博客
09-02 409
Linux 内核编程 /proc 例子代码
c++11新特性-智能指针
SuperYang_的博客
09-01 1138
智能指针RAII(Resource Acquisition Is Initialization)，是一种利用对象的生命周期来管理资源的技术。如果我们采用传统的new/delete来申请和释放资源，如果忘记调用delete，或者在调用delete之前程序抛出异常，都会导致内存泄漏问题，如代码1.1，Func函数中的new p2和Div都可能抛异常，导致后面的delete没有执行从而引发内存泄漏，采用智能指针对资源进行管理，能够杜绝这类问题。代码1.1：因异常引发的内存泄漏throw "除0错误";
【C++ Primer Plus习题】9.1
qq_74047911的博客
09-02 307
【C++ Primer Plus习题】9.1
可以使用c++的类与对象，继承，多态和虚函数等知识进行编译,题目要求如下: 1.输入任意一年将显示出该年的所有月份日期，对应的星期。 2.注意闰年情况其显示格式要求如下: (1) 月份:中文英文都可以。 (2)下一行显示星期，从周日到周六，中英文都可以。 (3)下一行开始显示日期从1号开始，并按其是周几实际情况与上面的星期数垂直对齐。
05-26
s += "六月"; break; case 7: s += "七月"; break; case 8: s += "八月"; break; case 9: s += "九月"; break; case 10: s += "十月"; break; case 11: s += "十一月"; break; case 12: s += "十...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值