c++::详解虚表

最新推荐文章于 2024-04-27 18:58:47 发布
最新推荐文章于 2024-04-27 18:58:47 发布
阅读量7.8k 收藏 46
点赞数 9
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lalu58/article/details/53674461
版权

(注：以下的运行环境是vs2008)

【虚表的定义】：

1.1定义：

每个有虚函数的类或者虚继承的子类，编译器都会为它生成一个虚表，表中的每一个元素都指向一个虚函数的地址（虚表是从属于类的）

1.2理解的关键点：

1）编译器会为包含虚函数的类加上一个成员变量，是一个指向该虚函数表的指针，虚表指针是从属于对象的，也就是说，如果一个类含有虚表，那么类的每个对象都含有虚表指针
2） 虚表的内容是依据类中的虚函数声明次序—填入函数指针。

【虚表的创建】：

1）基类（虚表）：按照虚函数在基类中出现的先后次序进行一次逐个填写虚表地址。

2）派生类（虚表）：

      A、先要知道基类虚表的格式

      B、派生类对基类中那些虚函数进行重写，如果重写了，会将虚表中相同偏移位置的函数的地址进行重写

      C、再将最后四个字节写为0

注意：

1、     不同对象的虚表地址相同

2、     基类类型的指针指向派生类对象，要调用派生类重写的函数时，无法调用

【不同继承方式下不同情况的虚表】：

（分别从继承方式，有无重写和是否是虚拟继承来进行分析）

2.1单继承的无重写的虚表

1）说明:程序的结果：
           A:基类的打印自己的，派生类的也打印自己的 
           B:基类大小：如果有成员的话，就是成员加头四个字节（指向虚表的指针）派生类大小；如果有成员的话，就是成员加基类加指向虚表的指针

2）举例代码：

#include<iostream>
using namespace std;
class Base
{
public:
	Base()
	{
		b=10;
	}
	virtual void fun0()
	{
		cout<<"Base::fun0()"<<endl;
	}
	virtual void fun1()
	{
		cout<<"Base::fun1()"<<endl;
	}
	virtual void fun2()
	{
		cout<<"Base::fun2()"<<endl;
	}
	int b;
};
class Derived:public Base
{
public:
	Derived()
	{}
	virtual void fun3()
	{
		cout<<"Derived::fun3()"<<endl;
	}
	virtual void fun4()
	{
		cout<<"Derived::fun4()"<<endl;
	}
	virtual void fun5()
	{
		cout<<"Derived::fun5()"<<endl;
	}
	int d;
};
typedef void (*vpf)();
void Printvpf()
{
	Base b;
	Derived d;
	cout<<"Base::vpf"<<endl;
	vpf* n = (vpf*)*(int *)(&b);
	while(*n)
	{
		(*n)();
		n++;
	}
	cout<<"Derived::vpf"<<endl;
	vpf* pn = (vpf*)*(int *)(&d);
	while(*pn)
	{
		(*pn)();
		pn++;
	}
	cout<<sizeof(Base)<<endl;
	cout<<sizeof(Derived)<<endl;
}
int main()
{
	Printvpf();
	return 0;
}
3）程序的运行结果图：

2.2单继承的有重写的虚表

1）说明:程序的结果：

           基类依然打印自己的，派生类将基类对应偏移位置的覆盖掉

2）举例代码：

#include<iostream>
using namespace std;
class Base
{
public:
	Base()
	{
		b=10;
	}
	virtual void fun0()
	{
		cout<<"Base::fun0()"<<endl;
	}
	virtual void fun1()
	{
		cout<<"Base::fun1()"<<endl;
	}
	virtual void fun2()
	{
		cout<<"Base::fun2()"<<endl;
	}
	int b;
};
class Derived:public Base
{
public:
	Derived()
	{d = 10;}
	virtual void fun0()
	{
		cout<<"Derived::fun0()"<<endl;
	}
	virtual void fun1()
	{
		cout<<"Derived::fun1()"<<endl;
	}
	virtual void fun5()
	{
		cout<<"Derived::fun5()"<<endl;
	}
	int d;
};
typedef void (*vpf)();
void Printvpf()
{
	Base b;
	Derived d;
	cout<<"Base::vpf"<<endl;
	vpf* n = (vpf*)*(int *)(&b);
	while(*n)
	{
		(*n)();
		n++;
	}
	cout<<"Derived::vpf"<<endl;
	vpf* pn = (vpf*)*(int *)(&d);
	while(*pn)
	{
		(*pn)();
		pn++;
	}
	cout<<sizeof(Base)<<endl;
	cout<<sizeof(Derived)<<endl;
}
int main()
{
	Printvpf();
	return 0;
}
3）运行程序结果


2.3单继承的虚拟继承的无重写的虚表

1）程序运行结果说明：

     A:基类打印自己的，派生类只打印自己的，并不会打印基类的
     B:基类大小：不变
        派生类大小：要加一个偏移量，所以多八个字节
       依次是：指向派生类的虚表指针，偏移量，派生类的数据成员，
             指向基类的虚表指针，基类的数据成员
2）举例代码：

#include<iostream>
using namespace std;
class Base
{
public:
	Base()
	{
		b=10;
	}
	virtual void fun0()
	{
		cout<<"Base::fun0()"<<endl;
	}
	virtual void fun1()
	{
		cout<<"Base::fun1()"<<endl;
	}
	virtual void fun2()
	{
		cout<<"Base::fun2()"<<endl;
	}
	int b;
};
class Derived:virtual public Base
{
public:
	Derived()
	{d = 20;}
	virtual void fun3()
	{
		cout<<"Derived::fun3()"<<endl;
	}
	virtual void fun4()
	{
		cout<<"Derived::fun4()"<<endl;
	}
	virtual void fun5()
	{
		cout<<"Derived::fun5()"<<endl;
	}
	int d;
};
typedef void (*vpf)();
void Printvpf()
{
	Base b;
	Derived d;
	//Base* p = &d;
	cout<<"Base::vpf"<<endl;
	vpf* n = (vpf*)*(int *)(&b);
	while(*n)
	{
		(*n)();
		n++;
	}
	cout<<"Derived::vpf"<<endl;
	vpf* pn = (vpf*)*(int *)(&d);
	while(*pn)
	{
		(*pn)();
		pn++;
	}
	cout<<sizeof(Base)<<endl;
	cout<<sizeof(Derived)<<endl;
}
int main()
{
	Printvpf();
	return 0;
}
3）程序运行结果：


4）对象模型分析：


2.4单继承的虚拟继承的有重写的虚表

1）程序结果分析：

    A:基类打印的不变，派生类将重写的不打印，只打印自己的
    B:基类大小：不变  
       派生类的大小：和无重写的几乎一样，不过多了一个用于区分对象的0
                            这个0加在了派生类数据成员和指向基类虚表的指针之间，
            这就是多出来的四个字节
2）举例代码：

#include<iostream>
using namespace std;
class Base
{
public:
	Base()
	{
		b=10;
	}
	virtual void fun0()
	{
		cout<<"Base::fun0()"<<endl;
	}
	virtual void fun1()
	{
		cout<<"Base::fun1()"<<endl;
	}
	virtual void fun2()
	{
		cout<<"Base::fun2()"<<endl;
	}
	int b;
};
class Derived:virtual public Base
{
public:
	Derived()
	{d = 20;}
	virtual void fun0()
	{
		cout<<"Derived::fun0()"<<endl;
	}
	virtual void fun1()
	{
		cout<<"Derived::fun1()"<<endl;
	}
	virtual void fun5()
	{
		cout<<"Derived::fun5()"<<endl;
	}
	int d;
};
typedef void (*vpf)();
void Printvpf()
{
	Base b;
	Derived d;
	//Base* p = &d;
	cout<<"Base::vpf"<<endl;
	vpf* n = (vpf*)*(int *)(&b);
	while(*n)
	{
		(*n)();
		n++;
	}
	cout<<"Derived::vpf"<<endl;
	vpf* pn = (vpf*)*(int *)(&d);
	while(*pn)
	{
		(*pn)();
		pn++;
	}
	cout<<sizeof(Base)<<endl;
	cout<<sizeof(Derived)<<endl;
}
int main()
{
	Printvpf();
	return 0;
}
3）代码运行结果：


4）对象模型分析


2.5多继承的无重写的虚表

1）程序运行结果说明：

    A:基类1：打印自己的
    B: 基类2：打印自己的
    C:派生类：打印基类一，打印自己的
    D:大小：基类大小不变，派生类大小是基类一加基类2加自己的数据成员大小
2）举例代码：

#include<iostream>
using namespace std;
class Base1
{
public:
	Base1()
	{
		b=10;
	}
	virtual void fun0()
	{
		cout<<"Base1::fun0()"<<endl;
	}
	virtual void fun1()
	{
		cout<<"Base1::fun1()"<<endl;
	}
	virtual void fun2()
	{
		cout<<"Base1::fun2()"<<endl;
	}
	int b;
};
class Base2
{
public:
	Base2()
	{
		b=20;
	}
	virtual void fun3()
	{
		cout<<"Base2::fun3()"<<endl;
	}
	virtual void fun4()
	{
		cout<<"Base2::fun4()"<<endl;
	}
	virtual void fun5()
	{
		cout<<"Base2::fun5()"<<endl;
	}
	int b;
};
class Derived:public Base1,public Base2
{
public:
	Derived()
	{d = 30;}
	virtual void fun6()
	{
		cout<<"Derived::fun6()"<<endl;
	}
	virtual void fun7()
	{
		cout<<"Derived::fun7()"<<endl;
	}
	virtual void fun8()
	{
		cout<<"Derived::fun8()"<<endl;
	}
	int d;
};
typedef void (*vpf)();
void Printvpf()
{
	Base1 b1;
	Base2 b2;
	Derived d;
	cout<<"Base1::vpf"<<endl;
	vpf* n = (vpf*)*(int *)(&b1);
	while(*n)
	{
		(*n)();
		n++;
	}
	cout<<"Base2::vpf"<<endl;
	vpf* pn = (vpf*)*(int *)(&b2);
	while(*pn)
	{
		(*pn)();
		pn++;
	}
	cout<<"Derived::vpf"<<endl;
	vpf* ppn = (vpf*)*((int *)(&d)+2);
	while(*ppn)
	{
		(*ppn)();
		ppn++;
	}
	cout<<sizeof(Base1)<<endl;
	cout<<sizeof(Base2)<<endl;
	cout<<sizeof(Derived)<<endl;
}
int main()
{
	Printvpf();
	return 0;
}
3）代码运行结果


4）对象模型说明


2.6多继承的有重写的虚表

1）程序运行结果说明：

    A: 执行结果：派生类覆盖了基类的，其他不变
    B: 大小：同上
2）举例代码：

#include<iostream>
using namespace std;
class Base1
{
public:
	Base1()
	{
		b=10;
	}
	virtual void fun0()
	{
		cout<<"Base1::fun0()"<<endl;
	}
	virtual void fun1()
	{
		cout<<"Base1::fun1()"<<endl;
	}
	virtual void fun2()
	{
		cout<<"Base1::fun2()"<<endl;
	}
	int b;
};
class Base2
{
public:
	Base2()
	{
		b=20;
	}
	virtual void fun3()
	{
		cout<<"Base2::fun3()"<<endl;
	}
	virtual void fun4()
	{
		cout<<"Base2::fun4()"<<endl;
	}
	virtual void fun5()
	{
		cout<<"Base2::fun5()"<<endl;
	}
	int b;
};
class Derived:public Base1,public Base2
{
public:
	Derived()
	{d = 30;}
	virtual void fun0()
	{
		cout<<"Derived::fun0()"<<endl;
	}
	virtual void fun1()
	{
		cout<<"Derived::fun1()"<<endl;
	}
	virtual void fun8()
	{
		cout<<"Derived::fun8()"<<endl;
	}
	int d;
};
typedef void (*vpf)();
void Printvpf()
{
	Base1 b1;
	Base2 b2;
	Derived d;
	//Base* p = &d;
	cout<<"Base1::vpf"<<endl;
	vpf* n = (vpf*)*(int *)(&b1);
	while(*n)
	{
		(*n)();
		n++;
	}
	cout<<"Base2::vpf"<<endl;
	vpf* pn = (vpf*)*(int *)(&b2);
	while(*pn)
	{
		(*pn)();
		pn++;
	}
	cout<<"Derived::vpf"<<endl;
	vpf* ppn = (vpf*)*(int *)(&d);
	while(*ppn)
	{
		(*ppn)();
		ppn++;
	}
	cout<<sizeof(Base1)<<endl;
	cout<<sizeof(Base2)<<endl;
	cout<<sizeof(Derived)<<endl;
}
int main()
{
	Printvpf();
	return 0;
}
4）对象模型解析

    这个我就不做过多的分析了。

2.8多继承的虚拟继承的无重写的虚表（虚拟继承一个基类）

1）程序运行结果说明：

     A：基类打印：基类打印自己的
     B：大小：多了偏移量，多了四个字节
2）举例代码：

#include<iostream>
using namespace std;
class Base1
{
public:
	Base1()
	{
		b=10;
	}
	virtual void fun0()
	{
		cout<<"Base1::fun0()"<<endl;
	}
	virtual void fun1()
	{
		cout<<"Base1::fun1()"<<endl;
	}
	virtual void fun2()
	{
		cout<<"Base1::fun2()"<<endl;
	}
	int b;
};
class Base2
{
public:
	Base2()
	{
		b=20;
	}
	virtual void fun3()
	{
		cout<<"Base2::fun3()"<<endl;
	}
	virtual void fun4()
	{
		cout<<"Base2::fun4()"<<endl;
	}
	virtual void fun5()
	{
		cout<<"Base2::fun5()"<<endl;
	}
	int b;
};
class Derived:virtual public Base1,public Base2
{
public:
	Derived()
	{d = 30;}
	virtual void fun6()
	{
		cout<<"Derived::fun6()"<<endl;
	}
	virtual void fun7()
	{
		cout<<"Derived::fun7()"<<endl;
	}
	virtual void fun8()
	{
		cout<<"Derived::fun8()"<<endl;
	}
	int d;
};
typedef void (*vpf)();
void Printvpf()
{
	Base1 b1;
	Base2 b2;
	Derived d;
	//Base* p = &d;
	cout<<"Base1::vpf"<<endl;
	vpf* n = (vpf*)*(int *)(&b1);
	while(*n)
	{
		(*n)();
		n++;
	}
	cout<<"Base2::vpf"<<endl;
	vpf* pn = (vpf*)*(int *)(&b2);
	while(*pn)
	{
		(*pn)();
		pn++;
	}
	cout<<"Derived::vpf"<<endl;
	vpf* ppn = (vpf*)*(int *)(&d);
	while(*ppn)
	{
		(*ppn)();
		ppn++;
	}
	cout<<sizeof(Base1)<<endl;
	cout<<sizeof(Base2)<<endl;
	cout<<sizeof(Derived)<<endl;
}
int main()
{
	Printvpf();
	return 0;
}
3）代码运行结果：


4）

2.9多继承的虚拟继承的无重写的虚表（虚拟继承所有的基类）

1）程序运行结果分析

     A:基类打印：基类打印自己的,派生类只打印自己的
     B:大小：多了偏移量，多了八个字节
2）举例代码

#include<iostream>
using namespace std;
class Base1
{
public:
	Base1()
	{
		b=10;
	}
	virtual void fun0()
	{
		cout<<"Base1::fun0()"<<endl;
	}
	virtual void fun1()
	{
		cout<<"Base1::fun1()"<<endl;
	}
	virtual void fun2()
	{
		cout<<"Base1::fun2()"<<endl;
	}
	int b;
};
class Base2
{
public:
	Base2()
	{
		b=20;
	}
	virtual void fun3()
	{
		cout<<"Base2::fun3()"<<endl;
	}
	virtual void fun4()
	{
		cout<<"Base2::fun4()"<<endl;
	}
	virtual void fun5()
	{
		cout<<"Base2::fun5()"<<endl;
	}
	int b;
};
class Derived:virtual public Base1,virtual public Base2
{
public:
	Derived()
	{d = 30;}
	virtual void fun6()
	{
		cout<<"Derived::fun6()"<<endl;
	}
	virtual void fun7()
	{
		cout<<"Derived::fun7()"<<endl;
	}
	virtual void fun8()
	{
		cout<<"Derived::fun8()"<<endl;
	}
	int d;
};
typedef void (*vpf)();
void Printvpf()
{
	Base1 b1;
	Base2 b2;
	Derived d;
	//Base* p = &d;
	cout<<"Base1::vpf"<<endl;
	vpf* n = (vpf*)*(int *)(&b1);
	while(*n)
	{
		(*n)();
		n++;
	}
	cout<<"Base2::vpf"<<endl;
	vpf* pn = (vpf*)*(int *)(&b2);
	while(*pn)
	{
		(*pn)();
		pn++;
	}
	cout<<"Derived::vpf"<<endl;
	vpf* ppn = (vpf*)*(int *)(&d);
	while(*ppn)
	{
		(*ppn)();
		ppn++;
	}
	cout<<sizeof(Base1)<<endl;
	cout<<sizeof(Base2)<<endl;
	cout<<sizeof(Derived)<<endl;
}
int main()
{
	Printvpf();
	return 0;
}

3）程序运行结果


4）对象模型分析


2.10多继承的虚拟继承的有重写的虚表（虚拟继承一个基类）

1）程序运行结果说明
      A：基类不变，派生类重写的基类一未影响，二会覆盖
2）举例代码： 
#include<iostream>
using namespace std;
class Base1
{
public:
	Base1()
	{
		b=10;
	}
	virtual void fun0()
	{
		cout<<"Base1::fun0()"<<endl;
	}
	virtual void fun1()
	{
		cout<<"Base1::fun1()"<<endl;
	}
	virtual void fun2()
	{
		cout<<"Base1::fun2()"<<endl;
	}
	int b;
};
class Base2
{
public:
	Base2()
	{
		b=20;
	}
	virtual void fun3()
	{
		cout<<"Base2::fun3()"<<endl;
	}
	virtual void fun4()
	{
		cout<<"Base2::fun4()"<<endl;
	}
	virtual void fun5()
	{
		cout<<"Base2::fun5()"<<endl;
	}
	int b;
};
class Derived:virtual public Base1,public Base2
{
public:
	Derived()
	{d = 30;}
	virtual void fun0()
	{
		cout<<"Derived::fun0()"<<endl;
	}
	virtual void fun4()
	{
		cout<<"Derived::fun4()"<<endl;
	}
	virtual void fun8()
	{
		cout<<"Derived::fun8()"<<endl;
	}
	int d;
};
typedef void (*vpf)();
void Printvpf()
{
	Base1 b1;
	Base2 b2;
	Derived d;
	//Base* p = &d;
	cout<<"Base1::vpf"<<endl;
	vpf* n = (vpf*)*(int *)(&b1);
	while(*n)
	{
		(*n)();
		n++;
	}
	cout<<"Base2::vpf"<<endl;
	vpf* pn = (vpf*)*(int *)(&b2);
	while(*pn)
	{
		(*pn)();
		pn++;
	}
	cout<<"Derived::vpf"<<endl;
	vpf* ppn = (vpf*)*(int *)(&d);
	while(*ppn)
	{
		(*ppn)();
		ppn++;
	}
	cout<<sizeof(Base1)<<endl;
	cout<<sizeof(Base2)<<endl;
	cout<<sizeof(Derived)<<endl;
}
int main()
{
	Printvpf();
	return 0;
}
3）程序运行结果

4）对象模型说明

2.11多继承的虚拟继承的有重写的虚表（虚拟继承所有的基类）

1）程序运行结果说明：

     A:基类不变，派生类重写的不打印，只打印自己的
     B:大小：重写的话，重写几个就多几个字节,多了一个用于区分的零在B1和D之间

2）举例代码：

#include<iostream>
using namespace std;
class Base1
{
public:
	Base1()
	{
		b=10;
	}
	virtual void fun0()
	{
		cout<<"Base1::fun0()"<<endl;
	}
	virtual void fun1()
	{
		cout<<"Base1::fun1()"<<endl;
	}
	virtual void fun2()
	{
		cout<<"Base1::fun2()"<<endl;
	}
	int b;
};
class Base2
{
public:
	Base2()
	{
		b=20;
	}
	virtual void fun3()
	{
		cout<<"Base2::fun3()"<<endl;
	}
	virtual void fun4()
	{
		cout<<"Base2::fun4()"<<endl;
	}
	virtual void fun5()
	{
		cout<<"Base2::fun5()"<<endl;
	}
	int b;
};
class Derived:virtual public Base1,virtual public Base2
{
public:
	Derived()
	{d = 30;}
	virtual void fun0()
	{
		cout<<"Derived::fun0()"<<endl;
	}
	virtual void fun7()
	{
		cout<<"Derived::fun7()"<<endl;
	}
	virtual void fun8()
	{
		cout<<"Derived::fun8()"<<endl;
	}
	int d;
};
typedef void (*vpf)();
void Printvpf()
{
	Base1 b1;
	Base2 b2;
	Derived d;
	//Base* p = &d;
	cout<<"Base1::vpf"<<endl;
	vpf* n = (vpf*)*(int *)(&b1);
	while(*n)
	{
		(*n)();
		n++;
	}
	cout<<"Base2::vpf"<<endl;
	vpf* pn = (vpf*)*(int *)(&b2);
	while(*pn)
	{
		(*pn)();
		pn++;
	}
	cout<<"Derived::vpf"<<endl;
	vpf* ppn = (vpf*)*(int *)(&d);
	while(*ppn)
	{
		(*ppn)();
		ppn++;
	}
	cout<<sizeof(Base1)<<endl;
	cout<<sizeof(Base2)<<endl;
	cout<<sizeof(Derived)<<endl;
}
int main()
{
	Printvpf();
	return 0;
}
3）程序运行结果

2.12无重写普通的菱形继承

1）程序运行结果分析：

     A：不过加了虚函数，这时D内存结果是顺序继承：B,C1,C2,D, 
          （但是在C1和C2之间多了一个地址和一个数据。我的编译器是这样）
     B:  D执行结果：打印出基类B，基类C1，D
     C：执行结果的大小：28
2）举例代码：

#include<iostream>
using namespace std;
class Base
{
public:
	Base()
	{
		b=10;
	}
	virtual void fun0()
	{
		cout<<"Base::fun0()"<<endl;
	}
	virtual void fun1()
	{
		cout<<"Base::fun1()"<<endl;
	}
	virtual void fun2()
	{
		cout<<"Base::fun2()"<<endl;
	}
	int b;
};
class C1:public Base
{
public:
	C1()
	{
		c1=20;
	}
	virtual void fun3()
	{
		cout<<"C1::fun3()"<<endl;
	}
	virtual void fun4()
	{
		cout<<"C1::fun4()"<<endl;
	}
	virtual void fun5()
	{
		cout<<"C1::fun5()"<<endl;
	}
	int c1;
};
class C2:public Base
{
public:
	C2()
	{
		c2=30;
	}
	virtual void fun6()
	{
		cout<<"C2::fun6()"<<endl;
	}
	virtual void fun7()
	{
		cout<<"C2::fun7()"<<endl;
	}
	virtual void fun8()
	{
		cout<<"C2::fun8()"<<endl;
	}
	int c2;
};
class Derived:public C1,public C2
{
public:
	Derived()
	{
		d = 40;
	}
	virtual void fun9()
	{
		cout<<"Derived::fun9()"<<endl;
	}
	virtual void fun10()
	{
		cout<<"Derived::fun10()"<<endl;
	}
	virtual void fun11()
	{
		cout<<"Derived::fun11()"<<endl;
	}
	int d;
};
typedef void (*vpf)();
void Printvpf()
{
	Base b;
	C1 c1;
	C2 c2;
	Derived d;
	cout<<"Base::vpf"<<endl;
	vpf* n = (vpf*)*(int *)(&b);
	while(*n)
	{
		(*n)();
		n++;
	}
	cout<<"C1::vpf"<<endl;
	vpf* pn1 = (vpf*)*(int *)(&c1);
	while(*pn1)
	{
		(*pn1)();
		pn1++;
	}
	cout<<"C2::vpf"<<endl;
	vpf* pn2 = (vpf*)*(int *)(&c2);
	while(*pn2)
	{
		(*pn2)();
		pn2++;
	}
	cout<<"Derived::vpf"<<endl;
	vpf* ppn = (vpf*)*(int *)(&d);
	while(*ppn)
	{
		(*ppn)();
		ppn++;
	}
	cout<<sizeof(Base)<<endl;
	cout<<sizeof(C1)<<endl;
	cout<<sizeof(C2)<<endl;
	cout<<sizeof(Derived)<<endl;
}
int main()
{
	Printvpf();
	return 0;
}
3）代码运行结果


2.13无重写（只有一个直接基类的此处为C1）普通的菱形继承

1）程序运行结果分析

    A：D 的打印结果：打印C1，打印D
          当然C1的大小多了八个字节
    B:执行结果的大小36

2）举例代码

#include<iostream>
using namespace std;
class Base
{
public:
	Base()
	{
		b=10;
	}
	virtual void fun0()
	{
		cout<<"Base::fun0()"<<endl;
	}
	virtual void fun1()
	{
		cout<<"Base::fun1()"<<endl;
	}
	virtual void fun2()
	{
		cout<<"Base::fun2()"<<endl;
	}
	int b;
};
class C1:virtual public Base
{
public:
	C1()
	{
		c1=20;
	}
	virtual void fun3()
	{
		cout<<"C1::fun3()"<<endl;
	}
	virtual void fun4()
	{
		cout<<"C1::fun4()"<<endl;
	}
	virtual void fun5()
	{
		cout<<"C1::fun5()"<<endl;
	}
	int c1;
};
class C2:public Base
{
public:
	C2()
	{
		c2=30;
	}
	virtual void fun6()
	{
		cout<<"C2::fun6()"<<endl;
	}
	virtual void fun7()
	{
		cout<<"C2::fun7()"<<endl;
	}
	virtual void fun8()
	{
		cout<<"C2::fun8()"<<endl;
	}
	int c2;
};
class Derived:public C1,public C2
{
public:
	Derived()
	{
		d = 40;
	}
	virtual void fun9()
	{
		cout<<"Derived::fun9()"<<endl;
	}
	virtual void fun10()
	{
		cout<<"Derived::fun10()"<<endl;
	}
	virtual void fun11()
	{
		cout<<"Derived::fun11()"<<endl;
	}
	int d;
};
typedef void (*vpf)();
void Printvpf()
{
	Base b;
	C1 c1;
	C2 c2;
	Derived d;
	cout<<"Base::vpf"<<endl;
	vpf* n = (vpf*)*(int *)(&b);
	while(*n)
	{
		(*n)();
		n++;
	}
	cout<<"C1::vpf"<<endl;
	vpf* pn1 = (vpf*)*(int *)(&c1);
	while(*pn1)
	{
		(*pn1)();
		pn1++;
	}
	cout<<"C2::vpf"<<endl;
	vpf* pn2 = (vpf*)*(int *)(&c2);
	while(*pn2)
	{
		(*pn2)();
		pn2++;
	}
	cout<<"Derived::vpf"<<endl;
	vpf* ppn = (vpf*)*(int *)(&d);
	while(*ppn)
	{
		(*ppn)();
		ppn++;
	}
	cout<<sizeof(Base)<<endl;
	cout<<sizeof(C1)<<endl;
	cout<<sizeof(C2)<<endl;
	cout<<sizeof(Derived)<<endl;
}
int main()
{
	Printvpf();
	return 0;
}

3）程序运行结果


2.13无重写（所有的直接基类都虚拟继承）普通的菱形继承

1）程序运行结果分析

     A：和上面的几乎一样，不同的是C2必然多了八个字节

2）举例代码;

#include<iostream>
using namespace std;
class Base
{
public:
	Base()
	{
		b=10;
	}
	virtual void fun0()
	{
		cout<<"Base::fun0()"<<endl;
	}
	virtual void fun1()
	{
		cout<<"Base::fun1()"<<endl;
	}
	virtual void fun2()
	{
		cout<<"Base::fun2()"<<endl;
	}
	int b;
};
class C1:virtual public Base
{
public:
	C1()
	{
		c1=20;
	}
	virtual void fun3()
	{
		cout<<"C1::fun3()"<<endl;
	}
	virtual void fun4()
	{
		cout<<"C1::fun4()"<<endl;
	}
	virtual void fun5()
	{
		cout<<"C1::fun5()"<<endl;
	}
	int c1;
};
class C2:virtual public Base
{
public:
	C2()
	{
		c2=30;
	}
	virtual void fun6()
	{
		cout<<"C2::fun6()"<<endl;
	}
	virtual void fun7()
	{
		cout<<"C2::fun7()"<<endl;
	}
	virtual void fun8()
	{
		cout<<"C2::fun8()"<<endl;
	}
	int c2;
};
class Derived:public C1,public C2
{
public:
	Derived()
	{
		d = 40;
	}
	virtual void fun9()
	{
		cout<<"Derived::fun9()"<<endl;
	}
	virtual void fun10()
	{
		cout<<"Derived::fun10()"<<endl;
	}
	virtual void fun11()
	{
		cout<<"Derived::fun11()"<<endl;
	}
	int d;
};
typedef void (*vpf)();
void Printvpf()
{
	Base b;
	C1 c1;
	C2 c2;
	Derived d;
	cout<<"Base::vpf"<<endl;
	vpf* n = (vpf*)*(int *)(&b);
	while(*n)
	{
		(*n)();
		n++;
	}
	cout<<"C1::vpf"<<endl;
	vpf* pn1 = (vpf*)*(int *)(&c1);
	while(*pn1)
	{
		(*pn1)();
		pn1++;
	}
	cout<<"C2::vpf"<<endl;
	vpf* pn2 = (vpf*)*(int *)(&c2);
	while(*pn2)
	{
		(*pn2)();
		pn2++;
	}
	cout<<"Derived::vpf"<<endl;
	vpf* ppn = (vpf*)*(int *)(&d);
	while(*ppn)
	{
		(*ppn)();
		ppn++;
	}
	cout<<sizeof(Base)<<endl;
	cout<<sizeof(C1)<<endl;
	cout<<sizeof(C2)<<endl;
	cout<<sizeof(Derived)<<endl;
}
int main()
{
	Printvpf();
	return 0;
}

3）程序运行结果


最后要说明的:还有一些情况类似于上面的，我就不一一说明了，我写的都是比较经典的情况，希望能对大家有所帮助！吐舌头


海绵宝宝的欧尼
关注
  • 9
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
C++类对象关于虚函数表详解
03-14
《C++类对象关于虚函数表详解》 C++中的虚函数是实现多态性的重要机制，它允许通过基类指针调用派生类的重写函数，从而展现出多种形态，这是一种典型的泛型技术。泛型技术的目标是用统一的代码处理不同类型的数据或...
C++的虚析构详解及实例代码
08-30
C++虚析构详解及实例代码 C++虚析构详解是指在C++中，使用虚函数来实现析构函数，以便在删除父类指针时，正确地销毁子类对象，避免内存泄露。下面是关于C++虚析构详解的知识点： 1. 虚析构的概念：虚析构是指在...
C++虚表详解
热门推荐
chczy1的博客
09-03 1万+
使用工具： 本文输出内存模型的工具为vs2017开发人员命令提示符，使用方法如图所示： 我们使用cl（不是C1，不是C一，是cl，LLLLL）命令cl的语法为： cl [filename].cpp /d1reportSingleClassLayout[className] 意思是查看[filename].cpp文件中名称以[className]开头的所有类的内存模型 如果文件不在同一...
C++虚表与虚表指针详解
zdlzf的博客
11-04 823
每个包含了虚函数的类都包含一个虚表。当一个类（B）继承另一个类（A）时，类B会继承类A的函数的调用权。所以如果一个基类包含了虚函数，那么其继承类也可调用这些虚函数，换句话说，一个类继承了包含虚函数的基类，那么这个类也拥有自己的虚表。来看以下的代码。类A包含虚函数vfunc1，vfunc2，由于类A包含虚函数，故类A拥有一个虚表。类A的虚表如图1所示。虚表是一个指针数组，其元素是虚函数的指针，每个元素对应一个虚函数的函数指针。
C++顺序表的创建及常用14种操作
最新发布
程序猿老樊的博客
04-27 693
顺序表通常使用数组来实现。为了便于管理顺序表，我们通常定义一个结构体来封装数组和记录顺序表当前的长度。顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。
【C++】虚表和虚基表到底有哪些区别？
qq_40376612的博客
05-24 1536
虚表和虚基表在同时存在时的对象模型
C++虚表解析
pyd_pyd的博客
10-27 115
但是对象不一样，是一个对象的时候，父类对象=子类对象，是把子类对象内的父类部分内容拷贝过来，调用拷贝构造，拷贝的时候不会拷贝虚表指针，原因是拷贝过来，这个时候不能保证多态指向父类，还能调用父类的虚函数，如果拷贝虚表指针，父类对象不能保证一定是父类的虚表，如果被赋值就是子类的虚表了，这样就只能调用子类了，并且析构函数可能会调错。重写的悬殊会覆盖虚表中原来父类虚函数的位置，没有覆盖的虚函数依旧，因此使用父类指针调用子类对象的时候，会进行切片，查找到的虚函数地址是子类的，因此会调用子类重写的虚函数。
c++ - 虚函数表
weixin_49303682的博客
12-23 2221
1.什么是虚函数表 所谓虚函数表就是存放着当前类中所有虚函数地址的表。在实例化一个具有虚函数的类时，这个表 也被分配到这个实例对象的内存中，通过虚函数表可以指明所要调用的函数的位置。在C++编译器 中虚函数表的地址存放在对象的最前面，这是为了即使多继承下也能快速获取到虚函数表。 代码示例： class Base{ public: virtual void A(){cout << "Base::A()" << endl;} virtual void B(){cout &
C++虚表结构详解
FBeetle的博客
12-14 2851
原文地址：https://www.learncpp.com/cpp-tutorial/125-the-virtual-table/ 为了实现虚函数，C++使用动态绑定方式，称为虚表。 虚表是一个包含函数的查找表，该查找表用于动态绑定方式解决函数调用问题，虚表有时候被称为“vtable”，"虚函数表"，“虚方法表”，“分派表”。 虚表虽然用语言描述有点复杂，实际上非常简单。 首先，每个包含虚...
C++ 虚函数的详解及简单实例
01-01
C++ 虚函数的详解 虚函数的使用和纯虚函数的使用。 虚函数是在基类定义，然后子类重写这个函数后，基类的指针指向子类的对象，可以调用这个函数，这个函数同时保留这子类重写的功能。 纯虚函数是可以不用在基类定义...
详解C++编程中的虚函数
09-03
3. **虚函数表**：C++实现虚函数调用依赖于虚函数表（Vtable），每个包含虚函数的类都有一个虚函数表，记录了类中虚函数的地址。 4. **构造函数与析构函数**：C++标准规定构造函数不能是虚函数，但析构函数默认是虚...
C++ 虚函数表详解
04-17
C++虚函数表详解 C++中的虚函数表是实现多态机制的关键组件。虚函数表（Virtual Table，简称V-Table）是一种机制，用于存储类的虚函数的地址，解决继承和覆盖的问题，使得父类的指针可以正确地调用子类的成员函数。...
c++虚函数表、地址详解
papaya的博客
07-14 1310
c++虚函数表详解
C/C++杂记：深入虚表结构
weixin_30432007的博客
06-10 185
1. 虚表与“虚函数表” 在“C/C++杂记：虚函数的实现的基本原理”一文中曾提到“虚函数表”的概念，只是为了便于理解，事实是：虚函数表并不真的独立存在，它只是虚表（virtual table）中的一部分内容。例： 从图中可已看出，虚表除了包含虚函数指针，还包含其它一些信息（如：RTTI信息、偏移值等）。 顺便介绍一下gcc的-fdump-class-hierarchy选项，它可以...
C++之虚表
qq_55306792的博客
06-09 1119
虚表理解
【C++】最通俗的多态、虚表、虚指针讲解
beidou111的博客
06-28 3134
多态需要两个特性： （1）方法重写（override）：父类与子类具有函数签名完全相同的方法。 （2）向上类型转换（upcasting）：用一个父类指针指向子类对象的时候，假如调用的是虚函数，会自动暂时将该指针转换为子类类型的指针。虚函数的存在就是为了类型转换，即使没有虚函数也能重写方法。虚函数并不是为了解决函数重写问题的。假如你去在父类和子类中都写上函数签名相同的方法，同样也能重写函数。例如 我们先写一个没有虚函数的例子 结果为 是完全没问题的！是的，即使不加virtual，也能实现方法重写！假如我用子类
在python中使用nvidia的VPF库对RTSP流进行硬解码并使用opencv进行显示
dota的专栏
08-08 3541
随着视频处理技术的不断发展，越来越多的应用需要对视频流进行解码和处理。在本文中，我们将介绍一个基于Python的多线程应用程序，该应用程序可以解码并处理多个RTSP视频流，同时利用GPU加速，以提高处理速度。这个应用程序使用了一些关键的Python库和工具，包括PyNvCodec、OpenCV、和PyCUDA等。它充分利用了现代GPU的计算能力，实现了高效的视频解码和处理。在这个应用程序中，我们使用了Python的库来实现多线程解码。
C++虚函数表剖析
qq_27695961的博客
07-04 324
关键词：虚函数，虚表，虚表指针，动态绑定，多态 一、概述 为了实现C++的多态，C++使用了一种动态绑定的技术。这个技术的核心是虚函数表（下文简称虚表）。本文介绍虚函数表是如何实现动态绑定的。 二、类的虚表 每个包含了虚函数的类都包含一个虚表。  我们知道，当一个类（A）继承另一个类（B）时，类A会继承类B的函数的调用权。所以如果一个基类包含了虚函数，那么其继承类也可调用
C++虚函数表详解
amoscykl的博客
01-05 1万+
C++的虚函数(Virtual Function)是通过一张虚函数表(Virtual Table)来实现的。简称为V-Table。在这个表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖(override)的问题，保证其能真实的反应实际的函数。这样，在有虚函数的类的实例中这张表被分配在了这个实例的内存中，所以当我们用父类的指针操作一个子类的时候，这张虚函数表就显得尤为重要了，他就像一个地...
C++虚函数，多态，详解
04-26
C++中的虚函数是在基类中声明的，它被用来实现多态性。多态性是指同一个函数名可以被具有不同类型的对象调用，而它们会产生不同的结果。虚函数的实现方式是将一个默认实现在基类中声明为虚函数，在派生类中可以重新定义或者覆盖这个函数的实现，从而实现多态性。 在C++中，如果一个类至少有一个虚函数，则编译器会自动为这个类生成一个虚函数表，也称为vtable，它保存着这个类中所有虚函数的地址。当我们定义一个对象并调用它的虚函数时，编译器会在这个对象的内存中查找vtable，并根据函数指针调用正确的函数实现。 使用多态性可以使程序更加灵活，因为它可以让派生类对基类中的某个函数重新定义其实现，同时也不会影响其他代码对基类函数的调用。此外，多态性也可以简化代码，并使代码更加易于维护。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值