C++ 虚拟继承问题

今天药忘吃喽~ 2021-10-26 11:56 245阅读 0赞

### 文章目录 ###

*   *  前言
     *  为什么要有虚拟继承
     *  虚拟继承和普通继承的区别
     *  虚拟继承 sizeof() 问题

## 前言 ##

本篇文章主要描述虚拟继承中内存分布情况，当然，可能会不太完全正确，希望大家多多指正

## 为什么要有虚拟继承 ##

我们看下面一种情景：

class A
    { 
    public:
    	int a;
    };
    
    class B : public A
    { 
    public:
    	int b;
    };
    
    class C : public A
    { 
    public :
    	int C;
    };
    
    class D : public B, public C
    { 
    public:
    	void func()
    	{ 
    		
    	}
    };

为了更加方便理解，用图表示:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpeGlhb2Rlc2h1c2h1_size_16_color_FFFFFF_t_70]  
如上图，那么就会出现问题：类D中的成员变量 int a，如果访问a，就会出现**二义性**问题，到底是B中的a，还是C中的A，并且会造成**数据冗余**问题。

其中，对于二义性问题，我们加访问限定即可。例如 C::a；但对于数据冗余问题却没有办法解决。

于是C++中就引入了虚拟继承

将代码改为：

class A
    { 
    public:
    	int a;
    };
    
    class B : virtual public A
    { 
    public:
    	int b;
    };
    
    class C : virtual public A
    { 
    public :
    	int C;
    };
    
    class D : public B, public C
    { 
    public:
    	void func()
    	{ 
    		
    	}
    };

如果，类中带有虚函数。内存结构会变为怎样？？

class A
    { 
    public:
    	A(int v = 100) :X(v) { };
    
    	virtual void foo(void) { }
    
    	int X;
    
    };
    
    class B :virtual public A
    { 
    public:
    	B(int v = 10) :Y(v), A(100) { };
    
    	virtual void fooB(void) { }
    
    	int Y;
    
    };
    
    class C : virtual public A
    { 
    public:
    	C(int v = 20) :Z(v), A(100) { }
    
    	virtual void fooC(void) { }
    
    	int Z;
    
    };
    
    class D : public B, public C
    { 
    	D(int v = 40) :B(10), C(20), A(100), L(v) { }
    
    	virtual void fooD(void) { }
    
    	int L;
    
    };

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpeGlhb2Rlc2h1c2h1_size_16_color_FFFFFF_t_70 1]  
对于类A，内存布局：  
![在这里插入图片描述][20190819205943586.png]  
对于类B，内存布局：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpeGlhb2Rlc2h1c2h1_size_16_color_FFFFFF_t_70 2]  
对于类D，内存布局：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpeGlhb2Rlc2h1c2h1_size_16_color_FFFFFF_t_70 3]

## 虚拟继承和普通继承的区别 ##

class A
    { 
    public:
    	virtual void funA();
    };  
    
    class B : public A
    { 
    public:
    	virtual void funB();
    }

class A
    { 
    public:
    	virtual void funA();
    };  
    
    class B : virtual public A
    { 
    public:
    	virtual void funB();
    }

上述两种继承有什么区别？？一种普通继承，一种虚拟继承

首先，我们知道，如果一个类中有虚函数，那么就会有一个虚表，有一个指针指向这个虚表。  
对于A，内存布局如下：  
![在这里插入图片描述][20190819210558292.png]  
对于**普通继承**，继承的虚函数和本有的虚函数共用同一个虚表  
则普通继承 B布局如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpeGlhb2Rlc2h1c2h1_size_16_color_FFFFFF_t_70 4]

但对于**虚拟继承**来说，不管是基类还是派生类都需要有一个指针来维护自己的虚表，并且还要有一个指针指向虚基表，其中存放偏移量  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpeGlhb2Rlc2h1c2h1_size_16_color_FFFFFF_t_70 5]

## 虚拟继承 sizeof() 问题 ##

有了上面的基础，来看几道题：

//第一种情况
    class a　　　　　　　　　
    { 　　　　　　　　　　　　
        virtual void func();
    };　　　　　　　　　　　
    class b:public virtual a
    { 　　　　　　　　　　　　
        virtual void foo();　
    };　　　　　　　　　　　
    
    //第二种情况
    class a　　　　　　　　　　　
    { 　　　　　　　　　　　　　　
    　　　　virtual void func();
     };　　　　　　　　　　　　　
    　class b :public a　　　　　
    { 　　　　　　　　　　　　　　
    　　　  virtual void foo();　
     };　　　　　　　　　　　　　　　　　　　　　　　　　
    
    //第三种情况
    class a　　　　　　　　　
    { 　　　　　　　　　　　　
    　　 virtual void func();
    　　 char x;　　　　　　　
    };　　　　　　　　　　　　
    class b:public virtual a　
    { 　　　　　　　　　　
    	virtual void foo();
    };　　　　　　　　　　　　
    
    //第四种情况
    　class a
    　{ 
    　　　virtual void func()
    　　  char x;
      };
     class b:public a
     { 
    　　　virtual void foo();
     };

对于每种情况，分别计算 sizeof(a), sizeof(b)的大小  
结果：  
**第一种：4，12  
第二种：4，4  
第三种：8，16  
第四种：8，8**

参照上述普通继承和虚拟继承的区别，就知道原因了。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpeGlhb2Rlc2h1c2h1_size_16_color_FFFFFF_t_70]: /images/20211026/7d2e97e987354ed28959c39629be1119.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpeGlhb2Rlc2h1c2h1_size_16_color_FFFFFF_t_70 1]: /images/20211026/ab1edd8b9a30451eb066ebe4bd6535d4.png
[20190819205943586.png]: /images/20211026/cab4e6f3971749188ec233c3c6c52059.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpeGlhb2Rlc2h1c2h1_size_16_color_FFFFFF_t_70 2]: /images/20211026/150dfef13f56404599f4ada8840918f3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpeGlhb2Rlc2h1c2h1_size_16_color_FFFFFF_t_70 3]: /images/20211026/03df27ff6e624923b29c62efd5713503.png
[20190819210558292.png]: /images/20211026/3eb78ae3affa4e04b261c74b120f0424.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpeGlhb2Rlc2h1c2h1_size_16_color_FFFFFF_t_70 4]: /images/20211026/e520be6ba488488886f5ac810bea60c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpeGlhb2Rlc2h1c2h1_size_16_color_FFFFFF_t_70 5]: /images/20211026/bba3abca206c41a6bb638424c70a2ed7.png