C++进阶篇，多态

已于 2023-01-11 23:28:28 修改
阅读量194 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2023-01-11 23:24:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chakming1/article/details/128652527
版权

C++进阶篇——多态

1. 多态的概念

多态的概念：从字面上理解，就是多种形态，具体一点就是，同一件事情，但是不同的人去做，会产生出不同的状态。

举例：

  • 买票**（是同一种票）**的行为，当普通人买票的时候，全价购买，当学生买票的时候，是半价购买，当军人买票的时候，是优先购买。
  • 支付宝扫码领红包，支付宝的策略就是，如果你是新人，或者你长期没有使用过支付宝支付，那么这个时候你的红包会特别大。但如果你是经常使用支付宝支付或者这个红包你已经领过很多次了，那么这个时候你的红包就会变小。意思就是，同样是扫码领红包这个动作，不同的人会产生不同的结果（红包），这也是一种多态行为。

2. 多态的定义和实现

2.1 多态的构成条件

多态是不同继承关系的类对象，去调用同一个函数，产生了不同的行为。

在继承中需要满足以下两个条件才会产生多态：

  1. 必须通过基类的指针或引用调用虚函数。
  2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。

在这里插入图片描述

在这里插入图片描述

#include <iostream>

using namespace std;

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票全价" << endl;
	}
};


class Student : public Person
{
public:
	// 派生类对基类的虚函数重写
	virtual void BuyTicket()
	{
		cout << "买票半价" << endl;
	}
};

// 通过基类的引用调用虚函数
void Func(Person& people)
{
	people.BuyTicket();
}


int main()
{
	Person Mike;
	Func(Mike); // 买票全价

	Student Johnson;
	Func(Johnson); // 买票半价
}
2.2 虚函数

虚函数，就是被virtual关键字所修饰的类成员函数称为虚函数。

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票全价" << endl;
	}
};
2.3 虚函数重写

虚函数重写（覆盖）：派生类有一个跟基类完全相同的虚函数（返回值类型、函数名字和参数列表完全相同），称为子类的虚函数重写了基类的虚函数。

注意：要区别于函数重载的概念，函数重载是指函数名相同，函数参数个数或者类型不同，然后可以存在多个相同名字的函数。

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票全价" << endl;
	}
};


class Student : public Person
{
public:
	// 派生类对基类的虚函数重写
    // 这里的virtual可以不添加，也可以构成重写，但是不推荐
	virtual void BuyTicket() 
	{
		cout << "买票半价" << endl;
	}
};

函数重写的两个例外：

  1. 协变（基类与派生类虚函数返回值类型不同）

    • 派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用，称为协变。

      class A {};
class B : public A {};

class Person 
{
public:
	virtual A* f() { return new A; }
};

class Student : public Person 
{
public:
	virtual B* f() { return new B; }
};

  2. 析构函数的重写（基类与派生类析构函数名字不同）

    • 如果基类的析构函数是虚函数，那么派生类的析构函数一定会构成重写，基类和派生类的析构函数必然名字不相同，但是编译器会对析构函数做特殊处理，统一处理成destructor。

      class Person 
{
public:
	virtual ~Person() {cout << "~Person()" << endl;}
};

class Student : public Person 
{
public:
	virtual ~Student() { cout << "~Student()" << endl; }
}
2.4 C++11 override和final

C++11提供了两个关键字override和final。

  1. final：修饰虚函数，表示该虚函数不可以被重写。

    class Car
{
public:
	virtual void Drive() final {} 
};

class Benz : public Car
{
public:
	virtual void Drive() { cout << "Benz" << endl; } // error
};

  2. override：检查派生类虚函数是否重写基类某个虚函数，如果没有，编译器报错。

    class Car
{
public:
	virtual void Drive() {} 
};

class Benz : public Car
{
public:
	virtual void Drive() override { cout << "Benz" << endl; } 
};
2.5 重载、覆盖（重写）、隐藏（重定义）的对比

在这里插入图片描述

3. 抽象类

3.1 概念

在虚函数的后面添加=0，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（接口类），抽象类不能实例化出对象。派生类必须重写纯虚函数。

class Car
{
public:
	virtual void Drive() = 0;
};

class Benz : public Car
{
public:
    virtual void Drive()
    {
    	cout << "Benz-舒适" << endl;
    }
};

class BMW : public Car
{
public:
    virtual void Drive()
    {
        cout << "BMW-操控" << endl;
    }
};

void Test()
{
    Car* pBenz = new Benz;
    pBenz->Drive();
    Car* pBMW = new BMW;
    pBMW->Drive();
}
3.2 接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

4. 多态的原理

4.1 虚函数表

我们先观察一道笔试题：sizeof(Base)是多少？

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
};

int main()
{
	Base b1;
}

首先，在我们不了解虚函数背后的多态机制时，我们可能以为这个类只占4个字节，其实这个类占8个字节。我们通过vs进行调试，发现该类除了包含一个_b的成员，还多了一个__vfptr，存的是一个地址，这个成员我们叫作虚函数表指针。

在这里插入图片描述

展开之后，我们看到这个表指针所指向的地址，存的是Base::Func1(void)这个虚函数中。

在这里插入图片描述

由此可知，包含虚函数的类除了存储自身的成员外，还会存储一个指向虚函数表的指针，在不同的平台下，指针的大小不同。因此，在我这个32位平台下，所得结果为8字节。

我们对代码进行改造：

class Base
{
public:
	virtual void Func1()
	{
		cout << "Base::Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "Base::Func2()" << endl;
	}
	void Func3()
	{
		cout << "Base::Func3()" << endl;
	}
private:
	int _b = 1;
};

class Derive : public Base
{
public:
	virtual void Func1()
	{
		cout << "Derive::Func1()" << endl;
	}
private:
	int _d = 2;
};

int main()
{
	Base b;
	Derive d;
	return 0;
}

在这里插入图片描述

我们进行一下总结：

  1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚 表指针也就是存在部分的另一部分是自己的成员。
  2. 类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
  3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
  4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。
  5. 总结一下派生类的虚表生成：
    • 先将基类中的虚表内容拷贝一份到派生类虚表中。
    • 如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数。
    • 派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
4.2 多态的原理

我们看回这个多态的例子，来理解一下多态的原理。

#include <iostream>

using namespace std;

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票全价" << endl;
	}
};


class Student : public Person
{
public:
	// 派生类对基类的虚函数重写
	virtual void BuyTicket()
	{
		cout << "买票半价" << endl;
	}
};

// 通过基类的引用调用虚函数
void Func(Person* people)
{
	people->BuyTicket();
}


int main()
{
	Person Mike;
	Func(&Mike); // 买票全价

	Student Johnson;
	Func(&Johnson); // 买票半价
}
  1. 下面的红色箭头表示，当people指向的是Mike对象的时候，在虚表找到的是Person::BuyTicket，也就是基类的虚函数。
  2. 下面的蓝色箭头表示，当people指向的是Johnson对象的时候，在虚表找到的是Student::BuyTicket，也就是派生类的虚函数。
  3. 因为派生类在重写了基类的虚函数，也会改变派生类虚函数表的内容，所以多态的本质就是调用对应的虚函数表的内容。
    在这里插入图片描述
4.3 动态绑定与静态绑定
  1. 静态绑定（早绑定）是指，在程序编译期间确定了程序的行为，也称为静态多态。比如：函数重载。
  2. 动态绑定（晚绑定）是指，在程序运行期间，根据具体类型确定程序的具体行为，也称为动态多态。

5. 单继承和多继承关系的虚函数表

5.1 单继承中的虚函数表
class Base {
public:
	virtual void func1() { cout << "Base::func1" << endl; }
	virtual void func2() { cout << "Base::func2" << endl; }
private:
	int a;
};
class Derive :public Base {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
	virtual void func4() { cout << "Derive::func4" << endl; }
private:
	int b;
};

int main()
{
	Base b;
	Derive d;

	return 0;
}

在这里插入图片描述

我们发现，vs有一个bug，我们在派生类的虚函数表无法看见func3()和func4()，也就是派生类单独的虚函数。所以我们写一个函数来观察。

typedef void(*VFPTR)(); // 返回值void，无参数的函数指针

void PrintVFTable(VFPTR* table)
{
	for (size_t i = 0; table[i] != nullptr; ++i)
	{
		printf("vft[%d]:->%p ", i, table[i]);
		VFPTR pf = table[i];
		pf();
	}
	cout << endl;
}

int main()
{
	Base b;
	Derive d;

	VFPTR* vTableb = (VFPTR*)(*(int*)&b);
	PrintVFTable(vTableb);

	VFPTR* vTabled = (VFPTR*)(*(int*)&d);
	PrintVFTable(vTabled);
	return 0;
}

有几个点需要注意：

  1. 我们知道类的首四个字节就是虚表的指针，所以我们对对象取地址并(int*)强转，在*解引用获取前四个字节的指针，传入到打印虚函数表函数中。
  2. 虚函数表本质上是一个存储虚函数指针的指针数组，最后一个放了一个nullptr。
  3. 打印虚表的代码经常会崩溃，这是因为编译器有时候对虚表处理不干胶，虚表最后没有放nullptr，导致越界，所以需要重新生成解决方案。
  4. 观察以下结果，我们能看到基类和派生类的虚表中的所有虚函数，并且派生类一旦重写了基类的虚函数，就会进行覆盖。

在这里插入图片描述

5.2 多继承中的虚函数表

class Base1 {
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1;
};
class Base2 {
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
	int b2;
};
class Derive : public Base1, public Base2 {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int d1;
};

typedef void(*VFPTR)(); // 返回值void，无参数的函数指针

void PrintVFTable(VFPTR* table)
{
	cout << " 虚表地址>" << vTable << endl;
    for (int i = 0; vTable[i] != nullptr; ++i)
    {
        printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
        VFPTR f = vTable[i];
        f();
    }
    cout << endl;
}


int main()
{
	Derive d;
	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
	PrintVFTable(vTableb1);
	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
	PrintVFTable(vTableb2);
	return 0;
}

在这里插入图片描述

由上图可得到以下结论：

我们看到在派生类中拥有Base1和Base2两个类的基表，Base1的基表存的是从覆盖了Base1的func1()、已经未重写的func2()和自身的func3()。Base2的基表存的是覆盖Base2的func1()和从Base2继承过来的func2()。

5.3 菱形继承、菱形虚拟继承

实际中我们不建议设计出菱形继承、菱形虚拟继承，一方面是太复杂容易出问题，另一方面其实虚表会带来一定的性能损耗。因此，这里不过多介绍。

CHAK&MING
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++进阶：多态
欧尼酱的技术园
07-29 309
文章目录前言一，多态的概念1.1 概念二，多态的定义及实现2.1 多态的构成条件2.2 虚函数2.3 虚函数的重写2.4 重载，覆盖（重写），隐藏（重定义）的对比三， 抽象类四，多态的原理4.1 虚函数表4.2 动态绑定与静态绑定五，常见问题总结 前言 本文章将为大家介绍多态的内容，多态是C++高级语法的核心部分，希望大家重视起来。 一，多态的概念 1.1 概念 多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。 例如：同样是扫码抢红包，不同的用户得到的
C++进阶（语法篇）
10-19
C++作为一门对象导向编程语言，在...通过本文对C++进阶语法的深入介绍，学习者可以逐步提升对这门复杂编程语言的理解和运用能力。无论是学习书籍推荐还是具体的知识点总结，都为C++的学习者提供了一条清晰的进阶之路。
C++进阶之多态
cls的博客
04-27 1542
多态的概念 概念：多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。 静态的多态:函数重载，看起来调用同一个函数有不同的行为。静态指的是在编译时实现的。 eg:流提取运算符的重载，自动识别不同的类型 动态的多态:一个父类的引用或者指针去调用同一个函数，传递不同的对象，会调用不同的函数。动态就是指运行时实现的。本质：不同的人去做同一件事情，结果不同 eg： class Person { public: virtual void Bu
C++进阶-多态
~
01-30 1867
【C++进阶学习】C++中的多态零、前言一、多态的概念和定义二、虚函数1、概念和定义2、虚函数重写的特例3、C++11 override 和 final4、重载/重写/重定义对比三、抽象类四、多态的原理1、虚函数表2、多态的原理3、动态绑定与静态绑定4、多继承虚函数表五、继承和多态常见的面试问题 零、前言 C++有五大特性：对象，封装，继承，抽象和多态。而本章则将学习讲解C++中的多态 一、多态的概念和定义 概念： 通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同
c++进阶之多态
2401_83052144的博客
08-17 886
继承和组合public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。优先使用对象组合，而不是类继承。继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。
【C++进阶】多态
Stark_Skywalker的博客
07-18 588
重写和重定义都发生在继承体系（即在不同的类），但重载只能在一个范围内（不能在不同类）重载允许同名函数有不同的参数列表。重写要求派生类中的函数与基类中的虚函数具有相同的原型。重定义允许派生类中的函数隐藏基类中的非虚函数，即使参数列表不同。在C++中，函数的原型（或签名）通常指的是函数名、参数列表（参数的类型和顺序），不包括返回类型和参数名称。
C++进阶—多态
一个努力拼搏的人
02-05 416
一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。
【C++进阶】多态详解
2301_78611726的博客
05-01 1042
多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价。那么在继承中要构成多态必须通过基类的指针或者引用调用虚函数被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。
(C++进阶) 多态
qq_57594025的博客
07-10 470
目录1. 多态的概念2. 多态的定义及实现2.1多态的构成条件2.2 虚函数2.3 虚函数的重写2.3.1 虚函数重写的两个例外2.4 C++11 override 和 fifinal2.5 重载、覆盖(重写)、隐藏(重定义)的对比2.6 多态示例3. 抽象类3.1 概念3.2 接口继承和实现继承4. 多态的原理4.1 虚函数表4.2 多态原理总结4.3 动态绑定与静态绑定5. 单继承和多继承关系中的虚函数表5.1 单继承中的虚函数表5.2 多继承中的虚函数表（1）多态是不同继承关系的类对象，去调用同一函数
C++程序设计-原理-与-实践第2版—进阶篇.pdf
03-27
《C++程序设计-原理与实践第2版—进阶篇》是一本深入探讨C++编程语言的专著，旨在帮助读者从基础知识过渡到高级概念和技术。这本书详细讲解了C++的核心特性，以及如何利用这些特性来编写高效、可维护的代码。在阅读...
编程实践：Visual C++进阶100例
03-13
本资料“编程实践：Visual C++进阶100例”旨在通过实际的编程案例帮助用户提升在Visual C++中的技能。 首先，让我们了解一下Visual C++的基本组成部分： 1. **编辑器**：提供了语法高亮、自动完成和错误检查等功能...
C++开发基于多态的公司职工管理系统(课设源码).zip
08-26
C++开发基于多态的公司职工管理系统(课设源码).zipC++开发基于多态的公司职工管理系统(课设源码).zipC++开发基于多态的公司职工管理系统(课设源码).zipC++开发基于多态的公司职工管理系统(课设源码).zipC++开发基于...
c++命令模式
最新发布
qq_71286244的博客
08-30 636
c++命令模式详细介绍
【C/C++】C++程序设计基础（输入输出、数据类型、动态内存、函数重载、内联函数、常量、引用）
强者征服今天，懦夫哀叹昨天，懒汉坐等明天。
08-28 2037
在后面的章节中，会讲到类与对象，欢迎各位的关注~
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 3277
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 8127
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
【C++ 面试 - 内存管理】每日 3 题（三）
Newin2020的博客
08-26 1438
栈就像我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。因为操作系统会在底层对栈提供支持，会分配专门的寄存器存放栈的地址，栈的入栈出栈操作也十分简单，并且有专门的指令执行，所以栈的效率比较高也比较快。栈顶和栈底是之前预设好的，栈是向栈底扩展，大小固定，可以通过 ulimit -a 查看，由 ulimit -s 修改。堆就像是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值