C++中虚函数机制分析

最新推荐文章于 2022-02-22 10:37:30 发布

倔强不倒翁

最新推荐文章于 2022-02-22 10:37:30 发布

阅读量402

点赞数

文章标签： C++ 虚函数机制内存布局

本文链接：https://blog.csdn.net/x_r_su/article/details/52385532

版权

1 虚函数机制

C++中的虚函数主要是为实现多态。多态就是用父类型的指针指向其子类的实例对象，然后通过父类的指针调用子类实例对象的成员函数。这可以让父类的指针有“多种形态”，是一种泛型技术（使用不变代码来实现可变算法）。

包含虚函数的类或者从包含虚函数基类派生的类，在创建对象时候，编译器会悄悄在对象内存空间额外分配一个虚表指针（VPTR），该指针指向类的虚表（VTABLE）。虚表VTABLE用来存储虚虚函数地址，可以看作是一个函数指针数组，它属于类但不属于对象，供对象共享访问。虚表指针VPTR属于对象，用来访问类的虚表VTABLE。如果派生类是单一继承则只有一个VPTR，如果是多重继承则可能有多个VPTR。在C++的标准规格说明书中说明，编译器必需要保证虚函数表的指针VPTR存在于对象实例内存空间中最前面的位置。

通过基类指针调用虚函数（多态调用）时，首先取得对象V P T R，然后通过它在V TA B L E表中查找函数地址，这样就能调用正确的函数。

2 虚函数内存布局

以下内容在Ubuntu 16.04 + gcc version 5.4.0上验证。

2.1 多重普通继承

1）代码片段如下：

class B{
	public:
		B():b(5) {}
		virtual void fb1() { cout << "[B::fb1]"; }
		virtual void fb() { cout << "[B::fb]"; }
	private:
		int b;		
};

class B1: public B{
	public:
		B1():b1(10) {}
		virtual void fb1() { cout << "[B1::fb1]"; }
		virtual void fb2() { cout << "[B1::fb2]"; }
		virtual void fb3() { cout << "[B1::fb3]"; }
	private:
		int b1;		
};


class B2: public B{
	public:
		B2():b2(20) {}
		virtual void fb1() { cout << "[B2::fb1]"; }
		virtual void fb2() { cout << "[B2::fb2]"; }
		virtual void fb3() { cout << "[B2::fb3]"; }
	private:


		int b2;


};


class EXT : public B1, public B2{
	public:
		EXT():e(30) {}
		virtual void fb1() { cout << "[EXT::fb1]"; }
		virtual void fe1() { cout << "[EXT::fe1]"; }
	private:
		int e;
};



#define RED "\033[31m"
#define GREEN "\033[32m"
#define YELLOW "\033[33m"
#define BLUE "\033[34m"
#define RESET "\033[0m"


typedef void(*fun)(void);


int main()

{

    fun pfun = NULL;
    EXT e;

    int **pVtab = (int**)&e;

    cout<<BLUE<<"sizeof class B "<<sizeof(class B)<<endl;<span style="color:#3366FF;">//4(B::vptr)+4(B::b)</span>
    cout<<BLUE<<"sizeof class B1 "<<sizeof(class B1)<<endl;<span style="color:#3366FF;">//4(B1::vptr)+4(B::b)+4(B1::b1)</span>
    cout<<"sizeof class B2 "<<sizeof(class B2)<<endl;<span style="color:#3366FF;">//4(B2::vptr)+4(B::b)+4(B2::b2)</span>
    cout<<"sizeof class EXT "<<sizeof(class EXT)<<endl<<endl;<span style="color:#3366FF;">//4(B1::VPTR)+4(B::b)+4(B1:b1)+4(B2:VPTR)+4(B:b)+4(B2:b2)+4(EXT::e)
</span>
    cout<<RED<<"B1::VPTR1->";
    pfun = (fun)pVtab[0][0];
    pfun();


    pfun = (fun)pVtab[0][1];
    pfun();

    pfun = (fun)pVtab[0][2];
    pfun();

    pfun = (fun)pVtab[0][3];
    pfun();

    pfun = (fun)pVtab[0][4];
    pfun();

    cout<<"\nB::b "<<pVtab[1]<<endl;
    cout<<"B1::b1 "<<pVtab[2]<<endl;

    cout<<YELLOW<<"B2::VPTR2->";
    pfun = (fun)pVtab[3][0];
    pfun();

    pfun = (fun)pVtab[3][1];
    pfun();

    pfun = (fun)pVtab[3][2];
    pfun();

    pfun = (fun)pVtab[3][3];
    pfun();

    cout<<"\nB:b "<<pVtab[4]<<endl;
    cout<<"B2:b2 "<<pVtab[5]<<endl;
    cout<<"EXT::e "<<pVtab[6]<<endl<<endl;

    cout<<RESET<<endl;

    e.fb1();
    cout<<endl;

    e.fe1();
    cout<<endl;

    //以下必须指定作用域调用否则有二义性，对于对象e其2基类均有如下函数
    e.B1::fb();
    cout<<endl;

    e.B2::fb();
    cout<<endl;

    e.B1::fb2();
    cout<<endl;

    e.B2::fb2();
    cout<<endl;

    e.B1::fb3();
    cout<<endl;

    e.B2::fb3();
    cout<<endl;


    return 0;

}

2）对象e内存布局如下指示：

从运行打印结果看：

1）对象e占用内存大小为28字节（4(B1::VPTR)+4(B::b)+4(B1:b1)+4(B2:VPTR)+4(B:b)+4(B2:b2)+4(EXT::e)=28）;

2）虚表指针VPTR1和VPTR2分别指向不同的虚表VTABLE;

3）子类的非重写虚函数（EXT：：fe1）放在了继承的第一基类（B1）的虚表后面处;

4）子类重写虚函数（EXT::fb1）分别存在继承的第一基类（B1）和第二基类（B2）虚表中，覆盖了基类的相应函数，这样就实现了通过基类指针调用子类对象函数的多态特性;

5）整体内存布局按照子类继承基类的顺序依次分配，B1->B2->EXT;

6）对于各个类首先分配虚表指针然后分配成员变量;

7）由于B是B1和B2的公共基类，所以导致了类B1和类B2对于类B的重复继承（B::b有2份）;

8）从2张虚表看fb，fb2，fb3在子类EXT的2个基类虚表中均可以找到，所以访问它们需要指定作用域否则产生二义性;

2.2 多重虚拟继承

2.2.1 公共基类是虚基类

1) 部分代码片段

class B{
	public:
		B():b(5) {}
		virtual void fb1() { cout << "[B::fb1]"; }
		virtual void fb() { cout << "[B::fb]"; }
	private:
		int b;		
};

class B1: <strong><span style="color:#3333FF;">virtual</span></strong> public B{
	public:
		B1():b1(10) {}
		virtual void fb1() { cout << "[B1::fb1]"; }
		virtual void fb2() { cout << "[B1::fb2]"; }
		virtual void fb3() { cout << "[B1::fb3]"; }
	private:
		int b1;		
};


class B2: <span style="color:#3333FF;"><strong>virtual</strong></span> public B{
	public:
		B2():b2(20) {}
		virtual void fb1() { cout << "[B2::fb1]"; }
		virtual void fb2() { cout << "[B2::fb2]"; }
		virtual void fb3() { cout << "[B2::fb3]"; }
	private:


		int b2;


};


class EXT : public B1, public B2{
	public:
		EXT():e(30) {}
		virtual void fb1() { cout << "[EXT::fb1]"; }
		virtual void fe1() { cout << "[EXT::fe1]"; }
	private:
		int e;
};

2）内存布局

从运行打印结果看：

1）对象e占用内存大小为28字节（4(B1::vptr)+4(B1::b1)+4(B2::vptr)+4(B2::b2)+4(EXT::e)+4(B::vptr)+4(B::b)=28）;

2）有3个虚表指针B1：：VPTR和B2::VPTR2和B::VPTR分别指向不同的虚表VTABLE;

3）子类的非重写虚函数（EXT：：fe1）放在了继承的第一基类（B1）的虚表后面处;

4）子类重写虚函数（EXT::fb1）分别存在继承的第一基类（B1）和第二基类（B2）虚表中，覆盖了基类的相应函数，这样就实现了通过基类指针调用子类对象函数的多态特性;子类重写的虚函数（EXT::fb1）在虚基类虚表中不再出现。

5）整体内存布局按照子类继承基类的顺序依次分配，B1->B2->EXT->B; 虚基类（B）内存分配位于最后。

6）对于各个类首先分配虚表指针然后分配成员变量;

7）B是B1和B2的公共基类，当其作为虚基类时候避免了类B1和类B2对于类B的重复继承（B::b只有一份）;

8）从3张虚表看fb2，fb3在子类EXT的2个基类（B1和B2）虚表中均可以找到，所以访问它们需要指定作用域否则产生二义性;

fb仅在公共基类（B）虚表中出现是唯一的且public继承而来，可以直接访问不用指定作用域。

9）虚拟继承关系，虚基类和其派生的子类均有各自虚表Vtable; 普通非虚拟继承关系，仅有基类有虚表子类将虚函数插入基类虚表;

10）虚拟继承关系时，子类重写的虚函数仅出现在子类虚表，虚基类虚表不再出现;

2.2.2 非公共基类是虚基类

1）代码片段

class B{
	public:
		B():b(5) {}
		virtual void fb1() { cout << "[B::fb1]"; }
		virtual void fb() { cout << "[B::fb]"; }
	private:
		int b;		
};

class B1: public B{
	public:
		B1():b1(10) {}
		virtual void fb1() { cout << "[B1::fb1]"; }
		virtual void fb2() { cout << "[B1::fb2]"; }
		virtual void fb3() { cout << "[B1::fb3]"; }
	private:
		int b1;		
};


class B2: public B{
	public:
		B2():b2(20) {}
		virtual void fb1() { cout << "[B2::fb1]"; }
		virtual void fb2() { cout << "[B2::fb2]"; }
		virtual void fb3() { cout << "[B2::fb3]"; }
	private:


		int b2;


};


class EXT : <strong><span style="color:#3333FF;">virtual</span></strong> public B1, <strong><span style="color:#3333FF;">virtual</span></strong> public B2{
	public:
		EXT():e(30) {}
		virtual void fb1() { cout << "[EXT::fb1]"; }
		virtual void fe1() { cout << "[EXT::fe1]"; }
	private:
		int e;
};

2）内存布局