多态——细致讲解

🔶多态基础概念
🔶概念
🔱多态性
🔱多态——重新(覆盖)
🔶示例
🔶基本使用方法
🔶特例
🔱协变
🔱析构函数重写
🔱多态原理
🔱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;
}