C++ 学习 对象模型之虚函数

虚函数在C++主要用于通过父类指针调用子类对象方法，从而达到实现多态机制。虚函数声明在类中，用virtual关键字修饰，虚函数在类的定义时就被放在了内存代码段，虚函数不在对象内存布局中。

1.虚函数表与虚函数指针

虚函数表可以看作一段内存里面面放着类里面的所有虚函数指针，当需要调用虚函数就从这里面找。在生成对象时，编译器会产生一个虚函数指针来指向虚函数表，虚函数指针在32位系统占4字节，64位系统占8字节。下面代码实例演示：

#include "stdafx.h"
#include <stdio.h>
#include <iostream>
using namespace std;
class A {
public:
	virtual  void fun1(){
		cout << "this is A  virtual  fun1" << endl;
	}

	virtual  void fun2() {
		cout << "this is A  virtual  fun2" << endl;
	}

	virtual  void fun3() {
		cout << "this is A  virtual  fun3" << endl;
	}
};

int main()
{
	A a1;
	printf("#########  对象a1 占用内存大小 %d\n", sizeof(a1));
	printf("######### 通过对象调用虚函数\n");
	a1.fun1();
	a1.fun2();
	a1.fun3();
	typedef void(*myfun)();
	//拿到虚函数表首地址 vptr就是一个有三个元素的函数指针数组
	long *vptr =(long *)*((long *)(&a1));  
	myfun vfun1 = (myfun)vptr[0];
	myfun vfun2 = (myfun)vptr[1];
	myfun vfun3 = (myfun)vptr[2];
	printf("######### 通过虚函数指针 手工调用虚函数\n");
	vfun1();
	vfun2();
	vfun3();

    return 0;
}

运行结果如下：

因为类A没有构造方法，有三个虚函数，且虚函数不占用对象内存空间。只有一个虚函数指针，所以时4字节。通过手工调用说明了虚函数表指针地址与类对象首地址相同，且虚函数表指针指向的内存存放着虚函数地址，这段内存就叫虚函数表。

2.继承模式下的虚函数与虚函数指针

1.单继承

#include <iostream>
using namespace std;
using namespace std;
class A {
public:
	virtual  void fun1() {
		cout << "this is A  virtual  fun1" << endl;
	}

	virtual  void fun2() {
		cout << "this is A  virtual  fun2" << endl;
	}

	virtual  void fun3() {
		cout << "this is A  virtual  fun3" << endl;
	}
};

class B :public A {
public:
	virtual  void fun3() {
		cout << "this is B  virtual  fun3" << endl;
	}

	virtual  void fun4() {
		cout << "this is B  virtual  fun4" << endl;
	}
};


int main()
{

	B b1;

	printf("#########  对象b1 占用内存大小 %d\n", sizeof(b1));
	printf("######### 通过对象调用虚函数\n");
	b1.fun1();
	b1.fun2();
	b1.fun3();
	b1.fun4();

	typedef void(*myfun)();
	//拿到虚函数表首地址 vptr就是一个有三个元素的函数指针数组
	long *vptr = (long *)*((long *)(&b1));
	myfun vfun1 = (myfun)vptr[0];
	myfun vfun2 = (myfun)vptr[1];
	myfun vfun3 = (myfun)vptr[2];
	myfun vfun4 = (myfun)vptr[3];
	printf("######### 通过虚函数指针 手工调用虚函数\n");
	vfun1();
	vfun2();
	vfun3();
	vfun4();
	return 0;
}

运行结果为：

子类会继承所有父类的虚函数，如果子类有相同名字参数的虚函数则会覆盖父类虚函数。对于父类虚函数fun3，即使子类的fun3不加virtual关键字，编译器也会认为fun3是虚函数，这点需要注意下。在这里父类和子类都只有一个虚函数表，父类和子类的虚函数指针分别指向自己的虚函数表。在这里子类的虚函数表比父类的虚函数表多一个fun4，fun3覆盖父类的fun3。如果子类没有虚函数，那么子类的虚函数表内容与父类的虚函数表内容相同，但虚函数指针不同，指向的虚函数表首地址也不同，仅仅是虚函数表的内容相同而已。虚函数表在类的定义时产生，虚函数指针在对象的构造时产生。

2.多继承

#include <iostream>
using namespace std;
class base1 {
public:
	virtual  void fun1() {
		cout << "this is base1  virtual  fun1" << endl;
	}

	virtual  void fun2() {
		cout << "this is base1  virtual  fun2" << endl;
	}
};

class base2 {
public:

	virtual  void fun3() {
		cout << "this is base2  virtual  fun3" << endl;
	}
	virtual  void fun4() {
		cout << "this is base2  virtual  fun4" << endl;
	}
};


class B :public base1, public base2{
public:

	void fun2() {    //覆盖base1虚函数
		cout << "this is B  virtual  fun2" << endl;
	}

	virtual  void fun3() {   //覆盖base2虚函数
		cout << "this is B  virtual  fun3" << endl;
	}

	virtual  void fun5() {
		cout << "this is B  virtual  fun5" << endl;
	}
};


int main()
{

	B b1;

	printf("#########  对象b1 占用内存大小 %d\n", sizeof(b1));
	printf("######### 通过对象调用虚函数\n");
	b1.fun1();
	b1.fun2();
	b1.fun3();
	b1.fun4();
	b1.fun5();

	typedef void(*myfun)();
	//子类与第一个基类公用一个虚函数指针vptr ，其他的基类有自己的虚函数指针
	long *vptr1 = (long *)*((long *)(&b1));
	myfun vfun1 = (myfun)vptr1[0];
	myfun vfun2 = (myfun)vptr1[1];
	myfun vfun3 = (myfun)vptr1[2];
	//myfun vfun4 = (myfun)vptr1[3];
	//myfun vfun5 = (myfun)vptr[4];
	printf("######### 通过虚函数指针 手工调用虚函数\n");
	vfun1();
	vfun2();
	vfun3();
	//vfun4();

	long *base2_vptr2 = (long *)*(long *)((long *)&b1 + 1);
	myfun base2_vfun1 = (myfun)base2_vptr2[0];
	myfun base2_vfun2 = (myfun)base2_vptr2[1];
	base2_vfun1();
	base2_vfun2();


	return 0;

运行结果如下：

这里对象b1的内存大小是8，说明对象b1有两个虚函数指针，继承自两个基类。其中子类的虚函数指针与子类第一个继承的父类共用，这里子类没有其他数据成员，因此对象b1的两个虚函数指针连续存储。由于子类覆盖了父类两个虚函数，因此子类对象一共有5个虚函数。由于继承两个基类，且这两个基类都有虚函数，所以子类有两个虚函数表，分别由两个虚函数指针指向。在子类定义的时候，对于虚函数表，子类会覆盖父类的同名虚函数。

3.虚函数指针位置分析

证明虚函数指针位置代码如下：

#include <iostream>
using namespace std;
class A {
public:
	int m_a;
	virtual void fun1() {
		cout << "this is A virtual fun1" << endl;
	}

};


int main()
{
	A a;
	long * a_pos = (long *)&a.m_a;
	printf("对象大小 %d, 对象首地址 %p, 成员a的地址%p\n", sizeof(a), &a, a_pos);

	return 0;
}

运行结果为

对象有一个int的数据成员和一个虚函数指针，所以对象大小为8字节，且数据成员的地址比对象首地址要偏移4字节，说明虚函数指针就在对象内存的开始位置。
这张图比较形象的说明了多继承虚函数及虚函数表的布局
图转载自https://blog.csdn.net/qq_36359022/article/details/81870219