多态（虚构的整体，具体的个体）（多态的基本概念/多态的原理剖析/纯虚函数和抽象类/虚析构和纯虚析构）

于 2024-08-28 21:07:47 发布
阅读量194 收藏 4
点赞数 3
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q1312022158/article/details/141222566
版权

多态的基本概念

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
using namespace std;
// 多态的基本概念
// 多态分为静态多态和动态多态
// 静态多态： 函数重载还运算符重载属于静态多态，服用函数名
// 动态多态： 派生派和虚函数实现运行时多态


//静态多态和动态多态的区别
// 静态多态的函数地址早绑定-编译阶段确定函数地址
// 动态多态的函数地址晚绑定-运行阶段确定函数地址


// 动态多态满足条件
// 1.有继承关系
// 2.子类重写父类的虚函数
//    重写就是：函数返回值类型 函数名 参数列表 完全相同

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


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

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

// 执行说话的函数

// C++中允许父子之间的类型转换，不需要强制类型转换
void doSpeak(Animal &animal)
{
	animal.speak();
}

void test01()
{
	Cat c;
	// 属于地址早绑定，在编译阶段确定函数地址
	// 如果想执行让猫说话，那么这个函数地址就不能提前绑定。
	// 需要在运行期间绑定，地址晚绑定
	// 此时用到虚函数的概念，也就是在父类中的函数前加virtual
	// 此作用是让被调用的类的说话函数优先执行，起始也就是加virtual降低了本身的优先级
	// 子类中的virtual可写可不写
	doSpeak(c); // 相当于 Animal &animal = c；
}
void doSpeak(Animal* animal)
{
	animal->speak();
}
void test02()
{
	Cat c;
	doSpeak(&c);
}
int main()
{

	test01();// 引用
	test02();// 指针
	system("pause");
	return 0;
}

多态的原理剖析

此时该类中储存指向该函数的指针

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
using namespace std;
// 多态的原理剖析
class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	};
};
class Cat :public Animal
{
public:
	//重写之后
	void speak()
	{
		cout << "小猫在说话" << endl;
	}
};
int main()
{
	cout << "sizeof(Animal) = " << sizeof(Animal) << endl;

	system("pause");
	return 0;
}

多态案例一---- 计算器类

普通写法

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
using namespace std;
// 计算器类普通写法
class Calculate
{
public:

	Calculate(int num1,int num2)
	{
		this->num1 = num1;
		this->num2 = num2;
	}
	int doWork(string operate)
	{
		if (operate == "+")
		{
			return num1 + num2;
		}else if (operate == "-")
		{
			return num1 - num2;
		}else if (operate == "*")
		{
			return num1 * num2;
		}
		// 此种写法如果想增加其它的功能，需要修改源码
		// 在真正的开发中 提倡 开闭原则
		// 开闭原则： 对扩展进行开放，对修改进行关闭
	}
	int num1;
	int num2;
};
// 普通写法
void test01()
{
	Calculate c(10, 20);
	cout << c.num1 << "+" << c.num2 << " = " <<  c.doWork("+") << endl;
	cout << c.num1 << "-" << c.num2 << " = " << c.doWork("-") << endl;
	cout << c.num1 << "*" << c.num2 << " = " << c.doWork("*") << endl;
}
int main()
{
	test01();

	system("pause");
	return 0;
}

多态写法

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
using namespace std;
// 计算器类-多态写法

// 多态的好处：
// 1.组织结构清晰
// 2.可读性强
// 3.对于前期和后期扩展以及维护性高

// C++开发提倡利用多态设计程序架构，因为多态优点很多
class AbstractCalculate
{
public:
	int num1;
	int num2;
	virtual int calculate()
	{
		return 0;
	}
};
class Add :public AbstractCalculate
{
public:
	virtual int calculate()
	{
		return num1 + num2;
	}
};
class Del :public AbstractCalculate
{
public:
	virtual int calculate()
	{
		return num1 - num2;
	}
};
class Cheng :public AbstractCalculate
{
public:
	virtual int calculate()
	{
		return num1 * num2;
	}
};
void test01()
{
	// 多态使用条件
	// 父类指针或引用指向子类对象

	AbstractCalculate* c = new Add;
	c->num1 = 10;
	c->num2 = 20;
	cout << c->num1 << " + " << c->num2 << " = " << c->calculate() << endl;
	// 用完记得销魂
	delete c;

	c = new Del;
	c->num1 = 10;
	c->num2 = 20;
	cout << c->num1 << " - " << c->num2 << " = " << c->calculate() << endl;
	delete c;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

纯虚函数和抽象类

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

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

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

抽象类特点：

1.无法实例化对象

2.子类必须重写抽象类中的纯虚函数，否则也属于抽象类

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
using namespace std;

// 纯虚函数和抽象类
class Animal
{
public:
	// 纯虚函数
	// 只要有一个纯虚函数，这类就称为抽象类
	// 抽象类特点
	// 1.无法实例化对象
	// 2.子类必须重写父类中的纯虚函数，否则无法实例化对象
	virtual void func() = 0;

};
class Cat :public Animal
{
public:
	void func()
	{
		cout << "func函数调用" << endl;
	}

};
void test01()
{
	//Animal a;
	//new Animal;  //抽象类是无法实例化对象的

	Cat c;// 子类必须重写父类中的纯虚函数，否则无法实例化对象
	Animal& animal = c;
	animal.func();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

多态案例二：制作饮品

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
using namespace std;
class AbstraceMakeDrinking
{
public:
	// 1.煮水
	virtual void zhuShui() = 0;

	// 2.冲泡
	virtual void chongPao() = 0;

	// 3.倒入杯中
	virtual void daoRuBeiZhong() = 0;

	// 4.加入辅料
	virtual void jiaRuFuLiao() = 0;

	void makeDrink()
	{
		zhuShui();
		chongPao();
		daoRuBeiZhong();
		jiaRuFuLiao();
	}
};
class kaFei :public AbstraceMakeDrinking
{
public:
	// 1.煮水
	virtual void zhuShui()
	{
		cout << "煮咖啡水" << endl;
	}

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

	// 3.倒入杯中
	virtual void daoRuBeiZhong()
	{
		cout << "导入咖啡杯中" << endl;
	}

	// 4.加入辅料
	virtual void jiaRuFuLiao()
	{
		cout << "加入咖啡辅料" << endl;
	}
};
void test01()
{
	AbstraceMakeDrinking* coffee = new kaFei;
	coffee->makeDrink();
	delete coffee;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

虚析构和纯虚析构

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
using namespace std;
#include<string>
// 虚析构和纯虚析构
// 多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时
//无法调用到子类的析构代码
// 因为父类引用指向子类对象，故在释放空间时调用的是父类的析构函数
// 故使用多态（虚析构或纯虚析构）

// 虚析构和纯虚析构的共性：
//  1.可以解决父类指针释放子类对象
//  2.都需要具体的函数实现

// 虚析构和纯虚析构的区别：
//   如果是纯虚析构，该类属于抽象类，无法实例化对象

// 总结
// 1.虚析构和纯虚析构就是用来解决父类指针释放子类对象
// 2.如果子类中没有堆区数据，可以不写虚析构或纯虚析构
// 3.拥有纯虚析构也属于抽象类
class Animal
{
public:
	// 纯虚析构
	virtual void speak() = 0;
	Animal()
	{
		cout << "Animal类构造函数的调用" << endl;
	}
	 利用虚析构可以解决 父类指针释放子类对象时不干净的问题
	//virtual ~Animal()
	//{
	//	cout << "Animal类析构函数的调用" << endl;
	//}

	// 纯虚析构(需要声明也需要实现)
	// 有了纯虚析构之后，这个类也属于抽象类，无法实例化对象
	virtual ~Animal() = 0;
};
// 子类中需要析构函数释放空间，但是多态走不到子类中的析构函数，
// 所以需要虚析构和纯虚析构
Animal:: ~Animal()
{
	cout << "Animal类析构函数的调用" << endl;
}
class Cat :public Animal
{
public:
	string* name;
	Cat(string name)
	{
		cout << "Cat类构造函数的调用" << endl;
		this->name = new string(name);
	}
	~Cat()
	{
		cout << "Cat类析构函数的调用" << endl;
		if (name != NULL)
		{
			delete name;
			name = NULL;
		}
	}
	virtual void speak()
	{
		cout << *name << "小猫在说话" << endl;
	}
};
void test01()
{
	// 多态：父类指针或引用指向子类对象
	// 引用：给变量取别名
	Animal *animal = new Cat("Tom");
	animal->speak();
	// 父类指针在析构的时候，不回调用子类中析构函数，
	// 导致子类如果有堆区属性，出现内存泄露
	delete animal;
	animal = NULL;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

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

// 解决方法，将父类析构函数改为虚析构或纯虚析构

多态案例三： 电脑组装

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
using namespace std;
// CPU抽象类
class Cpu
{
public:
	virtual void calculate() = 0;
};
// 显卡抽象类
class DisplayCard
{
public:
	virtual void display() = 0;
};
// 内存抽象类
class Memory
{
public:
	virtual void distory() = 0;
};

// 电脑类
class Computer
{
public:

	// 用来接受每一个零件
	Computer(Cpu *cpu, DisplayCard *card, Memory *memory)
	{
		this->cpu = cpu;
		this->card = card;
		this->memory = memory;
	}
	~Computer()
	{
		if (cpu != NULL)
		{
			delete cpu;
			cpu = NULL;
		}
		if (card != NULL)
		{
			delete card;
			card = NULL;
		}
		if (memory != NULL)
		{
			delete memory;
			memory = NULL;
		}
	}

	// 用来协同每一个零件工作
	void work()
	{
		cpu->calculate();
		card->display();
		memory->distory();
	}
private:
	Cpu* cpu;
	DisplayCard* card;
	Memory* memory;
};

// 不同厂商的CPU
class IntelCpu :public Cpu
{
public:
	virtual void calculate()
	{
		cout << "Intel的CPU开始计算了" << endl;
	}
};
class LevoeCpu :public Cpu
{
public:
	virtual void calculate()
	{
		cout << "Levoe的CPU开始计算了" << endl;
	}
};

// 不同厂商的显卡
class IntelDisplayCard :public DisplayCard
{
public:
	virtual void display()
	{
		cout << "Intel的显卡开始显示了" << endl;
	}
};
class LevoeDisplayCard :public DisplayCard
{
public:
	virtual void display()
	{
		cout << "Levoe的显卡开始显示了" << endl;
	}
};

//不同厂商的内存条
class IntelMemory :public Memory
{
public:
	virtual void distory()
	{
		cout << "Intel的内存条开始存储了 " << endl;
	}
};
class LevoeMemory :public Memory
{
public:
	virtual void distory()
	{
		cout << "Levoe的内存条开始存储了 " << endl;
	}
};


void test01()
{
	// 第一台电脑运行
	cout << "第一台电脑运行--------------------------" << endl;
	Cpu* cpu = new IntelCpu;
	DisplayCard* card = new IntelDisplayCard;
	Memory* memory = new IntelMemory;
	Computer *c = new Computer(cpu,card,memory);
	c->work();
	delete c;

	// 第二台电脑运行
	cout << "第二台电脑运行--------------------------" << endl;
	c = new Computer(new LevoeCpu, new LevoeDisplayCard, new LevoeMemory);
	c->work();
	delete c;
	c = NULL;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

别辜负这场相遇
关注
专栏目录
多态(虚函数,虚函数表,纯虚函数,虚析构函数,抽象类)
szplzx1314的博客
09-30 349
目录 多态 静多态 动多态 虚函数 动态类型和静态类型 静态类型 动态类型(多态实现) 虚函数表(vtable) 定位虚函数 虚函数初始化时间 虚函数表的特点 虚函数应用 纯虚函数 纯虚函数声明方法 纯虚函数特点 虚析构函数 虚函数限制 抽象类(虚基类这个好像是这么叫还是叫纯虚基类来着,记不清了.不过这个不重要) 总结 多态 多态嘛,固然就是一个物体有多种形态,在C++中就是一个函数名,有多种功能. 函数重载一般叫静多态,接下来介绍的就是动多态. 静多态 在.
多态
痞子王的博客
02-28 367
多态Polymorphism 一、多态的概念、格式与使用 (一)概念 多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同...
C++：多态
最新发布
Makise的博客
08-07 708
一篇带你完全掌握多态
C++虚函数多态和纯虚函数多态的经典示例源码
02-25
总之，C++的虚函数和纯虚函数是实现多态的核心工具。虚函数允许通过基类指针调用派生类的方法，实现运行时多态；而纯虚函数则用于定义抽象基类和接口，确保所有派生类都必须实现某些特定功能。这种灵活性和通用性...
C++学习篇?纯虚函数和抽象类
12-22
在C++编程语言中，纯虚函数和抽象类是面向对象设计的重要概念，它们主要用于创建类的继承层次结构。理解这两个概念对于开发复杂的、可扩展的软件系统至关重要。 纯虚函数，正如标题所言，是一种特殊的虚函数。虚...
深入解析C++编程中的纯虚函数和抽象类
01-20
有时在基类中将某一成员函数定为虚函数，并不是基类本身的要求，而是考虑到派生类的需要，在基类中预留了一个函数名，具体功能留给派生类根据需要去定义。 纯虚函数是在声明虚函数时被“初始化”为0的函数。声明纯虚...
后端 / C++ 类 封装 继承 多态 stl容器 虚函数 纯虚函数 友元函数 模板
01-08
本主题涵盖了C++中的关键概念和技术，包括类、封装、继承、多态、STL容器、虚函数、纯虚函数、友元函数以及模板。 1. **类(Class)**：类是C++中面向对象编程的基础，它定义了一组数据（成员变量）和操作这些数据的...
JavaSE 19 Polymorphism 多态
Niiuu的博客
02-09 259
第二十四章 Polymorphism 多态 extends继承或者implements实现，是多态的前提。 一个对象拥有多种形态，这就是对象的多态性。 举例 小明是一个学生，同时也是一个人 小明是一个对象， 小明对象即是学生形态，也有人类形态。 24.1 多态的格式与使用 代码当中体现多态性，其实就是一句话：父类应用指向子类对象。 格式： 父类名称 对象名称 = new 子类名称(); ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值