C++ 核心篇 9 之类与对象 - 多态

最新推荐文章于 2024-08-14 17:18:35 发布
最新推荐文章于 2024-08-14 17:18:35 发布
阅读量258 收藏
点赞数 3
分类专栏： C++（C语言的延伸） 文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51927215/article/details/120919875
版权

C++ 自学

多态的基本语法

多态分为二类：静态多态和动态多态

》》》静态多态：函数重载和运算符重载属于静态多态

》》》动态多态：派生类和虚函数实现运行时多态

静态多态和动态多态区别：静态多态的函数地址早绑定（编译阶段确认函数地址）动态多态的函数地址晚绑定（运行阶段确认函数地址）

程序举例

#include <iostream>
using namespace std;

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

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

void doSpeak(Animal &a) {
	a.speak();
}

int main() {
	
	Cat c1;
	c1.speak(); // 小猫在说话！
	// 多态的目的在于 Animal &a = c1; a.speak(); 的实际调用其实是 c1.speak();
	doSpeak(c1); // 动物在说话！

	system("pause");
	return 0;
}

此处我们使用虚函数实现晚绑定

#include <iostream>
using namespace std;

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

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

void doSpeak(Animal &a) {
	a.speak();
}

int main() {
	
	Cat c1;
	c1.speak(); // 小猫在说话！
	doSpeak(c1); // 小猫在说话！

	system("pause");
	return 0;
}

动态多态要求满足的条件：有继承关系；子类重写父类的虚函数

多态案例1 - 计算器类

原始实现

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

class Calculate {
public:
	// 构造函数
	Calculate(int num1, int num2) {
		Num1_ = num1;
		Num2_ = num2;
	}
	// 计算器的实现
	int getResult(string oper){
		if (oper == "+") {
			return Num1_ + Num2_;
		}
		else if (oper == "-") {
			return Num1_ - Num2_;
		}
		else if (oper == "*") {
			return Num1_ * Num2_;
		}
		else if (oper == "/") {
			return Num1_ / Num2_;
		}
	}
public:
	int Num1_;
	int Num2_;
};

int main() {
	
	Calculate c1(3, 4);
	cout << c1.getResult("+") << endl; // 7
	cout << c1.getResult("-") << endl; // -1
	cout << c1.getResult("*") << endl; // 12
	cout << c1.getResult("/") << endl; // 0

	system("pause");
	return 0;
}

多态实现

#include <iostream>
using namespace std;

class Calculate {
public:
	// 计算器的实现 - 虚函数
	virtual int getResult() {
		return 0;
	}

public:
	int Num1_;
	int Num2_;
};

class Add :public Calculate{
public:
	// 重写父类虚函数 - virtual 可写可不写
	virtual int getResult() {
		return Num1_ + Num2_;
	}
};

class Sub :public Calculate {
public:
	// 重写父类虚函数 - virtual 可写可不写
	virtual int getResult() {
		return Num1_ - Num2_;
	}
};

class Mul :public Calculate {
public:
	// 重写父类虚函数 - virtual 可写可不写
	virtual int getResult() {
		return Num1_ * Num2_;
	}
};

class Div :public Calculate {
public:
	// 重写父类虚函数 - virtual 可写可不写
	virtual int getResult() {
		return Num1_ / Num2_;
	}
};

int main() {
	
	// 多态使用条件：父类指针或引用指向子类对象
	// 1. 实现加法
	Calculate *cal1 = new Add;
	// 二个操作数
	cal1->Num1_ = 10;
	cal1->Num2_ = 2;
	cout << cal1->getResult() << endl; // 12

	// 2. 实现减法
	Calculate *cal2 = new Sub;
	// 二个操作数
	cal2->Num1_ = 10;
	cal2->Num2_ = 2;
	cout << cal2->getResult() << endl; // 8

	// 3. 实现乘法
	Calculate *cal3 = new Mul;
	// 二个操作数
	cal3->Num1_ = 10;
	cal3->Num2_ = 2;
	cout << cal3->getResult() << endl; // 20

	//4. 实现除法
	Calculate *cal4 = new Div;
	// 二个操作数
	cal4->Num1_ = 10;
	cal4->Num2_ = 2;
	cout << cal4->getResult() << endl; // 5

	system("pause");
	return 0;
}

优点：组织结构清晰；可读性强；对与前期和后期扩展以及维护性高

纯虚函数和抽象类

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

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

纯虚函数语法：virtual 返回值类型 函数名 (参数列表) = 0;

》》》当类中存在纯虚函数，这个类也称为抽象类

抽象类特点

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

程序举例

#include <iostream>
using namespace std;

// 抽象类
class Base {
public:
	// 纯虚函数
	virtual void func() = 0;
};

// 继承自抽象类却不重写纯虚函数故也是抽象类
class Son :public Base{

};

int main() {
	
	// Base b1; // Error！
	// 不能实例化抽象类 “Base” 因为 void Base::func(void)”: 是抽象的
	// Son s1; // Error！
	// 不能实例化抽象类 “Son” 因为 void Son::func(void)”: 是抽象的

	system("pause");
	return 0;
}

多态案例2 - 学科学习过程

#include <iostream>
using namespace std;

// 抽象类
class AbstractStudying {
public:
	// 1. 调整好心态
	virtual void AjustMind() = 0;
	// 2. 学习方法
	virtual void StudyMethod() = 0;
	// 3. 认真程度
	virtual void ConcernDegree() = 0;
	// 4. 回报
	virtual void Repay() = 0;

	// 类中函数全实现
	void doWork() {
		AjustMind();
		StudyMethod();
		ConcernDegree();
		Repay();
	}
};

// 数学类
class Math :public AbstractStudying{
public:
	// 重写纯虚函数
	// 1. 调整好心态
	virtual void AjustMind() {
		cout << "数学学习心态：10 分" << endl;
	}
	// 2. 学习方法
	virtual void StudyMethod() {
		cout << "数学学习方法：10 分" << endl;
	}
	// 3. 认真程度
	virtual void ConcernDegree() {
		cout << "数学认真程度：10 分" << endl;
	}
	// 4. 回报
	virtual void Repay() {
		cout << "数学学习回报：10 分" << endl;
	}
};

// 英语类
class English :public AbstractStudying{
public:
	// 重写纯虚函数
	// 1. 调整好心态
	virtual void AjustMind() {
		cout << "英语学习心态：10 分" << endl;
	}
	// 2. 学习方法
	virtual void StudyMethod() {
		cout << "英语学习心态：10 分" << endl;
	}
	// 3. 认真程度
	virtual void ConcernDegree() {
		cout << "英语学习心态：10 分" << endl;
	}
	// 4. 回报
	virtual void Repay() {
		cout << "英语学习心态：10 分" << endl;
	}
};

int main() {
	
	// 数学学习过程
	AbstractStudying *abs1 = new Math;
	abs1->doWork();

	cout << "-------------------" << endl;

	// 英语学习过程
	AbstractStudying *abs2 = new English;
	abs2->doWork();
	
	// outputs:数学学习心态：10 分
	//		   数学学习方法：10 分
	//		   数学认真程度：10 分
	//		   数学学习回报：10 分
	//		   -------------------
	//		   英语学习心态：10 分
	//		   英语学习心态：10 分
	//		   英语学习心态：10 分
	//		   英语学习心态：10 分

	system("pause");
	return 0;
}

虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用子类的析构函数，也就不能释放子类中开辟到堆区的属性

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

虚析构和纯虚析构共性

》》》可以解决父类指针释放子类对象

》》》都需要有具体的函数实现

虚析构和纯虚析构区别

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

程序举例

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

// 被纯虚析构函数修饰 -- 抽象类
class Animal {
public:
	Animal() {
		cout << "Animal 构造函数实现" << endl;
	}
	// 纯虚析构函数
	// 重点：无论是虚析构函数或是纯虚析构函数都需要在函数体有相关实现
	virtual ~Animal() = 0; // 错误实现：~Animal() = 0; 
	virtual void Speak() = 0;
};
// 在类外实现纯虚析构函数的相关实现
Animal::~Animal() {
	cout << "Animal 纯虚析构函数实现" << endl;
}

// 子类
class Cat :public Animal{
public:
	// 重写纯虚析构函数
	~Cat(){
		if (Name_ != NULL) {
			delete Name_;
			Name_ = NULL;
		}
		cout << "Cat 纯虚析构函数实现" << endl;
	}
	// 构造函数
	Cat(string name) {
		Name_ = new string(name);
		cout << "Cat 构造函数实现" << endl;
	}
	// 重写纯虚函数
	virtual void Speak() {
		cout << "小猫" << *Name_ << "在说话！" << endl;
	}
public:
	// 小猫名称
	string *Name_;
};

void func() {
	Animal *aml = new Cat("苏苏");
	// outputs:Animal 构造函数实现
	//		   Cat 构造函数实现
	aml->Speak(); // 小猫苏苏在说话！

	// 原始析构函数：父类指针在析构时不会调用子类的析构函数，导致堆区内存泄露
	// 新析构函数：也就是将父类析构函数改为虚析构函数或纯析构函数
	delete aml;
	// outputs:Cat 纯虚析构函数实现
	//		   Animal 纯虚析构函数实现
}

int main() {
	
	func();

	system("pause");
	return 0;
}

多态案例3 - 电脑组装

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

// 电脑零件产商 - Intel
class IntelCPU :public CPU{
public:
	// 重写父类中的纯虚函数
	virtual void Calculate() {
		cout << "Intel 的 CPU 开始工作了！" << endl;
	}
};
class IntelVideoCard :public VideoCard {
public:
	// 重写父类中的纯虚函数
	virtual void Display() {
		cout << "Intel 的 显卡 开始工作了！" << endl;
	}
};
class IntelMemory :public Memory {
public:
	// 重写父类中的纯虚函数
	virtual void Storage() {
		cout << "Intel 的 内存条 开始工作了！" << endl;
	}
};
// 电脑零件产商 - HP
class HPCPU :public CPU {
public:
	// 重写父类中的纯虚函数
	virtual void Calculate() {
		cout << "HP 的 CPU 开始工作了！" << endl;
	}
};
class HPVideoCard :public VideoCard {
public:
	// 重写父类中的纯虚函数
	virtual void Display() {
		cout << "HP 的 显卡 开始工作了！" << endl;
	}
};
class HPMemory :public Memory {
public:
	// 重写父类中的纯虚函数
	virtual void Storage() {
		cout << "HP 的 内存条 开始工作了！" << endl;
	}
};

// 电脑类
class Computer {
public:
	// 构造函数
	Computer(CPU *cpu, VideoCard * videocard, Memory *memory) {
		Cpu_ = cpu;
		Videocard_ = videocard;
		Memory_ = memory;
	}
	// 析构函数
	~Computer() {
		// 释放 CPU
		if (Cpu_ != NULL) {
			delete Cpu_;
			Cpu_ = NULL;
		}
		// 释放显卡
		if (Videocard_ != NULL) {
			delete Videocard_;
			Videocard_ = NULL;
		}
		// 释放内存条
		if (Memory_ != NULL) {
			delete Memory_;
			Memory_ = NULL;
		}
		cout << "电脑零件：CPU、显卡和内存条占用的堆区内存已被释放！" << endl;
	}
	// 提供工作的函数
	void Work() {
		Cpu_->Calculate();
		Videocard_->Display();
		Memory_->Storage();
	}
private:
	CPU *Cpu_; // CPU 的零件指针
	VideoCard * Videocard_; // 显卡的零件指针
	Memory *Memory_; // 内存条的零件指针
};


void func() {
	// 第一台电脑零件
	CPU *cpu = new HPCPU;
	VideoCard *videocard = new HPVideoCard;
	Memory *memory = new HPMemory;

	// 创建第一台电脑
	Computer *computer = new Computer(cpu, videocard, memory);
	// 电脑开始工作
	computer->Work();
	delete computer;
	// outputs:HP 的 CPU 开始工作了！
	//		   HP 的 显卡 开始工作了！
	//		   HP 的 内存条 开始工作了！
	//		   电脑零件：CPU、显卡和内存条占用的堆区内存已被释放！

	cout << "-----------------------------------------------" << endl;

	// 创建第二台电脑
	Computer *computer2 = new Computer(new IntelCPU, new IntelVideoCard, new IntelMemory);
	// 电脑开始工作
	computer2->Work();
	delete computer2;
	// outputs:Intel 的 CPU 开始工作了！
	//		   Intel 的 显卡 开始工作了！
	//		   Intel 的 内存条 开始工作了！
	//		   电脑零件：CPU、显卡和内存条占用的堆区内存已被释放！
}

int main() {
	
	func();

	system("pause");
	return 0;
}
是我来晚了！
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
C++基础之this指针与另一种“多态”
09-05
总的来说，`this`指针是C++中实现对象成员访问的关键机制，它使得成员函数能够与特定对象关联，而多态则允许我们通过基类接口来操作不同的派生类对象。从底层角度看，这些高级特性在汇编代码中表现为内存地址的跳转...
C++day15-多态 文档
10-28
在C++编程语言中，多态（Polymorphism）是一个核心特性，它允许我们使用一个接口来表示多种不同的类型，增强了代码的灵活性和可扩展性。在C++中，多态主要通过虚函数（Virtual Functions）和纯虚函数（Pure Virtual ...
C++ 多态
weixin_42325783的博客
09-02 166
本文章部分内容源于《黑马程序员C++ 核心篇》 1. 前言 突发奇想来回顾一下多态，顺便把继承和智能指针一起练习一下。多态的出现就是为了在封装和继承类以后，使调用类的时候更宽泛，把类里面的东西再向下一个类里面细分，最后再调用大类的时候，就可以将子类实现的功能一起搞出来。 众所周知多态的实现条件有两个： 有继承关系 子类重写父类中的虚函数 注意在子类重写父类成员函数(虚函数/纯虚函数)时，virtual可以省略，写了也没啥问题，我下面的代码里都没写。 多态使用时：父类指针或引用指向子类对象。因此这里涉及
C++虚函数、纯虚函数（抽象函数）
realfancy的博客
02-17 2277
虚函数 虚函数是C++实现动态多态的一种方式，可以使得父类指针指向子类对象，调用虚函数时是调用子类的同名成员函数。 而普通的成员函数没有这个特性，使用父类指针调用方法时无法调用子类函数。 虚函数在类的成员函数前用virtual关键字修饰，可以没有实现，子类也不一定要实现该方法。 如下，父类Animal中有虚函数fun()，子类为Cat和Dog；另一个父类Vehicle中的fun()为普通函数，子类为Car和Bicycle #include <iostream> using namespace s
#3 C++ 类和对象_多态
cheng_09的博客
05-29 110
1.多态的基本语法 1.动态多态满足条件： 有继承关系； 子类要重写（函数返回值、函数名、参数列表完全相同）父类的虚函数； 动态多态的使用： 父类的指针或者引用，执行子类对象 #include<iostream> using namespace std; class Animal { public: virtual void speak() { cout <&l...
多态
weixin_43767691的博客
07-16 102
多态： c++支持编译时多态（静态多态）和运行时多态（动态多态）。运算符重载和函数重载就是静态多态，而派生类和虚函数实现运行时多态。 静态多态和动态多态的区别就是函数地址的早绑定（静态联编）还是晚绑定（动态联编）。如果函数的调用，在编译阶段就可以确定函数的调用地址，并产生代码，就是静态多态，地址就是早绑定的。而如果函数的调用地址不能在编译期间确定，而需要运行时才决定，这就属于晚绑定。 #inclu...
C++ 类和对象-多态
qq_44836803的博客
11-15 629
多态的基本概念 多态是C++面向对象三大特性之一 多态分为两类 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名 动态多态: 派生类和虚函数实现运行时多态 静态多态和动态多态区别： 静态多态的函数地址早绑定 - 编译阶段确定函数地址 动态多态的函数地址晚绑定 - 运行阶段确定函数地址 #include<iostream> using namespace std; class Animal { public: void speak() { cout <
C++ 核心编程：4 类和对象（4）--- 多态
weixin_40064300的博客
05-18 237
4.7 多态 4.7.1 多态的基本概念 多态是C++面向对象三大特性之一 多态分为两类 静态多态：函数重载 和 运算符重载 属于静态多态，复用函数名 动态多态：派生类 和 虚函数 实现运行时多态 静态多态和动态多态的区别： 静态多态的函数地址早绑定 - 编译阶段确定函数地址 动态多态的函数地址晚绑定 - 运行阶段确定函数地址 下面通过案例进行讲解多态 #include<iostream> using namespace std; // 多态 // 动物类 class Animal
C++核心编程：P10-＞类和对象----多态
InnerPeaceHQ的博客
06-03 387
本系列文章为黑马程序员C++教程学习笔记，前面的系列文章链接如下 C++核心编程：P1-＞程序的内存模型 C++核心编程：P2-＞引用 C++核心编程：P3-＞函数提高 C++核心编程：P4-＞类和对象----封装 C++核心编程：P5-＞类和对象----对象的初始化和清理 C++核心编程：P6-＞类和对象----C++对象模型和this指针 C++核心编程：P7-＞类和对象----友元 C++核心编程：P8-＞类和对象----运算符重载 C++核心编程：P9-＞类和对象----继承多态例： 假设我们有个动
「地表最强」C++核心编程（十）类和对象--多态
B_White的博客
12-31 480
C++多态
10-多态.rar.rar.rar
10-19
总结来说，多态是面向对象编程的核心特性之一，它使得程序能够以更加灵活的方式处理不同类型的对象，提高了代码的可复用性和可扩展性。理解和熟练运用多态，对于提升编程能力及编写高质量代码至关重要。在实际编程...
4-多态.docx
10-14
多态性是面向对象编程的核心特性之一，它允许不同的对象对同一消息做出不同的响应。在C++中，多态性主要分为编译时的多态性和运行时的多态性。 1. **编译时多态性**：主要通过函数重载（Overload）实现。函数重载指...
C++面向对象技术之虚函数与多态
11-03
面向对象编程是C++的核心特性之一，它包括封装、继承和多态三个主要概念。在C++中，多态性是实现动态绑定的关键，允许不同的对象对同一消息作出不同的响应，增强了代码的灵活性和可扩展性。本篇将深入探讨C++中的虚...
【C++】类的默认成员函数，构造函数、析构函数、拷贝构造函数、运算符重载
2402_82757055的博客
08-10 898
这篇我们继续学习C++类和对象部分，大概会说一下类的一些默认成员函数，构造函数、析构函数、拷贝构造函数、赋值运算符重载这些知识。
C语言断言进阶篇：全面总结与实战技巧
极客代码
08-10 470
断言是一种用于验证程序中某个条件是否为真的语句。如果条件为假，程序会触发一个错误，通常会导致程序终止。断言主要用于开发和测试阶段，以帮助开发者发现和修正错误。在某些情况下，默认的assert宏可能无法满足我们的需求。if (!abort();= NULL);在这个自定义断言宏中，我们输出了更多的错误信息，包括失败的断言表达式、函数名、文件名和行号，方便我们定位错误。本文系统且全面地总结了C语言中的断言机制，包括断言的定义、作用、实现以及在实战中的运用。
【C语言】字符串操作函数详解
EleganceJiaBao的博客
08-14 490
这些头文件提供了字符串操作所需的函数声明。以下是常用字符串操作函数的详细讲解，包括每个函数的参数、返回值说明以及示例代码。每个函数的使用说明还包括了适当的表格以帮助理解其功能和用法。
C++_基本语法笔记_模板
最新发布
qq_45629864的博客
08-14 259
思想是Java里的泛型（不确定用什么类型的数据）这里template这一句，意思是声明T是泛型，后面写用到泛型T的函数。建议都用应用场景：不同数据类型的交换函数。
C语言常用关键字
Fearlessness的博客
08-14 393
C语言中常用的关键字
C++的内存分区
m0_63764282的博客
08-14 296
在C++中，程序的内存主要被分为几个不同的区域（或称为“分区”），这些区域用于存储不同类型的数据。
C++面向对象基础：类、继承与多态详解
C++面向对象核心语法是C++编程语言的重要组成部分，尤其对于初学者来说，理解并掌握这些概念至关重要。C++通过引入类、继承、多态性和重载等面向对象特性，实现了程序设计的模块化和灵活性。本章将深入讲解以下关键...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

是我来晚了！

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值