C++多态

原创 已于 2024-05-26 22:52:38 修改 · 423 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

于 2024-05-26 17:14:15 首次发布

多态

1. 多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
例如：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。

2. 多态的定义以及实现

2.1 多态构成条件

多态是在不同继承关系的类对象，去调用同一函数，并产生了不同的行为。
想要构成多态需要满足三个条件：

  1. 两个类必须是继承关系
  2. 必须通过基类的指针或者引用去调用虚函数
  3. 被调用的必须为虚函数，并且在派生类中必须对虚函数进行重写。
class Person {
public:
 virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
 virtual void BuyTicket() { cout << "买票-半价" << endl; }
void Func(Person& p)
{ 
  p.BuyTicket(); 
}

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 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;}
};
  1. 析构函数的重写（基类与派生类的析构函数名不同）
    若基类的析构函数为虚函数，这时只要派生类只要定义析构函数，无论加不加virtual都与基类的析构函数都构成重写，虽然基类与派生类析构函数的名字不同。其实在这里编译器对析构函数做了特殊处理，编译后的析构函数名称都为destructor。
class Person {
public:
 virtual ~Person() {cout << "~Person()" << endl;}
};
class Student : public Person {
public:
 virtual ~Student() { cout << "~Student()" << endl; }
};
// 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
 Person* p1 = new Person;
 Person* p2 = new Student;
 delete p1;
 delete p2;
 return 0;
}
  1. 派生类虚函数重写可以不加virtual 。（建议：派生类的虚函数都加上virtual）

例题：以下程序输出结果是什么（）
A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

class A
   {
   public:
       virtual void func(int val = 1){ std::cout<<"A->"<< val <<std::endl;
       virtual void test(){ func();}
   };
   
   class B : public A
   {
   public:
       void func(int val=0){ std::cout<<"B->"<< val <<std::endl; }
   };
   
   int main(int argc ,char* argv[])
   {
       B*p = new B;
       p->test();
       return 0;
   }

答案：B
原因是虚函数的重写，重写的是函数体的实现。函数的结构部分（函数名参数返回值等）用的都是父类的。

2.4 override 和 final

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

在这里插入图片描述

  • override：检查派生类的某个虚函数是否重写了，若没有则编译报错。
    在这里插入图片描述

2.5 重载、重写（覆盖）和重定义（隐藏）的对比

重载 ：

  • 两个函数在同一个作用域下
  • 函数名相同、参数不同

重写（覆盖） ：

  • 两个函数分别在基类和派生类
  • 函数名、参数、返回值必须相同（协变除外）
  • 两个函数都为虚函数

重定义（隐藏）：

  • 两个函数分别在基类和派生类中
  • 函数名相同
  • 两个函数基类和派生类中的两个同名函数不构成重写就是重定义

3. 多态的原理

虚函数指针和虚函数表

首先我们来看一则代码并计算一下sizeof(Base)的大小：

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

通过监视窗口我们发现b对象是8bytes，除了b成员之外还有一个_vfptr放在前面，对象中的这个指针我们叫做虚函数表指针。每个含有虚函数的类中都至少有一个虚函数表指针，因为虚函数的地址都要放到虚函数表（虚表）中。
在这里插入图片描述
为了近一步的了解虚函数表，观察以下代码：

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

通过监视窗口我们可以发现，基类和派生类中除了本身函数的成员外，都有一个虚表指针，这个虚表指针指向的各自类的虚表。虚函数表存放的是各自类中虚函数的地址。

对象 d 虽然继承了 b对象中Func()1 和Func()2 ,但是d对Func1()进行了重写。所以我们在监视窗口看到 d对象的虚表中存放的是重写的Func1()和Func2()。这里解释了为什么重写也叫做覆盖，覆盖就是对虚表中的虚函数地址的覆盖。

注意： 虚表中只存放虚函数的地址，其他的成员函数不能进虚表中。虚函数表本身就是一个存放指针的指针数组，一般情况下这个数组最后一个元素为nullptr。
虚表
在这里插入图片描述

原理

下面代码中Person对象Mike 和Student对象Johnson传参给p ，调用的BuyTicket却不同。
多态是如何实现的呢？

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
private:
	int _i = 1;
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
private:
	int _j = 2;
};
void Func(Person* p)
{
	p->BuyTicket();
}
int main()
{
	Person Mike;
	Func(&Mike);

	Student Johnson;
	Func(&Johnson);

	return 0;
}

在这里插入图片描述

通过监视窗口我们发现，对象Mike中有虚表指针和成员变量_i，对象Johnson中有两个成员变量和虚表指针，并都指向各自的虚函数表。

当Mike传参给p时，p->BuyTicket会在Mike虚表中找到对应的虚函数Person::BuyTicket。

当Johnson传参给p时，p->BuyTicket会在Johnson虚表中找到对应的虚函数Student::BuyTicket。

这样就实现了不同对象去做同一件事情，表现出不同的状态。

动态绑定与静态绑定
  1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
  2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

接下来我们可以从汇编的角度更加深入理解动态绑定和静态绑定
不满足多态
代码：

class Person {
public:
	 void BuyTicket() { cout << "买票-全价" << endl; }
private:
	int _i = 1;
};
class Student : public Person {
public:
	 void BuyTicket() { cout << "买票-半价" << endl; }
private:
	int _j = 2;
};

int main()
{
	Person p;
	Student  s;
	p = s;
	p.BuyTicket();
	return 0;
}

通过调试查看汇编码，发现只有两条汇编指令，并且是在程序编译是就确定的。
在这里插入图片描述
满足多态
代码：

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
private:
	int _i = 1;
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
private:
	int _j = 2;
};
void Func(Person* p)
{
	p->BuyTicket();
}
int main()
{
	
	Student  s;
	Person* p = &s;

	p->BuyTicket();
	return 0;
}

通过调试发现，相对于不构成多态所生成的汇编指令，这里生成的汇编指令更多。原因是程序在运行时，还要在对象的虚表中找到所调用的虚函数。这里就体现了动态绑定是在运行时确定的。
在这里插入图片描述

4. 抽象类

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。

class Car
{
public:
virtual void Drive() = 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;
 }
};

接口继承和实现继承

  1. 普通函数继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。
  2. 虚函数的继承的是一种接口继承，派生类继承的是基类虚函数的接口，目的就是重写虚函数，实现多态，继承的是接口。

5. 单继承中的虚函数

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

在这里插入图片描述
通过监视窗口我们发现对象d中的虚表跟我们想象的不一样，虚表中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数，解决这个问题有两种办法一是通过调试查看内存窗口、二是使用指针的方式打印虚表中的内容。
法一：
在这里插入图片描述
法二：

typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
	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);
	PrintVTable(vTableb1);

	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
	PrintVTable(vTableb2);

	return 0;
}

6. 多继承中的虚函数

既然有单继承自然也就有多继承，那我们思考一下？多继承的派生类有几个虚表？派生类中的自身虚函数放在那个虚表中？

运行以下代码：

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 PrintVTable(VFPTR vTable[])
{
 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);
 PrintVTable(vTableb1);
 VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d+sizeof(Base1)));
 PrintVTable(vTableb2);
 //通过切片的方式
 Base2* b2 = &d;
 VFPTR* vTableb2 = (VFPTR*)(*(int*)(b2));
 PrintVTable(vTableb2);
 return 0;
}

在这里插入图片描述
通过运行结果来看多继承派生类中的虚函数地址放在第一个继承基类部分的虚表中。

7. 继承和多态的有关问题

  1. 什么是多态？答：就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
  2. 什么是重载、重写(覆盖)、重定义(隐藏)？答：重载：在同一作用域中、函数名相同、参数不同。重写：在不同作用域中、函数名、参数、返回值（协变除外）相同、都为虚函数。 重定义：在不同作用域中、函数名相同即可、两个函数基类和派生类中的两个同名函数不构成重写就是重定义。
  3. 多态的实现原理？答：通俗点来说就是到指向对象的虚表中找虚函数调用，指向父类调用父类的虚函数，指向子类调用子类的虚函数。
  4. inline函数可以是虚函数吗？答：可以，不过编译器就忽略inline属性，这个函数就不再是 inline，因为虚函数要放到虚表中去。
  5. 静态成员可以是虚函数吗？答：不能，因为静态成员函数没有this指针，使用类型::成员函数 的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
  6. 构造函数可以是虚函数吗？答：不能，因为对象中的虚函数表指针是在构造函数初始化列表 阶段才初始化的。
  7. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？答：可以，并且最好把基类的析 构函数定义成虚函数。
  8. 对象访问普通函数快还是虚函数更快？答：首先如果是普通对象，是一样快的。如果是指针 对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函 数表中去查找。
  9. 虚函数表是在什么阶段生成的，存在哪的？答：虚函数表是在编译阶段就生成的，一般情况 下存在代码段(常量区)的。
  10. C++菱形继承的问题？虚继承的原理？答：菱形继承会导致子类中会用两份父类成员，因此会出现数据冗余和二义性的问题。虚基类只会在派生类中存放一份，通过虚基表中的偏移量找到并访问虚基类成员。
  11. 什么是抽象类？抽象类的作用？答：抽象类强制重写了虚函数，另外抽 象类体现出了接口继承关系。
BoJerry777
关注
C++多态详解
zjxuec的博客
09-17 1582
1.必须基类指针或者引⽤调⽤虚函数 2.被调⽤的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。这两个条件缺一不可，缺少了任何一个都不能实现多态，如果不是基类的指针或引用调用虚函数，那便指向不了派生类，而派生类没有重写基类的虚函数，派生类就没有不同的函数，多态的不同形态效果就达不到，也就无法实现多态。如上图所示，Student类的虚函数重写了基类Person的虚函数，且调用虚函数的都是基类的引用或指针，那么这就构成了多态，指向哪个对象，就调用哪个对象的虚函数。结果:我们在上面提到了虚函数，接下来我们来
C++ 多态
cp
10-29 1888
介绍什么是多态、虚函数、抽象类、虚表和虚表指针
C++ 多态 超详细讲解
热门推荐
qq_53558968的博客
05-18 5万+
文章目录多态概念引入1、C++中多态的实现1.1 多态的构成条件1.2 虚函数1.3虚函数的重写1.4 C++11 override && final1.5 重载，覆盖(重写)，重定义（隐藏）2、抽象类2.1 抽象类的概念2.2 接口继承和实现继承3、 多态的原理3.1 虚函数表3.2多态的原理3.3动态绑定与静态绑定4 、继承中的虚函数表4.1 单继承中的虚函数表4.2 多继承中的虚函数表other 一些有意思的题目 多态概念引入 多态字面意思就是多种形态。 我们先来想一想在日常生活中
C++多态的用法详解
分享学习的知识，记录我的技术成长道路
04-23 1万+
C++多态是在继承的基础上实现的，了解多态之前我们需要掌握一定的C++继承的知识，本文将介绍C++中多态的概念，构成条件以及用法。
c++多态 详解
none
03-09 1541
综上：如果满足多态，看指向对象的类型，调用这个类型的成员函数如果不满足多态， 看调用者类型，调用这个类型的成员函数解释：满足多态的情况下，我们定义Parent * p= new student，这个会调用Student的发生重写的函数我们定义Parent *p =new Parent ，这个会调用Parent中被重写的函数不满足多态的情况下，我们定义Student *s =new Student，这个会调用Student的函数。
C++多态（超级详细版）
kkbca的博客
10-28 1万+
在继承中要构成多态还有两个条件：1. 必须通过基类的指针或者引用调用虚函数2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写public:virtual void BuyTicket() { cout
C++ 多态类型
索命的博客
11-06 774
C++ 多态入门
C++ 多态详解
2402_86037826的博客
02-21 1189
详解 C++ 多态
深入理解C++多态
m0_69520125的博客
04-03 1217
多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了 Person。Person对象买票全价，Student对象买票半价。那么在继承中要构成多态还有两个条件1. 必须通过基类的指针或者引用调用虚函数2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写这里通过基类引用接收不同派生类对象时，虽然从代码表面看是调用父类函数，但实际会根据对象的实际类型动态选择对应的函数实现。在虚函数的后面写上 =0 ，则这个函数为纯虚函数。
C++多态Demo
05-01
这个“C++多态Demo”示例中，我们看到长方形和三角形作为形状（Shape）类的派生类，体现了面向对象编程中的继承和多态概念。 首先，让我们来理解一下基础的面向对象概念： 1. **类（Class）**: 类是创建对象的蓝图...
C++多态(Polymorphism)
TU^的博客
09-24 1539
1.多态的构成条件多态是⼀个继承关系的下的类对象，去调用同⼀函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象优惠买票。必须指针或者引用调用虚函数被调用的函数必须是虚函数。说明：要实现多态效果，第⼀必须是基类的指针或引用，因为只有基类的指针或引用才能既指向派生类对象；第⼆派生类必须对基类的虚函数重写/覆盖，重写或者覆盖了，派生类才能有不同的函数，多态的不同形态效果才能达到。2.虚函数。
Parasoft C/C++test如何解决在VC6环境中单元测试的LNK2005错误
2501_91602431的博客
11-05 473
Parasoft C/C++test是一款专为C/C++代码设计的自动化测试工具，通过静态代码分析、单元测试和运行时错误检测等功能，帮助开发团队在早期发现并修复缺陷，提升代码质量和开发效率 。在实际使用中，尤其是在VC6此类旧版开发环境中执行单元测试时，可能会因环境兼容性问题触发链接错误。
【穿越Effective C++】条款13：以对象管理资源——RAII原则的基石
沐怡旸的专栏
11-05 1017
这个条款揭示了C++资源管理的核心理念：通过对象的生命周期自动管理资源，避免手动资源管理带来的泄漏和错误。这是C++最重要的设计原则之一，也是现代C++编程的基石。
C Primer Plus 12.9 编程练习
Auroruaur0rua的博客
11-05 224
【代码】C Primer Plus 12.9 编程练习。
LeetCode 面试经典 150_二叉树_翻转二叉树（69_226_C++_简单）(DFS)
最新发布
huayimenghan的博客
11-07 401
LeetCode 面试经典 150_二叉树_翻转二叉树（69_226_C++_简单） 题目描述： 给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
从零开始c++精讲：第六篇——Vector
m0_57180439的博客
11-04 448
vector是表示可变大小数组的序列容器。就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是。
C语言内功强化之goto
qq_55794426的博客
11-03 191
goto语句可以直接跳转到自己定义的标签位置执行。他可能导致代码不易理解和维护，但有时候它可以用于一些特殊的控制流需求。建议：在同一个函数内部使用。不要再不同的函数直接跳转。
c++多态
03-08
C++多态允许通过基类接口来操作派生类对象，使得程序具有更大的灵活性和扩展性。下面给出两个示例以展示这种特性： 利用`virtual`关键字声明虚函数支持动态绑定[^2] ```cpp #include using namespace std; class...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值