C++:14---虛繼承，虛函數，多态

一、多級混合繼承

下面先介紹菱形繼承

//菱形繼承
class A
{
public:
int data;
};
class B:public A
{
public:
int data;
};
class C:public A
{
public:
int data;
};
class D:public B,public C
{
public:
int data;
};




int main()
{
D c;
D.data=1;
D.B::data=2;//通路B中的
D.C.::data=3;//通路C中的
D.B::A::data=4;//通路B繼承的A
D.C::A::data=5;//通路C繼承的A
D.A::data=4;//錯誤，産生二義性，不知道是B、C中哪一個
}      

類的記憶體大小​

1. sizeof(D); //20
2. sizeof(B); //8
3. sizeof(C); //8

• 記憶體圖解 

D先繼承于B再繼承于C，是以B的資料放在D記憶體段的最前方，C放在B的後面，D放在最後。

此種菱形繼承多存儲了兩倍的A的記憶體段，下面将介紹虛基類

二、虛基類(virtual)

1.概念：也稱虛繼承、菱形繼承。用于多級混合繼承時，保留一個虛基類

2.構造順序

• 先構造虛基類，如果有多個虛基類，按聲明（從左至右）依次構造
• 再構造基類，如果有多個基類，按聲明（從左至右）依次構造
• 如果有子對象，再構造子對像，如果有多個子對象，按聲明的順序（從上至下）依次構造
• 最後構造自己

class A //虛基類
{
public:
A(int data){}//1
int data;
};
class B:virtual public A
{
public:
B():A(1){}//2
int data;
};
class C:virtual public A
{
public:
C():A(2){}//3
int data;
};
class D:public B,public C
{
public:
D():A(3){}//4
int data;
};
int main()
{
D d;
d.data=1;
d.B::data=2;
d.C::data=3;
d.B::A.data=4;
d.C::A::data=5;
}      

• 構造順序為：1-2-3-4
• 構造順序解釋：構造類D對象d的時候，發現繼承于B，于是去構造B，構造B的時候，發現繼承于虛基類A，于是構造虛基類A，接着構造B。再接着構造C，發現C繼承于虛基類A，但發現虛基類A已經被B構造過了，是以不再構造A，直接構造C。最後構造D
• 如果虛基類構造函數為帶參構造，則其子類，以及子類拓展出來的子類，都要在成員初始化清單對其進行構造函數的初始化
• d的data指派為1，繼承于B、C，分别指派為2,3，順序為從左至右。A的值本來為4，後來執行到最後一行的時候被指派為5

3.類的記憶體大小

• 繼承于虛基類的類，記憶體位址大小加4位元組(此4位元組是屬于虛基類的，不是屬于自己的)

1. sizeof(B); //12
2. sizeof(C); //12
3. sizeof(D); //24

4.記憶體位址圖解

• 虛基類的記憶體位址在派生類記憶體位址的最後
• 虛基類在派生時，隻儲存一份記憶體在派生類記憶體中

 位址解析：

• B和C中都儲存了A的值，但是在D繼承B和C的時候，隻儲存了一份A，且放在最後
• 在D繼承的B和C記憶體段中分别有一個函數指針放在最前方

二、虛函數表

1.概念：是一塊連續的記憶體，所有虛函數的首位址都存放在虛函數表中，其大小為4位元組

2.注意

• 隻有類中有虛函數時，才有虛函數表
• 父子類之間的虛函數表是不同的位址，且虛函數表中的虛函數的首位址也不同

class A
{
public:
virtual void run1(){};
virtual void run2(){};
};
class A:public B
{
public:
virtual void run1(){};
virtual void run2(){};
};
int main()
{
cout<<sizeof(A); //4
cout<<sizeof(B); //4
}      

3.通過指針通路虛函數表中的函數


原理：通過指針周遊虛函數表然後列印虛函數，虛函數都是按照順序在記憶體中存儲的
class A
{
public:
virtual void run1(){cout<<"A1";};
virtual void run2(){cout<<"A2";};
};
typedef void(*pFun)();
int main()//列印一個
{
pFun pf = NULL;
A a;
pf = (pFun)*((int*)*(int *)&a);
pf();//列印run1()函數
}
int main()//列印兩個虛函數
{
pFun pf = NULL;
A a;
for (int i = 0; i < 2; ++i)
{
pf = (pFun)*((int*)*(int *)&a+i);
pf();
}
}      

5.錯誤代碼示範與更正

class A
{
int data;
public:
A() { data=1; }
void show() { cout << "A:" << data; }
};
class B:public A
{
int data;
public:
B() { data = 2; }
void show() { cout << "B:" << data; }
};
int main()
{
A a;
B pb；
pb = (B*)&a;//将A對象轉換為B類型
pb->show();//列印垃圾值
return 0;
}      

• 上面的代碼，列印的是B的show()，因為沒有函數virtual關鍵字，是以函數的調用看的是對象類型，此處的B的類型，是以調用的是B的show()。但是此種做法會列印垃圾值。
• 列印垃圾值原因：B類為8位元組，A類為4位元組。B中show()函數通路的是B類的後四節的data資料，現在pb指針指向的是4位元組的空間，後面4位元組不确定，是以為垃圾值。

• 上面的代碼如果show函數加上virtual關鍵字，則不會産生錯誤，看如下代碼

class A
{
int data;
public:
A() { data=1; }
virtual void show() { cout << "A:" << data; }
};
class B:public A
{
int data;
public:
B() { data = 2; }
void show() { cout << "B:" << data; }
};
int main()
{
A a;
B pb；
pb = (B*)&a;//将A對象轉換為B類型
pb->show();//列印1,調用A中的show();
return 0;
}      

• 原因：此處調用的是A中的show()，A中的show()通路的是前4位元組的資料，A的data存在于前4位元組，是以列印A中的data