C++虚函数

最新推荐文章于 2022-07-18 13:10:49 发布
最新推荐文章于 2022-07-18 13:10:49 发布
阅读量245 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43003442/article/details/113964749
版权

本文是基于32位系统下的分析，用的vs2019
参考资料：https://blog.csdn.net/haoel/article/details/1948051/

准备工作
vs 设置查看内存分布方式：
右键-> 属性 -> C/C++ 命令行 填入 /d1 reportAllClassLayout
在这里插入图片描述
在这里插入图片描述

一般继承（无虚函数覆盖）

class A
{
public:
	virtual void f() { cout << "A::f()" << endl; }
	int _a;
};

class B : public A
{
public:
	void fb() { cout << "B::fb()" << endl; }
	int _b;
};

vs打印出的内存布局如下图
在这里插入图片描述
内容复制出来如下
1>class A size(8):
1> ±–
1> 0 | {vfptr}
1> 4 | _a
1> ±–
1>A::$vftable@:
1> | &A_meta
1> | 0
1> 0 | &A::f
1> 1 | &A::g
1> 2 | &A::h

可以看到A类有一个4字节的虚函数指针vfptr，该虚函数指针指向了一张虚函数表vftable，虚函数表中存储了每一个虚函数的地址

1>class B size(12):
1> ±–
1> 0 | ±-- (base class A)
1> 0 | | {vfptr}
1> 4 | | _a
1> | ±–
1> 8 | _b
1> ±–
1>B::$vftable@:
1> | &B_meta
1> | 0
1> 0 | &A::f
1> 1 | &A::g
1> 2 | &A::h

B类继承了A类虚函数表和成员变量

一般继承（有虚函数覆盖,子类没有自己新的虚函数）

例：在子类B中重写父类A的f()方法

class A
{
public:
	virtual void f() { cout << "A::f()" << endl; }
	virtual void g() { cout << "A::g()" << endl; }
	virtual void h() { cout << "A::h()" << endl; }
	int _a;
};

class B : public A
{
public:
	void f() { cout << "B::f()" << endl; }
	int _b;
};

1>class B size(12):
1> ±–
1> 0 | ±-- (base class A)
1> 0 | | {vfptr}
1> 4 | | _a
1> | ±–
1> 8 | _b
1> ±–
1>B::$vftable@:
1> | &B_meta
1> | 0
1> 0 | &B::f
1> 1 | &A::g
1> 2 | &A::h

可见B的虚函数表中&B::f 覆盖了原有的&A::f

一般继承（有虚函数覆盖,子类有自己新的虚函数）

例：在子类B中重写父类A的f()方法，同时新增一个自己的虚函数k()

class A
{
public:
	virtual void f() { cout << "A::f()" << endl; }
	virtual void g() { cout << "A::g()" << endl; }
	virtual void h() { cout << "A::h()" << endl; }
	int _a;
};

class B : public A
{
public:
	void f() { cout << "B::f()" << endl; }
	virtual void k() { cout << "B::k()" << endl; }
	int _b;
};

1>class B size(12):
1> ±–
1> 0 | ±-- (base class A)
1> 0 | | {vfptr}
1> 4 | | _a
1> | ±–
1> 8 | _b
1> ±–
1>B::$vftable@:
1> | &B_meta
1> | 0
1> 0 | &B::f
1> 1 | &A::g
1> 2 | &A::h
1> 3 | &B::k
可以看到新增的虚函数会顺式添加到已有的虚函数表中

多重继承（无虚函数覆盖）

class Base1
{
public:
	Base1() : _iBase1(10) {}
	virtual void f() { std::cout << "Base1::f()" << std::endl; }
	virtual void g() { std::cout << "Base1::g()" << std::endl; }
	virtual void h() { std::cout << "Base1::h()" << std::endl; }
	int _iBase1;
};

class Base2
{
public:
	Base2() : _iBase2(100) {}
	virtual void f() { std::cout << "Base2::f()" << std::endl; }
	virtual void g() { std::cout << "Base2::g()" << std::endl; }
	virtual void h() { std::cout << "Base2::h()" << std::endl; }
	int _iBase2;
};

class Base3
{
public:
	Base3() : _iBase3(1000) {}
	virtual void f() { std::cout << "Base3::f()" << std::endl; }
	virtual void g() { std::cout << "Base3::g()" << std::endl; }
	virtual void h() { std::cout << "Base3::h()" << std::endl; }
	int _iBase3;
};


class Derive
	: public Base1
	, public Base2
	, public Base3
{
public:
	Derive() : _iDerived(10000) {}
	virtual void f1() { std::cout << "Derive::f()" << std::endl; }
	virtual void g1() { std::cout << "Derive::g1()" << std::endl; }

	int _iDerived;
};

1>class Derive size(28):
1> ±–
1> 0 | ±-- (base class Base1)
1> 0 | | {vfptr}
1> 4 | | _iBase1
1> | ±–
1> 8 | ±-- (base class Base2)
1> 8 | | {vfptr}
1>12 | | _iBase2
1> | ±–
1>16 | ±-- (base class Base3)
1>16 | | {vfptr}
1>20 | | _iBase3
1> | ±–
1>24 | _iDerived
1> ±–
1>Derive::KaTeX parse error: Expected 'EOF', got '&' at position 22: …e@Base1@: 1> | &̲Derive_meta 1> …vftable@Base2@:
1> | -8
1> 0 | &Base2::f
1> 1 | &Base2::g
1> 2 | &Base2::h
1>Derive::$vftable@Base3@:
1> | -16
1> 0 | &Base3::f
1> 1 | &Base3::g
1> 2 | &Base3::h
在这里插入图片描述

总结：多重继承（无虚函数覆盖）场景
①每个父类都有自己的虚表
②派生类中的布局按照基类被声明时的顺序进行排列
③派生类自己的虚函数，会被加入到第一个基类的虚函数表中

多重继承（有虚函数覆盖）

class Base1
{
public:
	Base1() : _iBase1(10) {}
	virtual void f() { std::cout << "Base1::f()" << std::endl; }
	virtual void g() { std::cout << "Base1::g()" << std::endl; }
	virtual void h() { std::cout << "Base1::h()" << std::endl; }
	int _iBase1;
};

class Base2
{
public:
	Base2() : _iBase2(100) {}
	virtual void f() { std::cout << "Base2::f()" << std::endl; }
	virtual void g() { std::cout << "Base2::g()" << std::endl; }
	virtual void h() { std::cout << "Base2::h()" << std::endl; }
	int _iBase2;
};

class Base3
{
public:
	Base3() : _iBase3(1000) {}
	virtual void f() { std::cout << "Base3::f()" << std::endl; }
	virtual void g() { std::cout << "Base3::g()" << std::endl; }
	virtual void h() { std::cout << "Base3::h()" << std::endl; }
	int _iBase3;
};


class Derive
	: public Base1
	, public Base2
	, public Base3
{
public:
	Derive() : _iDerived(10000) {}
	void f() { std::cout << "Derive::f()" << std::endl; }
	virtual void g1() { std::cout << "Derive::g1()" << std::endl; }

	int _iDerived;
};

1>class Derive size(28):
1> ±–
1> 0 | ±-- (base class Base1)
1> 0 | | {vfptr}
1> 4 | | _iBase1
1> | ±–
1> 8 | ±-- (base class Base2)
1> 8 | | {vfptr}
1>12 | | _iBase2
1> | ±–
1>16 | ±-- (base class Base3)
1>16 | | {vfptr}
1>20 | | _iBase3
1> | ±–
1>24 | _iDerived
1> ±–
1>Derive::KaTeX parse error: Expected 'EOF', got '&' at position 22: …e@Base1@: 1> | &̲Derive_meta 1> …vftable@Base2@:
1> | -8
1> 0 | &thunk: this-=8; goto Derive::f // 这里存的不是&Derive::f，而是跳转指令
1> 1 | &Base2::g
1> 2 | &Base2::h
1>Derive::$vftable@Base3@:
1> | -16
1> 0 | &thunk: this-=16; goto Derive::f // 这里存的不是&Derive::f，而是跳转指令
1> 1 | &Base3::g
1> 2 | &Base3::h

可以看到内存分布中Derive继承了Base1 Base2 Base3的虚函数指针、虚函数表，同时按照基类Base1、Base2、Base3的声明顺序进行排列；Derive重写了f()函数，因此Base1 Base2 Base3的需表中各自的f()函数都被覆盖成&Derive::f，不过只有Base1的虚表中存的是&Derive::f，Base2 Base3虚表中都是一条跳转指令。Derive自己新增的虚函数被存放在
Base1的虚表中。

在这里插入图片描述

总结：多重继承（有虚函数覆盖）场景
①每个父类都有自己的虚表
②派生类中的布局按照基类被声明时的顺序进行排列
③派生类自己的虚函数，会被加入到第一个基类的虚函数表中
④派生类会覆盖基类的虚函数，但是只有第一个虚表中存放的是被覆盖的函数地址，其他的都存放的是跳转指令

一个简单的例子测试虚表的存在

#include <iostream>

class A
{
public:
	A() :_a(10) {}
	virtual void f() { std::cout << "A::f()" << std::endl; }
	virtual void g() { std::cout << "A::g()" << std::endl; }
	virtual void h() { std::cout << "A::h()" << std::endl; }
	int _a;
};

class B : public A
{
public:
	B() :_b(100) {}
	void f() { std::cout << "B::f()" << std::endl; }
	int _b;
};

typedef void(*Function)(void);
int main(void)
{
	B b;
#if 1
	int* vfptr = (int*)&b;
	int vtaleAdress = *vfptr;

	int* pVtable = (int*)vtaleAdress;
	int func = *pVtable;

	Function f = (Function)func;
	f();
	Function g = (Function) * (pVtable + 1);
	g();
	Function h = (Function) * (pVtable + 2);
	h();
	std::cout << "A::_a = " << (int)*(vfptr + 1) << std::endl;
	std::cout << "B::_b = " << (int)*(vfptr + 2) << std::endl;
#endif

#if 0
	int** vfptr = (int**)&b;
	for (int idx = 0; vfptr[0][idx] != NULL; ++idx) {
		Function f = (Function)vfptr[0][idx];
		f();
	}
	std::cout << "A::_a = " << (int)vfptr[1] << std::endl;
	std::cout << "B::_b = " << (int)vfptr[2] << std::endl;
#endif
	return 0;
}
feiyang0205
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++虚函数表解析
03-03
前言C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型...
【转】c++虚函数实现原理
weixin_30338743的博客
07-19 58
原文链接：https://blog.csdn.net/neiloid/article/details/6934135 C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，R...
C++虚函数表分析
weixin_30443747的博客
07-26 133
先看代码： #include <iostream> using namespace std; class Base { public: virtual void f() {cout<<"base::f"<<endl;} virtual void g() {cout<<"base::g"<<endl;...
c++虚函数的讲解
In_Zihuatanejo的博客
07-28 300
废话少说，直接上测试代码 #include #include using namespace std; //有虚函数的类  class A { public: A(); ~A(); virtual void f(){ cout } virtual void g() { cout } private: int   _a; }; class B:
【C++基础之十一】虚函数的用法
偶尔e网事
09-22 9543
虚函数的作用和意义，就不进行说明了，这里主要讨论下虚函数的用法。 1.典型的虚函数用法 可以看到，只有标识为virtual的函数才会产生多态的效果，而且是编译多态。它只能借助指针或者引用来达到多态的效果。 class A { public: virtual void f(){cout<<"A::f()";}//虚函数 void g(){cout<<"A::g()";}//普通
C++ Primer学习总结 第15章 面向对象程序设计
sgh666666的博客
03-15 350
1、 构造基类和派生类 其中A类是基类，B类是派生类。 继承关系中，每个类必须控制它自己的成员初始化过程。即B类必须使用A的构造函数来初始化基类部分。也就是B的构造函数必须是重写过的（不是继承A的）。 派生类可以覆盖基类的虚函数，但是也可以不覆盖（而使用基类的）。 基类的静态成员：基类定义一个静态成员，那么基类与所有派生类都共同拥有这仅有的一个静态成员。 #include&amp;amp;lt;bits/stdc...
C++ 虚函数的详解及简单实例
01-01
C++ 虚函数的详解 虚函数的使用和纯虚函数的使用。 虚函数是在基类定义，然后子类重写这个函数后，基类的指针指向子类的对象，可以调用这个函数，这个函数同时保留这子类重写的功能。 纯虚函数是可以不用在基类定义...
C++ 虚函数专题
12-17
虚函数 基类中使用virtual关键字声明的函数，称为虚函数。 虚函数的实现，通过虚函数表来实现的。即V-table 这个表中有一个类，用于储存虚函数的地址。解决其继承，覆盖的问题，用于保证其真实反映的函数。这样有虚...
C++虚函数表实例分析
01-21
在对象中，有一个指针指向一张虚函数表，里面按照次序存放了每一个虚函数，当子类继承的时候，即到虚函数表的指定位置去修改函数地址。当我们通过父类指针来操作一个子类的时候，调用虚函数，都是通过虚函数表+固定...
【C++】继承
qq_53893431的博客
07-18 294
C++继承
定义三个类A，B，C,其中B继承于A，C继承于B，都包含f()，用于表明当前执行的是哪个类的f()
qq_39352109的博客
03-22 3074
#include<iostream> #include<bits/stdc++.h> using namespace std; class A { public: A(){cout<<"create A"<<endl;} virtual ~A(){cout<<"conustructing A"&lt...
cout 输出控制
热门推荐
wolinxuebin的专栏
04-23 4万+
cout输出格式控制 如果要在输出流中加入格式控制符则要加载头文件：#include 　　这里面iomanip的作用比较多: 　　主要是对cin,cout之类的一些操纵运算子，比如setfill,setw,setbase,setprecision等等。它是I/O流控制头文件,就像C里面的格式化输出一样.以下是一些常见的控制函数的: dec 置基数为10 相当于"%d" hex
C++笔记8.22
iMercedes的博客
08-23 278
不可修饰的对象 const Currency the_raise(42,38) 编译器只知道原型，不知道body并不知道对象的body中的函数会不会修改这个const 所以在函数（）后面加const，原型和body都要加 class A{ int i; public: A():i(0){} void f() {cout <<"f"<<endl;} void f() const{cout<<"f const"<<endl;} }; int main()
C++-动态联编
qq_43535469的博客
02-24 1479
静态联编 束定：程序中的操作调用（如函数调用）与执行该操作代码间的关系（简单来说就是在函调用时能找到相应代码的位置） 静态联编就是联编工作在编译阶段完成 也就是在程序运行之前就已经确定好了调用这个函数要去哪找 编译阶段就必须确定程序中的操作调用（如函数调用）与执行该操作代码间的关系 下面代码类B继承类A 创建了一个类A类型的指针pa 先pa指针指向类A对象a 调用f()函数 结果是A 再将pa指向类B对象b的地址 调用f()函数 结果还是A 我们会发现地址变了 但是结果没变 class A { publi
C++中的虚函数(virtual)
weixin_43510267的博客
07-15 132
class base{ public: virtual void f(){cout << "base" << ends;} }; class derived : public base{ public: virtual void f(){cout << "derived" << ends;} }; int main(void){ derived a; // a.f(); 静态类型 直接输出derived，什么类型就是什么类型
虚函数和类的多态性
Tim's Blog
12-12 671
多态特性让程序员省去了细节的考虑，提高了开发效率，使代码大大的简化，当然虚函数的定义也是有缺陷的，因为多态特性增加了一些数据存储和执行指令的开销，所以能不用多态最好不用。（为了实现virtual函数，类中间必须要增加一个pointer指向虚函数表，这样增大了类的体积。所以没有必要的话，还是不要随意声明virtual的析构函数。普遍的规则是只有当类当中有virtual的函数时，析构函数才声明为vir
【C++】虚函数
qq_45829112的博客
03-14 845
虚函数是构成C++多态的重要一步，今天来说一下虚函数！ 虚函数： 在基类(或父类)中，使用virtual关键字对函数进行声明为并在一个或多个派生类(子类)中被重新定义的成员函数，通过指向派生类的基类指针或引用，访问派生类中同名覆盖成员函数。 它的用法是这样的：virtual + 函数返回类型 + 函数名 +（参数表） {函数体} 首先我们要知道为什么要有虚函数这个东西？ 我来看下下面这两段代码的结果再来说结果： class A { public: void fun() { cout
虚基类、虚函数，对象内存分布
northhero的专栏
09-06 2014
在Project Properties->C++->Command Line->Additional Options里面加上/d1reportSingleClassLayoutDerived编译时，可输出类Derived的内存布局。  非虚拟继承：在派生类对象里，按照继承声明顺序依次分布基类对象，最后是派生类数据成员。若基类声明了虚函数，则基类对
c++虚函数
最新发布
05-25
C++中的虚函数是一种特殊的成员函数，它可以在派生类中被重写。在基类中声明一个函数为虚函数，可以使得该函数在其任何派生类中被重写，从而实现多态性。 使用虚函数的步骤如下： 1. 在基类中声明虚函数，使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值