多態——細致講解

🔶多態基礎概念
?🔶概念
??🔱多態性
??🔱多態——重新(覆蓋)
?🔶示例
??🔶基本使用方法
??🔶特例
???🔱協變
???🔱析構函數重寫
?🔱多態原理
??🔱1. 虛函數形成虛表
??🔱2. 虛函數存儲位置(覆蓋)
??🔱3. 多態中重寫的虛函數存儲位置
???🔱1. 重寫原理——虛表
???🔱2. 單繼承中，子類新增虛函數會存到父類的虛表中——普通繼承
???🔱3. 單繼承中，子類新增虛函數會存到父類的虛表中——虛繼承
???🔱4. 同類公用一個虛表；父類和子類不共用一張虛表
?🔱多態例題
🔱經典問題

父類中需要使用virtual修飾函數，子類中virtual可以不寫

class A
{
public:virtual void func(){puts("A-->func");}
};
class B:public A
{
public:virtual void func(){puts("B-->func");}
};
int main()
{// 父類指向子類A* a1 = new B;a1->func();// 父類指向父類a1 = new A;a1->func();// 父類引用子類B tb;A& a2 = tb;a2.func();// 父類引用父類A ta;A& a3 = ta; // 不能直接使用a2=ta，引用不能重新賦值，雖然他不會報錯，但是他的結果是錯的a3.func();return 0;
}

final 修飾類——不能繼承

修飾虛函數——不能背重寫

override ——這個函數一定要重新父類的某一個虛函數

一定要注意這兩個關鍵字加載虛函數結尾

特例

協變

虛函數的返回值可以不一樣，只能出現父類返回父類的指針/引用，子類返回子類的指針/引用

不可以一個返回指針，一個返回引用
只能同時返回指針/同時返回引用

析構函數重寫

#include<iostream>
using namespace std;
typedef void (*T)();
class A
{
public:virtual void fun1(){cout << "A::fun1" << endl;}virtual void fun2(){cout << "A::fun2" << endl;}~A(){cout << "delete A" << endl;}int _a = 1;};
class B :public A
{
public:virtual void fun1(){cout << "B::fun1" << endl;}virtual void fun3(){cout << "B::fun3" << endl;}~B(){cout << "delete B" << endl;}int _b = 2;
};
int main()
{A* a = new B;delete a;return 0;
}

delete釋放看的是類型，也就是說這里delete調用的是A的析構函數
根本上說，delete會被處理成—> destructor() + operator delete,所以他們能構成重寫，在具體實現的時候需要寫成virtual

	virtual ~A(){cout << "delete A" << endl;}

?多態原理

?1. 虛函數形成虛表

#include<iostream>
using namespace std;
typedef void (*T)();
class A
{
public:virtual void fun1(){cout << "A::fun1" << endl;}virtual void fun2(){cout << "A::fun2" << endl;}};
int main()
{A a;return 0;
}

#include<iostream>
using namespace std;
typedef void (*T)();
class A
{
public:virtual void fun1(){cout << "A::fun1" << endl;}virtual void fun2(){cout << "A::fun2" << endl;}};
class B :public A
{
public:virtual void fun1(){cout << "B::fun1" << endl;}
};
int main()
{B b;return 0;
}

🎭2. 單繼承中，子類新增虛函數會存到父類的虛表中——普通繼承

#include<iostream>
using namespace std;
typedef void (*T)();
class A
{
public:virtual void fun1(){cout << "A::fun1" << endl;}virtual void fun2(){cout << "A::fun2" << endl;}};
class B :public A
{
public:virtual void fun1(){cout << "B::fun1" << endl;}virtual void fun3(){cout << "B::fun3" << endl;}
};
int main()
{B b;print((T*)(*(int*)(&b)));return 0;
}

vs中虛表通常在最后一個都是0，Linux不是

🎭3. 單繼承中，子類新增虛函數會存到父類的虛表中——虛繼承

#include<iostream>
using namespace std;
typedef void (*T)();
class A
{
public:virtual void fun1(){cout << "A::fun1" << endl;}virtual void fun2(){cout << "A::fun2" << endl;}int _a = 1;};
class B :virtual public A
{
public:virtual void fun1(){cout << "B::fun1" << endl;}virtual void fun3(){cout << "B::fun3" << endl;}int _b = 2;
};
int main()
{B b;A* a = &b; // 要注意這種寫法，確保他能準確跳到下一個虛表處print((T*)(*(int*)(a)));print((T*)(*(int*)(&b)));return 0;
}

🎭4. 同類公用一個虛表；父類和子類不共用一張虛表

#include<iostream>
using namespace std;
typedef void (*T)();
class A
{
public:virtual void fun1(){cout << "A::fun1" << endl;}virtual void fun2(){cout << "A::fun2" << endl;}int _a = 1;};
class B :virtual public A
{
public:virtual void fun1(){cout << "B::fun1" << endl;}int _b = 2;
};
int main()
{A a;B b1;B b2;return 0;
}

🖼多態例題

class A
{
public:virtual void fun(int val = 1){cout << "val = " << val << endl;}virtual void test(){fun();}
};
class B :public A
{
public:virtual void fun(int val = 0){cout << "val = " << val << endl;}
};
int main()
{A* a = new B;a->test();return 0;
}
void print(T a[])
{for (int i = 0; a[i] != 0; i++){printf("[%d]--->%p\n", i, a[i]);}puts("");
}
int main()
{B b;print((T*)(*(int*)(&b)));return 0;
}

父類指向子類，調用的test函數，test函數是父類的虛函數，類內的函數有一個默認的this指針，test內部調用的fun函數實際上是this->fun(this類型是A*——父類的指針指向虛函數)，fun是子類重寫的虛函數(函數是子類重寫的虛函數)——滿足多態條件
虛函數中的this是根據是否重寫確定的，這里的test沒有被重寫，是A*this指針，然后調用fun，fun是經過重寫的函數，所以調用的是重寫的函數
虛函數繼承的是函數的接口，重寫的是函數的實現

所以缺省值才是1

#include<iostream>
using namespace std;class A
{
public:virtual void fun(int val = 0){printf("A::fun()--> %d", val);}virtual void test(){fun();}
};
class B:public A
{
public:void fun(int val = 1){printf("B::fun()--> %d", val);}
};
int main()
{B b;b.test();return 0;
}