『C++』多态

最新推荐文章于 2024-03-09 11:04:25 发布
最新推荐文章于 2024-03-09 11:04:25 发布
阅读量172 收藏
点赞数 2
分类专栏： 『C++』 文章标签： C++ 多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sss_0916/article/details/93461904
版权

多态的简单介绍

概念

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

定义

多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票时全价，Student对象买票半价。
在继承中要构成多态还有两个条件：

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

在这里插入图片描述

虚函数

虚函数：被virtual修饰的类的成员函数称为虚函数。

class Person{
public:
	virtual void BuyTicket() const{
		std::cout << "全价！" << std::endl;
	}
};

虚函数的重写

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

#include <iostream>
#include <stdlib.h>

class Person{
public:
	virtual void BuyTicket() const{
		std::cout << "全价！" << std::endl;
	}
};

class Student : public Person{
public:
	// 此处不加virtual，也可以构成重写
	// （因为继承后基类的虚函数被继承下来了在派生类中依旧保持虚函数属性）
	// 但是这样不规范，不建议使用。
	// 其实是为了照顾析构函数，因为有的析构函数可能不会显式定义，没办法给virtual
	virtual void BuyTicket() const{
		std::cout << "半价！" << std::endl;
	}
};

void Func(const Person& p){
	p.BuyTicket();
}

int main(){

	Person p;
	Func(p);

	Student s;
	Func(s);
	
	system("pause");
	return 0;
}

虚函数重写的两个例外

  1. 协变（基类与派生类虚函数返回值类型不同）
    派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。
    在这里插入图片描述
  2. 析构函数的重写（基类与派生类析构函数的名字不同）
    如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名字做了特殊处理，编译后析构函数的名字统一处理成destructor。
    在这里插入图片描述
    在这里插入图片描述

C++11 override和final

从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重写，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

  • final关键字：修饰虚函数，表示该虚函数不能被重写。
    在这里插入图片描述
  • override关键字：检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。
    在这里插入图片描述

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

在这里插入图片描述

抽象类

在虚函数的后面加上=0，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

#include <iostream>
#include <stdlib.h>

class Animal{
public:
	virtual void action() = 0;
};

class Dog : public Animal{
public:
	virtual void action(){
		std::cout << "汪汪汪~~" << std::endl;
	}
};

class Cat : public Animal{
public:
	virtual void action(){
		std::cout << "喵喵喵~~" << std::endl;
	}
};

int main(){

	Dog dog;
	dog.action();

	Cat cat;
	cat.action();

	system("pause");
	return 0;
}

在这里插入图片描述

接口继承和实现继承

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

多态的原理

先来看一个问题，下面这个类的大小是多少？

#include <iostream>
#include <stdlib.h>

class Base{
public:
	virtual void func(){
		std::cout << "func()" << std::endl;
	}

private:
	int _b = 1;
};

int main(){

	Base b;
	std::cout << "sizeof(b): " << sizeof(b) << std::endl;

	system("pause");
	return 0;
}

在这里插入图片描述
从上面运行结果可以看出，对象b的大小为8bytes，除了_b成员，对象中还有什么呢，下面我们来调试看一下。
在这里插入图片描述
通过调试，我们发现除了_b成员，还多了一个_vfptr放在对象的前面（与编译器有关，别的编译器可能会放在对象的后面），对象中的这个指针我们叫做虚函数表指针（v代表virtual，f代表function）。一个含有虚函数的类中都至少有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称为虚表，那么派生类中这个表放了些什么呢？
我们对前面的代码略作修改。

#include <iostream>
#include <stdlib.h>

class Base{
public:
	virtual void func1(){
		std::cout << "Base::func1()" << std::endl;
	}

	virtual void func2(){
		std::cout << "Base::func2()" << std::endl;
	}

	void func3(){
		std::cout << "Base::func3()" << std::endl;
	}

private:
	int _b = 1;
};

class Derive : public Base{
public:
	virtual void func1(){
		std::cout << "Derive::func1()" << std::endl;
	}

private:
	int _d = 2;
};

int main(){

	Base b;

	Derive d;

	system("pause");
	return 0;
}

调试观察。
在这里插入图片描述
总结：

  1. 基类b对象和派生类d对象的虚表是不一样的，我们发现func1完成了重写，所以d的虚表中存的是重写的Derive::func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法上的叫法，覆盖是原理上的叫法。
  2. func2继承下来后是虚函数，所以放进了虚表，func3也继承下来了，但是不是虚函数，所以不会放进虚表。
  3. 虚函数表本质是一个村虚函数指针的指针数组，这个数组最后面放了一个nullptr。
  4. 派生类的虚表生成：①先将基类中的虚表内容拷贝一份到派生类虚表中。②如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数。③派生类自己新增加的虚函数按其派生类中声明次序增加到派生类虚表的最后。
  5. 虚函数存在哪？虚表存在哪？
    虚表中存的是虚函数的指针，不是虚函数。虚函数和普通函数一样，都在代码段。只是它的指针存在了虚表中。对象中存的不是虚表，存的是虚表指针。我们可以验证一下虚表是存在哪的？
#include <iostream>
#include <stdlib.h>

class Base{
public:
	virtual void func1(){
		std::cout << "Base::func1()" << std::endl;
	}

	virtual void func2(){
		std::cout << "Base::func2()" << std::endl;
	}

	void func3(){
		std::cout << "Base::func3()" << std::endl;
	}

private:
	int _b = 1;
};

class Derive : public Base{
public:
	virtual void func1(){
		std::cout << "Derive::func1()" << std::endl;
	}

private:
	int _d = 2;
};

int var1 = 1;

void func(){

}

typedef void(*Func)();

int main(){
	int var2 = 2;

	int* p = new int;

	Base b;

	Derive d;

	std::cout << "栈: " << &var2 << std::endl;
	std::cout << "堆: " << p << std::endl;
	std::cout << "数据段: " << &var1 << std::endl;
	std::cout << "代码段: " << &func << std::endl;

	// 打印虚表所在地址
	std::cout << "vfptr: " << *(Func*)(&b) << std::endl;

	system("pause");
	return 0;
}

在这里插入图片描述
从结果中可以看出，vfptr和代码段地址最为接近，所以虚表存在代码段中。
那么多态的原理究竟是什么呢？再来看一段代码。

#include <iostream>
#include <stdlib.h>

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

class Student : public Person{
public:
	virtual void BuyTicket(){
		std::cout << "买票-半价!" << std::endl;
	}
};

void func(Person& p){
	p.BuyTicket();
}

int main(){
	Person p;
	func(p);

	Student s;
	func(s);

	system("pause");
	return 0;
}

在这里插入图片描述
对上述代码进行调试分析。
在这里插入图片描述
查看反汇编。

	p.BuyTicket();
// 将p移动到eax中
002D2D2E  mov         eax,dword ptr [p]  
// [eax]就是取eax值指向的内容
// 相当于将p/s对象头4个字节（虚表指针）移动到了edx
002D2D31  mov         edx,dword ptr [eax]
// 取edx值指向的内容
// 相当于把虚表中的头四个字节的虚函数指针移动到了eax   
002D2D38  mov         eax,dword ptr [edx]  
// eax中存的是虚函数的指针，调用虚函数
// 这里可以看出满足多态的调用，不是在编译时确定的，是运行起来以后到对象中取的。
002D2D3A  call        eax  
002D2D3C  cmp         esi,esp

将main函数修改成如下。

int main(){
	Student s;
	s.BuyTicket();

	system("pause");
	return 0;
}

查看反汇编。

	s.BuyTicket();
00E14BC0  lea         ecx,[s]  
// 虽然BuyTicket是虚函数，但是s是对象，不满足多态条件
// 所以这里是普通函数的调用
// 是在编译时已经从符号确认了函数的地址，直接call地址
00E14BC3  call        Student::BuyTicket (0E1151Eh)

动态绑定和静态绑定

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

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

单继承中的虚函数表

#include <iostream>
#include <stdlib.h>

class Base{
public:
	virtual void func1(){
		std::cout << "Base::func1()" << std::endl;
	}

	virtual void func2(){
		std::cout << "Base::func2()" << std::endl;
	}

private:
	int _b;
};

class Derive : public Base{
public:
	virtual void func1(){
		std::cout << "Derive::func1()" << std::endl;
	}

	virtual void func3(){
		std::cout << "Derive::func3()" << std::endl;
	}

	virtual void func4(){
		std::cout << "Derive::func4()" << std::endl;
	}

private:
	int _d;
};

int main(){
	Base b;

	Derive d;

	system("pause");
	return 0;
}

在这里插入图片描述
调试发现看不到虚函数func3和虚函数func4，这是编译器的一个小bug。
对上述代码略作修改，手动打印虚函数表。

#include <iostream>
#include <stdlib.h>

class Base{
public:
	virtual void func1(){
		std::cout << "Base::func1()" << std::endl;
	}

	virtual void func2(){
		std::cout << "Base::func2()" << std::endl;
	}

private:
	int _b;
};

class Derive : public Base{
public:
	virtual void func1(){
		std::cout << "Derive::func1()" << std::endl;
	}

	virtual void func3(){
		std::cout << "Derive::func3()" << std::endl;
	}

	virtual void func4(){
		std::cout << "Derive::func4()" << std::endl;
	}

private:
	int _d;
};

typedef void (*VFPTR)();

void vfptrDisplay(VFPTR v[]){
	std::cout << "虚表地址: " << v << std::endl;

	for (int i = 0; v[i] != nullptr; ++i){
		printf("第%d个虚函数地址: 0X%x, ->", i, v[i]);
		VFPTR f = v[i];
		f();
	}

	std::cout << std::endl;
}

int main(){
	Base b;
	Derive d;

	// &b先取对象b的地址
	// (int*)&b，转换为int*，方便下一步解引用取出头四个字节
	// *(int*)&b，取对象b的头四个字节，这个值就是指向虚函数表的指针
	// 再将该指针类型强制转换为虚函数类型的函数指针
	VFPTR* vb = (VFPTR*)(*(int*)&b);
	vfptrDisplay(vb);

	VFPTR* vd = (VFPTR*)(*(int*)&d);
	vfptrDisplay(vd);

	system("pause");
	return 0;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

多继承中的虚函数表

#include <iostream>
#include <stdlib.h>

class Base1{
public:
	virtual void func1(){
		std::cout << "Base1::func1()" << std::endl;
	}

	virtual void func2(){
		std::cout << "Base1::func2()" << std::endl;
	}

private:
	int _b1;
};

class Base2{
public:
	virtual void func1(){
		std::cout << "Base2::func1()" << std::endl;
	}

	virtual void func2(){
		std::cout << "Base2::func2()" << std::endl;
	}

private:
	int _b2;
};

class Derive : public Base1, public Base2{
public:
	virtual void func1(){
		std::cout << "Derive::func1()" << std::endl;
	}

	virtual void func3(){
		std::cout << "Derive::func3()" << std::endl;
	}

private:
	int _d;
};

typedef void(*VFPTR)();

void vfptrDisplay(VFPTR v[]){
	std::cout << "虚表地址: " << v << std::endl;

	for (int i = 0; v[i] != nullptr; ++i){
		printf("第%d个虚函数地址: 0X%x, ->", i, v[i]);
		VFPTR f = v[i];
		f();
	}

	std::cout << std::endl;
}

int main(){
	Derive d;

	VFPTR* vd1 = (VFPTR*)(*(int*)&d);
	vfptrDisplay(vd1);

	VFPTR* vd2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
	vfptrDisplay(vd2);

	system("pause");
	return 0;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

爱喝可乐的炸鸡
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++多态
weixin_50569901的博客
04-20 1万+
C++中的多态分为静态多态和动态多态两种，其中： 静态多态在编译阶段实现，其原理是由函数重载实现，通过不同的实参调用其相应的同名函数。 动态多态通过虚函数实现，以下着重介绍 动态多态的两个必要条件： 必须通过基类的指针或者引用调用 被调用的必须是虚函数，且在派生类中实现了该虚函数的重写 以下解释何为通过基类的指针或者引用调用 int main() { Person p; student s; Person &tmp1 = p; Person &tmp2 = s;//tm
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++ 多态
jun8086的博客
10-31 591
c++ 多态
c++多态 详解
最新发布
qq_39117115的博客
03-09 1010
综上：如果满足多态，看指向对象的类型，调用这个类型的成员函数如果不满足多态， 看调用者类型，调用这个类型的成员函数解释：满足多态的情况下，我们定义Parent * p= new student，这个会调用Student的发生重写的函数我们定义Parent *p =new Parent ，这个会调用Parent中被重写的函数不满足多态的情况下，我们定义Student *s =new Student，这个会调用Student的函数。
C++多态详解
米莱虾
10-12 933
目录 多态的概念 多态的实现 虚函数的定义要遵循以下重要规则： 多态的概念 多态现在一般的用法，就是拿一个父类的指针去调用子类中被重写的方法。 那为什么要用多态呢，我们直接在子类中写一个同名的成员函数，从而隐藏父类的函数不是也可以吗? -------- 这是不可以的。下面我们用一个例子来解释为什么要用多态： 将父类比喻为电脑的外设接口，子类比喻为外设，现在我有移动硬盘、U盘以及MP3，它们3个都是可以作为存储但各不相同。在写驱动的时候，用个父类表示外设接口，然后在子类中重写父类那个读取设备..
c++ 多态详解
不倒翁.
05-02 5485
c++多态详解
c++ 多态
RSH的博客
07-24 380
1、多态 多态的基本概念 多态是C++面向对象三大特性之一 多态分为两类 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名 动态多态: 派生类和虚函数实现运行时多态 静态多态和动态多态区别： 静态多态的函数地址早绑定 - 编译阶段确定函数地址 动态多态的函数地址晚绑定 - 运行阶段确定函数地址 虚函数表存放的是虚函数的入口地址，当子类重写了虚函数后，子类会把继承于父类的虚函数表进行覆盖，所以当用父类指针或引用指向子类对象的时候，由于本身还是子类，所以当调用公共接口时，它会从子类去
C++多态（超级详细版）
kkbca的博客
10-28 1万+
在继承中要构成多态还有两个条件：1. 必须通过基类的指针或者引用调用虚函数2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写public:virtual void BuyTicket() { cout
C++多态的底层原理
分享学习的知识，记录我的技术成长道路
04-27 2792
要了解C++多态的底层原理需要我们对C指针有着深入的了解，这个在打印虚表的时候就可以见功底，理解了多态的本质我们才能记忆的更牢，使用起来更加得心应手。
『C++』endl、ends和flush的区别
叄拾叄画生
07-12 1741
endl、ends和flush的区别。
『C++』deque容器的简单介绍
叄拾叄画生
06-14 1470
deque简单接收。deque的使用。构造函数。迭代器。容量相关操作。元素访问操作。元素修改操作。注意。
『C++』vector容器的简单介绍
叄拾叄画生
05-20 1097
vector容器简单介绍。vector的使用。vector的定义。vector iterator的使用。vector空间相关接口。vector增删改查。vector迭代器失效问题。
『C++』内存管理
叄拾叄画生
04-25 639
C/C++内存分布。C语言动态内存管理。C++动态内存管理。new和delete的实现原理。定位new表达式。new/delete和malloc/free的区别。内存泄漏。如何在堆上申请4G空间。
『C++』基本认识
叄拾叄画生
10-22 485
C++关键字。命名空间。C++输入输出。缺省参数。函数重载。引用。内联函数。auto关键字。范围for循环。指针空值nullptr。
『C++』string类模拟实现
叄拾叄画生
04-28 382
深拷贝与浅拷贝。写时拷贝。string类的模拟实现。
『C++』STL简介
叄拾叄画生
11-22 363
什么是STL？STL的版本。STL的六大组件。STL的缺点。
『C++』string类的简单介绍
叄拾叄画生
04-28 329
string类的引入。string类简介。常用接口介绍。常用构造函数。容量操作。访问操作。修改操作。非成员函数。
『C++』Lambda表达式
叄拾叄画生
07-14 323
函数指针。仿函数。Lambda表达式。Lambda表达式语法。Lambda表达式捕获列表说明。仿函数和Lambda表达式。函数指针、仿函数和Lambda表达式的简单比较。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值