C++虚函数表分析——参考陈皓版

最新推荐文章于 2022-07-21 18:51:01 发布

xxZkj

最新推荐文章于 2022-07-21 18:51:01 发布

阅读量241

点赞数

分类专栏： Effective C++理解

原文链接：https://blog.csdn.net/haoel/article/details/1948051

版权

Effective C++理解专栏收录该内容

7 篇文章 0 订阅

订阅专栏

C++虚函数表分析——参考陈皓版

适用于64位机

前言

C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。

虚函数表

对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。在这个表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其内容真实反应实际的函数。

C++的编译器保证指向虚函数表地址的指针存在在对象实例中的最前面位置，这是在多重继承下获得最佳性能，记住是指向虚函数表的指针存在在对象实例的最前面位置，不是说每一个对象实例都有一个虚函数表，而是所有对象实例共享这个虚函数表（试想如果每个实例对象都有一个虚函数表，那一个对象实例多占空间啊）。

实践结果：

#include<iostream>
using namespace std;

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

};

//声明一个函数指针，这个函数指针类型名为Fun，它指向的函数调用参数为void，返回值为void
typedef void(*Fun)(void);

int main() {
	Base b;
	cout << "虚函数表的地址(十六进制)：" << (long long*)*((long long*)(&b)) << endl;
	cout << "虚函数表的地址(十进制)：" << *((long long*)(&b)) << endl;
	cout << "虚函数表的第一个函数的地址：" << (long long*)*(long long*)*((long long*)(&b)) << endl;
	Fun pFun = nullptr;
	pFun = (Fun)*((long long*)*((long long*)(&b)));
	pFun();
    pFun = (Fun)*((long long*)*((long long*)(&b)) + 1);
    pFun();
    pFun = (Fun)*((long long*)*((long long*)(&b)) + 2);
    pFun();
	return 0;
}

输出结果：（Ubuntu18.04、64位机子）
在这里插入图片描述
这里解释下为什么 (long long*)*((long long*)&b) 可以获得虚函数表的地址，从右开始往左分析，&b是获得对象实例b的内存地址，由于我们已经知道虚函数表的指针存储在对象实例内存的最前面位置，并且64位系统的指针大小为8个字节，也就是64位，故取得对象实例b的内存地址后，强制转换为指向long long的指针，也就是(long long*)&b的由来，这样我们就得到了指向虚函数表地址的指针，然后再解引用，就获得了虚函数表的地址，也就是*(long long*)&b，最后再进行一次(long long*)的强制转换将其转换为long long指针，输出地址。

（可能有人会问为什么不直接输出*(long long*)&b，是因为C++输出运算符重载的原因，当直接输出*(long long*)&b时，编译器检测到是指向long long的指针，结果会输出长整型十进制数，如果再进行一次强制指针转型时，就输出长整型指针，也就是十六进制的地址，两者其实是一样，只不过十进制和十六进制的区别）

同理虚函数表的第一个函数地址也一样，虚函数表里面存得其实也是函数指针，指向虚函数f、g、h的地址，因而我们只要对获得的虚函数表地址再进行一次解引用+强制转型，就获得了虚函数f的地址了。

为了验证，我们还使用了函数指针Fun，将获得虚函数表的第一个函数地址转型赋值给函数指针pFun，这样pFun就能调用这个虚函数f了。

用一张图来解释就是：
在这里插入图片描述
注意：在上面这个图中，我在虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符’\0’一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。

以上在64位机子测试通过，32位机子需要把long long*全部改为int*，因为32位机子指针只占4个字节，也就是32位。

题外话，大家可能也注意到了，64位机子的内存地址也应该是64位啊，为什么只输出了48位（12位十六进制）呢？在这引用知乎RednaxelaFX的回答，当前版本的AMD64架构就规定了只用48位地址；一个表示虚拟内存地址的64位指针只有低48位有效并带符号扩展到64位——换句话说，其高16位必须是全1或全0，而且必须与低48位的最高位（第47位）一致，否则通过该地址访问内存会产生#GP异常（general-protection exception）。只用48位的原因很简单：因为现在还用不到完整的64位寻址空间，所以硬件也没必要支持那么多位的地址。

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

假设有如下所示的一个继承关系：
在这里插入图片描述
请注意，在这个继承关系中，子类没有重载任何父类的函数。那么，在派生类的实例中，其虚函数表如下所示：

我们可以看到下面几点：

虚函数按照声明顺序放在虚函数表里面。
父类的虚函数在子类的虚函数前面。

实践结果：

#include<iostream>
using namespace std;

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

};

class Derive: public Base {
public:
	virtual void f1() {
		cout << "Derive::f1" << endl;
	}
        virtual void g1() {
                cout << "Derive::g1" << endl;
        }
        virtual void h1() {
                cout << "Derive::h1" << endl;
        }

};
typedef void(*Fun)(void);

int main() {
	Derive d;
	cout << "虚函数表的地址(十六进制)：" << (long long*)*((long long*)(&d)) << endl;
	cout << "虚函数表的地址(十进制)：" << *((long long*)(&d)) << endl;
	cout << "虚函数表的第一个函数的地址：" << (long long*)*(long long*)*((long long*)(&d)) << endl;
	Fun pFun = nullptr;
	pFun = (Fun)*((long long*)*((long long*)(&d)));
	pFun();
    pFun = (Fun)*((long long*)*((long long*)(&d)) + 1);
    pFun();
    pFun = (Fun)*((long long*)*((long long*)(&d)) + 2);
    pFun();
    pFun = (Fun)*((long long*)*((long long*)(&d)) + 3);
    pFun(); 
    pFun = (Fun)*((long long*)*((long long*)(&d)) + 4);
    pFun(); 
    pFun = (Fun)*((long long*)*((long long*)(&d)) + 5);
    pFun(); 
	return 0;
}

在这里插入图片描述

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

如果子类中有虚函数重载了父类的虚函数，会是一个什么样子？假设，我们有下面这样的一个继承关系。
在这里插入图片描述
在这个类的设计中，我只覆盖了父类的一个函数：f()。那么，对于派生类的实例，其虚函数表会是下面的一个样子：

我们从表中可以看到下面几点：

覆盖的f()函数被放到了虚表中原来父类虚函数的位置。
没有被覆盖的函数依旧。

这样，我们就可以看到对于下面这样的程序：

    Base *b = new Derive();
 
    b->f();

由b所指的内存中的虚函数表的f()的位置已经被Derive::f()函数地址所取代，于是在实际调用发生时，是Derive::f()被调用了。这就实现了多态。

实践结果：

#include<iostream>
using namespace std;

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

};

class Derive: public Base {
public:
	virtual void f() {
		cout << "Derive::f1" << endl;
	}
        virtual void g1() {
                cout << "Derive::g1" << endl;
        }
        virtual void h1() {
                cout << "Derive::h1" << endl;
        }

};
typedef void(*Fun)(void);

int main() {
	Derive d;
	cout << "虚函数表的地址(十六进制)：" << (long long*)*((long long*)(&d)) << endl;
	cout << "虚函数表的地址(十进制)：" << *((long long*)(&d)) << endl;
	cout << "虚函数表的第一个函数的地址：" << (long long*)*(long long*)*((long long*)(&d)) << endl;
	Fun pFun = nullptr;
	pFun = (Fun)*((long long*)*((long long*)(&d)));
	pFun();
    pFun = (Fun)*((long long*)*((long long*)(&d)) + 1);
    pFun();
    pFun = (Fun)*((long long*)*((long long*)(&d)) + 2);
    pFun();
    pFun = (Fun)*((long long*)*((long long*)(&d)) + 3);
    pFun(); 
    pFun = (Fun)*((long long*)*((long long*)(&d)) + 4);
    pFun(); 
	cout << "以下是通过父指针操作孩子重载虚函数" << endl;
	Base* b = new Derive();
	b->f();
	delete b;
	return 0;
}

在这里插入图片描述

多继承（无虚函数覆盖）

再让我们来看看多继承中的情况，假设有下面这样一个类的继承关系。注意：子类并没有覆盖父类的函数。
在这里插入图片描述
对于子类实例中的虚函数表，是下面这个样子：

我们可以看到：

每个父类都有自己的虚表。
子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）

这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。

多继承（有虚函数覆盖）

下图中，我们在子类中覆盖了父类的f()函数。
在这里插入图片描述
下面是对于子类实例中的虚函数表的图：

我们可以看见，三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样，我们就可以任一静态类型的父类来指向子类，并调用子类的f()了。如：

            Derive d;
 
 
            Base1 *b1 = &d;
 
 
            Base2 *b2 = &d;
 
 
            Base3 *b3 = &d;
 
 
            b1->f(); //Derive::f()
 
 
            b2->f(); //Derive::f()
 
 
            b3->f(); //Derive::f()
 
 
            b1->g(); //Base1::g()
 
 
            b2->g(); //Base2::g()
 
 
            b3->g(); //Base3::g()

安全性

每次写C++的文章，总免不了要批判一下C++。这篇文章也不例外。通过上面的讲述，相信我们对虚函数表有一个比较细致的了解了。水可载舟，亦可覆舟。下面，让我们来看看我们可以用虚函数表来干点什么坏事吧。

一、通过父类型的指针访问子类自己的虚函数

我们知道，子类没有重载父类的虚函数是一件毫无意义的事情。因为多态也是要基于函数重载的。虽然在上面的图中我们可以看到Base1的虚表中有Derive的虚函数，但我们根本不可能使用下面的语句来调用子类的自有虚函数：

 Base1 *b1 = new Derive();
 
 b1->f1();  //编译出错

任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法，所以，这样的程序根本无法编译通过。但在运行时，我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。

二、访问non-public的虚函数

另外，如果父类的虚函数是private或是protected的，但这些非public的虚函数同样会存在于虚函数表中，所以，我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数，这是很容易做到的。

#include<iostream>
using namespace std;

class Base {
//申明为private了
private:
	virtual void f() {
		cout << "Base::f" << endl;
	}
	virtual void g() {
		cout << "Base::g" << endl;
	}
	virtual void h() {
		cout << "Base::h" << endl;
	}
};

class Derive: public Base {
public:
	virtual void f1() {
		cout << "Derive::f1" << endl;
	}
        virtual void g1() {
                cout << "Derive::g1" << endl;
        }
        virtual void h1() {
                cout << "Derive::h1" << endl;
        }
};
typedef void(*Fun)(void);

int main() {
	Derive d;
	cout << "虚函数表的地址(十六进制)：" << (long long*)*((long long*)(&d)) << endl;
	cout << "虚函数表的地址(十进制)：" << *((long long*)(&d)) << endl;
	cout << "虚函数表的第一个函数的地址：" << (long long*)*(long long*)*((long long*)(&d)) << endl;
	Fun pFun = nullptr;
	//还是可以访问到父类的私有虚函数
	pFun = (Fun)*((long long*)*((long long*)(&d)));
	pFun();
    pFun = (Fun)*((long long*)*((long long*)(&d)) + 1);
    pFun();
    pFun = (Fun)*((long long*)*((long long*)(&d)) + 2);
    pFun();
   pFun = (Fun)*((long long*)*((long long*)(&d)) + 3);
    pFun(); 
    pFun = (Fun)*((long long*)*((long long*)(&d)) + 4);
    pFun(); 
    pFun = (Fun)*((long long*)*((long long*)(&d)) + 5);
    pFun();

	//d.f(); //编译出错，直接无法访问父类的私有成员函数
	return 0;
}

在这里插入图片描述

例程

#include<iostream>
using namespace std;

class Base {
private:
	virtual void f() {
		cout << "Base::f" << endl;
	}
	virtual void g() {
		cout << "Base::g" << endl;
	}
	virtual void h() {
		cout << "Base::h" << endl;
	}

};

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

class Derive: public Base, public Base1 {
public:
	virtual void f() {
		cout << "Derive::f1" << endl;
	}
        virtual void g1() {
                cout << "Derive::g1" << endl;
        }
        virtual void h1() {
                cout << "Derive::h1" << endl;
        }

};
typedef void(*Fun)(void);

int main() {
	Derive d;
	Fun pFun = nullptr;
	//其实存储在对象实例的虚函数表指针可以当作一个二级指针
	//因为其指向的虚函数表存储的也是函数指针
	long long** address = (long long**)(&d);
	cout << "虚函数表地址" << address << endl;
	
	pFun = (Fun)address[0][0];
	pFun();
	pFun = (Fun)address[0][1];
	pFun();
	pFun = (Fun)address[0][2];
	pFun();
    pFun = (Fun)address[0][3];
    pFun();
    pFun = (Fun)address[0][4];
    pFun();
	pFun = (Fun)address[1][0];
	pFun();
	pFun = (Fun)address[1][1];
	pFun();
	pFun = (Fun)address[1][2];
	pFun();
	cout << sizeof(d) << endl; 

	return 0;
}

在这里插入图片描述

补充

子类覆盖了父类的虚函数后，为什么还可以引用父类的函数？

#include<iostream>
using namespace std;

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

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

int main() {
	Derive d;
	d.f();
	d.Base::f();
}

答：
域作用符::可以禁止虚拟调度机制，有效地将虚拟成员函数调用转换为普通成员函数调用。
虚函数是指这个函数的签名。
而这个虚函数在类中的实现不是，它是一个实实在在的成员函数。
和普通的函数一样的。
如果这个函数是虚函数，此时编译器会把其地址放在虚函数表中。不是虚函数不会放入虚函数表中。
所以这个函数有两个入口。
第一个就是通过域作用符呼叫，和普通的成员函数一致。
第二个是通过引用呼叫，此时编译器会通过虚表来呼叫。

这个问题让我想到了《Effective C++》的条款33：避免遮掩继承而来的名称，其也是陈述了可以使用using声明式或者转交函数来让被遮掩的名称再见天日。

参考原文链接

1、https://blog.csdn.net/a3192048/article/details/82190866
2、https://stackoverflow.com/questions/11426970/why-can-a-derived-class-virtual-function-call-a-base-class-virtual-function-how
3、https://www.zhihu.com/question/28638698
4、https://blog.csdn.net/haoel/article/details/1948051

xxZkj

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C++虚函数表分析——参考陈皓版

C++虚函数表分析——参考陈皓版前言虚函数表一般继承（无虚函数覆盖）一般继承（有虚函数覆盖）多继承（无虚函数覆盖）多继承（有虚函数覆盖）安全性例程补充参考原文链接适用于64位机前言C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。虚函数表对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Tabl
复制链接

扫一扫