从C向C++8——多态

一.多态基础

面向对象程序设计语言有封装、继承和多态三种机制，这三种机制能够有效提高程序的可读性、可扩充性和可重用性。

“多态（polymorphism）”指的是同一名字的事物可以完成不同的功能。多态可以分为编译时的多态和运行时的多态。前者主要是指函数的重载（包括运算符的重载）、对重载函数的调用，在编译时就能根据实参确定应该调用哪个函数，因此叫编译时的多态；而后者则和继承、虚函数等概念有关。

1.多态

​ 我们之前知道基类的指针可以指向派生类对象，但是其中存在一个问题：通过基类指针只能访问派生类的成员变量，但是不能访问派生类的成员函数。大家可以自己写代码尝试确认，为了消除这种尴尬，让基类指针能够访问派生类的成员函数，C++增加了虚函数。使用虚函数非常简单，只需要在函数声明前面增加 virtual 关键字。

​ 有了虚函数，基类指针指向基类对象时就使用基类的成员（包括成员函数和成员变量），指向派生类对象时就使用派生类的成员。换句话说，基类指针可以按照基类的方式来做事，也可以按照派生类的方式来做事，它有多种形态，或者说有多种表现方式，我们将这种现象称为多态（Polymorphism）。

#include <iostream>
using namespace std;

//基类People
class People{
public:
    People(char *name, int age);
    virtual void display();  //声明为虚函数
protected:
    char *m_name;
    int m_age;
};
People::People(char *name, int age): m_name(name), m_age(age){}
void People::display(){
    cout<<m_name<<"今年"<<m_age<<"岁了，是个无业游民。"<<endl;
}

//派生类Teacher
class Teacher: public People{
public:
    Teacher(char *name, int age, int salary);
    virtual void display();  //声明为虚函数
private:
    int m_salary;
};
Teacher::Teacher(char *name, int age, int salary): People(name, age), m_salary(salary){}
void Teacher::display(){
    cout<<m_name<<"今年"<<m_age<<"岁了，是一名教师，每月有"<<m_salary<<"元的收入。"<<endl;
}

int main(){
    People *p = new People("王志刚", 23);
    p -> display();

    p = new Teacher("赵宏佳", 45, 8200);
    p -> display();

    return 0;
}

​ 上面的代码中，同样是p->display();这条语句，当 p 指向不同的对象时，它执行的操作是不一样的。同一条语句可以执行不同的操作，看起来有不同表现方式，这就是多态。多态是面向对象编程的主要特征之一，C++中虚函数的唯一用处就是构成多态。

​ C++提供多态的目的是：可以通过基类指针对所有派生类（包括直接派生和间接派生）的成员变量和成员函数进行“全方位”的访问，尤其是成员函数。如果没有多态，我们只能访问成员变量。

多态满足条件：

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

多态使用：父类指针或引用指向子类对象

2.引用实现多态

引用在本质上是通过指针的方式实现的，既然借助指针可以实现多态，那么我们就有理由推断：借助引用也可以实现多态。

修改上例中 main() 函数内部的代码，用引用取代指针：

int main(){
    People p("王志刚", 23);
    Teacher t("赵宏佳", 45, 8200);
   
    People &rp = p;
    People &rt = t;
   
    rp.display();
    rt.display();
    return 0;
}

运行结果：
王志刚今年23岁了，是个无业游民。
赵宏佳今年45岁了，是一名教师，每月有8200元的收入。

​ 由于引用类似于常量，只能在定义的同时初始化，并且以后也要从一而终，不能再引用其他数据，所以本例中必须要定义两个引用变量，一个用来引用基类对象，一个用来引用派生类对象。从运行结果可以看出，当基类的引用指代基类对象时，调用的是基类的成员，而指代派生类对象时，调用的是派生类的成员。

​ 不过引用不像指针灵活，指针可以随时改变指向，而引用只能指代固定的对象，在多态性方面缺乏表现力，所以以后我们再谈及多态时一般是说指针。

3.多态剖析

我们知道一个空类在C++中的大小是1，如果一个类只含有成员函数，它近似于一个空类，如果使用sizeof()关键字计算其大小，其结果是1。

那么就上面的例子，现在我们计算People类的大小，应该为56字节，其中string为40字节，而隐含的vfptr在x64环境下为8字节，分析以下Teachar的大小为64字节，注意VS的默认情况下是对齐方式的。

4.虚函数注意事项

C++虚函数对于运行时多态具有决定性的作用，有虚函数才能构成多态。

  1. 只需要在虚函数的声明处加上 virtual 关键字，函数定义处可以加也可以不加。

  2. 为了方便，你可以只将基类中的函数声明为虚函数，这样所有派生类中具有遮蔽关系的同名函数都将自动成为虚函数。

  3. 当在基类中定义了虚函数时，如果派生类没有定义新的函数来遮蔽此函数，那么将使用基类的虚函数。

  4. 只有派生类的虚函数覆盖基类的虚函数（函数原型相同）才能构成多态（通过基类指针访问派生类函数）。例如基类虚函数的原型为virtual void func();，派生类虚函数的原型为virtual void func(int);，那么当基类指针 p 指向派生类对象时，语句p -> func(100);将会出错，而语句p -> func();将调用基类的函数。

  5. **构造函数不能是虚函数。**对于基类的构造函数，它仅仅是在派生类构造函数中被调用，这种机制不同于继承。也就是说，派生类不继承基类的构造函数，将构造函数声明为虚函数没有什么意义。

  6. 析构函数可以声明为虚函数，而且有时候必须要声明为虚函数。

二.虚函数

1.纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容，因此可以将虚函数改为纯虚函数。
纯虚函数语法：

virtual 返回值类型 函数名 (函数参数) = 0;

当类中只要有了一个纯虚函数，这个类也称为抽象类。
抽象类特点：

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

2.虚析构

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

方法：将父类的析构函数改为虚析构或纯虚析构。

虚析构和纯虚析构共性：

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

虚析构和纯虚析构区别：

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

3.虚函数表

编译器之所以能通过基类指针指向的对象找到虚函数，是因为在创建对象时额外地增加了虚函数表。

如果一个类包含了虚函数，那么在创建该类的对象时就会额外地增加一个数组，数组中的每一个元素都是虚函数的入口地址。不过数组和对象是分开存储的，为了将对象和数组关联起来，编译器还要在对象中安插一个指针，指向数组的起始位置。这里的数组就是虚函数表（Virtual function table），简写为vtable。

其中某一多态的内存模型图，如图所示：

在这里插入图片描述

图中左半部分是对象占用的内存，右半部分是虚函数表 vtable。在对象的开头位置有一个指针 vfptr，指向虚函数表，并且这个指针始终位于对象的开头位置。

当通过指针调用虚函数时，先根据指针找到 vfptr，再根据 vfptr 找到虚函数的入口地址。

三.多态案例练习1

1.要求

写一个简单计算器。

2.实验代码

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

//基类
class Calculate {
public:
    int m_num1;
    int m_num2;
    //虚函数
    virtual int getresult() {
        return 0;
    }
};

//加法类计算器
class AddCalculate :public Calculate {
    int getresult() {
        return m_num1 + m_num2;
    }
};

//减法计算器
class SubCalculate :public Calculate {
    int getresult() {
        return m_num1 - m_num2;
    }
};


//乘法计算器
class MulCalculate :public Calculate {
    int getresult() {
        return m_num1 * m_num2;
    }
};


//除法计算器
class DivCalculate :public Calculate {
    int getresult() {
        return m_num1 / m_num2;
    }
};
int main() {

    Calculate* p = new AddCalculate;
    p->m_num1 = 20;
    p->m_num2 = 10;
    cout << p->m_num1 << "+" << p->m_num2 << "=" << p->getresult() << endl;

    return 0;
}

3.总结

多态的优点

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

四.多态案例练习2

1.题目

案例描述：

​ 电脑主要组成部件为 CPU (用于计算) ，显卡 (用于显示) ，内存条 (用于存储)。将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如intel厂商和Lenovo厂商，创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口。测试时组装三台不同的电脑进行工作 。

在这里插入图片描述

2.实验代码

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

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/388892.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Linux之动静态库

Linux之动静态库

今天我们来讲动静态库&#xff01; 首先我们来粗粒度的划分一下动态库和静态库。 动态库就是只有一份库文件&#xff0c;所有想用该库的文件与改库文件建立链接&#xff0c;然后使用。这样可以提高代码复用率&#xff0c;避免重复拷贝产生没必要的内存消耗。 静态库&#xf…
阅读更多...
京东购物拉新保姆级教程

京东购物拉新保姆级教程

您好&#xff0c;我是码农飞哥&#xff08;wei158556&#xff09;&#xff0c;感谢您阅读本文&#xff0c;欢迎一键三连哦。&#x1f4aa;&#x1f3fb; 1. Python基础专栏&#xff0c;基础知识一网打尽&#xff0c;9.9元买不了吃亏&#xff0c;买不了上当。 Python从入门到精通…
阅读更多...
【Java多线程】Thread类的基本用法

【Java多线程】Thread类的基本用法

目录 Thread类 1、创建线程 1.1、继承 Thread&#xff0c;重写run 1.2、实现 Runnable&#xff0c;重写run 1.3、使用匿名内部类&#xff0c;继承 Thread&#xff0c;重写run 1.4、使用匿名内部类&#xff0c;实现 Runnable&#xff0c;重写run 1.5、使用 lambda 表达式…
阅读更多...
如何在30天内使用python制作一个卡牌游戏

如何在30天内使用python制作一个卡牌游戏

如何在30天内使用python制作一个卡牌游戏 第1-5天&#xff1a;规划和设计第6-10天&#xff1a;搭建游戏框架第11-20天&#xff1a;核心游戏机制开发第21-25天&#xff1a;游戏界面和用户体验第26-30天&#xff1a;测试和发布附加建议游戏类型游戏规则设计界面设计技术选型第6-…
阅读更多...
Qt：自定义信号，信号emit，传参问题，信号槽与moc

Qt：自定义信号，信号emit，传参问题，信号槽与moc

一、自定义信号&#xff0c;信号emit 1、自定义信号 在头文件中 加入signals&#xff1a; 就可以编写信号 2、emit emit的作用是通知信号发生 二、跨UI控件传参 每次按Dialog添加按钮主控件数字会增长 // .h private slots:void on_btnAdd_clicked(); signals:void sign…
阅读更多...
Rust 数据结构与算法：5栈：用栈实现前缀、中缀、后缀表达式

Rust 数据结构与算法：5栈：用栈实现前缀、中缀、后缀表达式

3、前缀、中缀和后缀表达式 计算机是从左到右处理数据的&#xff0c;类似(A (B * C))这样的完全括号表达式&#xff0c;计算机如何跳到内部括号计算乘法&#xff0c;然后跳到外部括号计算加法呢&#xff1f; 一种直观的方法是将运算符移到操作数外&#xff0c;分离运算符和操…
阅读更多...
【Java从入门到精通】Java变量命名规则

【Java从入门到精通】Java变量命名规则

Java 变量命名规则 在 Java 中&#xff0c;不同类型的变量&#xff08;例如实例变量、局部变量、静态变量等&#xff09;有一些命名规则和约定。 遵循一些基本规则&#xff0c;这有助于提高代码的可读性和维护性。 以下是各种变量命名规则的概述&#xff1a; 使用有意义的名…
阅读更多...
第13章 网络 Page733 “I/O对象”的链式传递 单独的火箭发射函数

第13章 网络 Page733 “I/O对象”的链式传递 单独的火箭发射函数

把main函数中火箭发射代码挪走一些&#xff0c;构成一个单独的火箭发射函数launch_rocket()&#xff0c;如下图所示&#xff1a; 代码&#xff1a; 之所以没有将io_service对象也挪到launch_rocket()函数中&#xff0c;是因为正常的asio程序肯定还会有大量的其他异步操作需要这…
阅读更多...
C++ 图上 bfs（五十八）【第五篇】

C++ 图上 bfs（五十八）【第五篇】

今天我们来学习一下图上bfs。 1.图上bfs 在图上&#xff0c;我们也可以进行 BFS&#xff0c;也可以解决图上 DFS 能解决的问题&#xff0c;比如连通块。 除此以外&#xff0c;根据 BFS 的性质&#xff0c;第一次到一个点的时候记下来的步数一定是到从起点到这个点的最小步数&…
阅读更多...
Linux第56步_根文件系统第3步_将busybox构建的根文件系统烧录到EMMC

Linux第56步_根文件系统第3步_将busybox构建的根文件系统烧录到EMMC

1、第1次将“rootfs”打包 1)、打开第1个终端&#xff0c;准备在“mnt”目录下创建挂载目录“rootfs”&#xff1b; 输入“ls回车” 输入“cd /mnt回车” 输入“ls回车”&#xff0c;查看“mnt”目录下的文件和文件夹 输入“sudo mkdir rootfs回车”&#xff0c;在“mnt”…
阅读更多...
核心篇-OSPF技术之序（下）

核心篇-OSPF技术之序（下）

文章目录 一. 实验专题1.1. 实验1&#xff1a;配置OSPF特殊区域1.1.1. 实验目的1.1.2. 实验拓扑图1.1.3. 实验步骤&#xff08;1&#xff09;配置IP地址&#xff08;2&#xff09;创建环回口&#xff08;3&#xff09;查看路由表&#xff08;4&#xff09;设置Stub区域&#xf…
阅读更多...
(10)Hive的相关概念——文件格式和数据压缩

(10)Hive的相关概念——文件格式和数据压缩

目录 一、文件格式 1.1 列式存储和行式存储 1.1.1 行存储的特点 1.1.2 列存储的特点 1.2 TextFile 1.3 SequenceFile 1.4 Parquet 1.5 ORC 二、数据压缩 2.1 数据压缩-概述 2.1.1 压缩的优点 2.1.2 压缩的缺点 2.2 Hive中压缩配置 2.2.1 开启Map输出阶段压缩&…
阅读更多...
[OPEN SQL] 修改数据

[OPEN SQL] 修改数据

MODIFY语句用于修改数据库表中的数据 MODIFY拥有INSERT和UPDATE的操作&#xff0c;如果数据库表中不存在符合条件的数据则会添加该条新数据&#xff0c;反之数据库表中存在符合条件的数据则会更新该条数据 本次操作使用的数据库表为SCUSTOM&#xff0c;其字段内容如下所示 航…
阅读更多...
Mysql运维篇（四） Xtarbackup--备份与恢复练习

Mysql运维篇（四） Xtarbackup--备份与恢复练习

一路走来&#xff0c;所有遇到的人&#xff0c;帮助过我的、伤害过我的都是朋友&#xff0c;没有一个是敌人。如有侵权&#xff0c;请留言&#xff0c;我及时删除&#xff01; 前言 xtrabackup是Percona公司CTO Vadim参与开发的一款基于InnoDB的在线热备工具&#xff0c;具有…
阅读更多...
力扣例题----二叉树

力扣例题----二叉树

文章目录 1. 100.相同的树2. 572. 另一颗树的子树3. 266.翻转二叉树4. LCR 175.计算二叉树的深度5. 110.平衡二叉树6. 101. 对称二叉树7. 牛客题目&#xff1a;KY11 二叉树遍历8. 102.二叉树的层序遍历9. 236.二叉树的最近公共祖先10. 105.根据前序和中序构造一棵二叉树11. 106…
阅读更多...
Rust - 切片Slice

Rust - 切片Slice

Slice类型 Slice数据类型没有所有权&#xff0c;slice允许我们引用集合中一段连续的元素序列而不用引用整个集合。字符串slice(string slice) 是String中 一部分值的引用。如下述代码示例&#xff0c;不是对整个String的引用而是对部分String的引用&#xff1a; fn main() {l…
阅读更多...
ESP32学习（1）——环境搭建

ESP32学习（1）——环境搭建

使用的ESP32板子如下图所示 它可以用Arduino 软件&#xff0c;基于C语言开发。但是&#xff0c;在这里&#xff0c;我是用Thonny软件&#xff0c;基于micro_python对其进行开发。 1.安装Thonny Thonny的软件安装包&#xff0c;可以去它官网上下载。Thonny, Python IDE for begi…
阅读更多...
leetcode 160 相交链表

leetcode 160 相交链表

题目 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 注意&#xff0c;函数返回结…
阅读更多...
09、全文检索 -- Solr -- SpringBoot 整合 Spring Data Solr （生成DAO组件 和 实现自定义查询方法）

09、全文检索 -- Solr -- SpringBoot 整合 Spring Data Solr （生成DAO组件 和 实现自定义查询方法）

目录 SpringBoot 整合 Spring Data SolrSpring Data Solr的功能&#xff08;生成DAO组件&#xff09;&#xff1a;Spring Data Solr大致包括如下几方面功能&#xff1a;Query查询&#xff08;属于半自动&#xff09;代码演示&#xff1a;1、演示通过dao组件来保存文档1、实体类…
阅读更多...
Flutter Android开发 梳理Google Material Design颜色体系

Flutter Android开发 梳理Google Material Design颜色体系

前言 做安卓开发&#xff08;Kotlin语言&#xff09;&#xff0c;Flutter开发的人员应该都听说过谷歌一直推崇的Material Design&#xff0c;而Material Design Color是其推崇的颜色体系&#xff0c;具体来说&#xff0c;Material Design Color是一套旨在帮助设计师和开发者创…
阅读更多...
最新文章

Copyright @ 2022~2023