多态——细致讲解

 1. 静态多态：函数重载和运算符重载
 2. 动态多态：继承和虚函数

 1. 父类的指针/引用调用虚函数
 2. 调用的虚函数必须是子类重写的虚函数
这样就能在指针调用相应的对象函数的时候使用相应的成员函数，具体看示例
这里条件很严格
重写的函数要是一摸一样——返回值，函数名，参数个数，参数位置，参数类型都要完全一样，虚函数之后的const也要一样

1. 父类中需要使用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;
}

2. final 修饰类——不能继承

修饰虚函数——不能背重写

3. 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;}

#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;
}

#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不是

#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;
}

#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;
}

1. 父类指向子类，调用的test函数，test函数是父类的虚函数，类内的函数有一个默认的this指针，test内部调用的fun函数实际上是this->fun(this类型是A*——父类的指针指向虚函数)，fun是子类重写的虚函数(函数是子类重写的虚函数)——满足多态条件
2. 虚函数中的this是根据是否重写确定的，这里的test没有被重写，是A*this指针，然后调用fun，fun是经过重写的函数，所以调用的是重写的函数
3. 虚函数继承的是函数的接口，重写的是函数的实现

所以缺省值才是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;
}

1. 什么是多态？
2. 什么是重载、重写(覆盖)、重定义(隐藏)？
3. 多态的实现原理？
4. inline函数可以是虚函数吗？

可以，不构成多态就是inline，构成多态就不是inline

5. 静态成员可以是虚函数吗？

不能，因为静态成员函数没有this指针，使用类型::成员函数
的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

6. 构造函数可以是虚函数吗？

不能，虚表在编译时生成
在调用构造函数之后，但是虚表指针在成员初始化之前

7. 析构函数可以是虚函数吗？

本就应该是，在A* a = new B;这种场景下，在释放子类对象时，需要将析构函数变成虚函数

8. 对象访问普通函数快还是虚函数更快？

首先如果是普通对象，是一样快的。如果构成多态，就是普通函数快，因为运行时调用虚函数需要到虚函数表中去查找。

9. 虚函数表是在什么阶段生成的，存在哪的？

虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。

10. C++菱形继承的问题？虚继承的原理？

菱形继承会造成祖宗类数据冗余的问题
在每一个继承自祖宗类的派生类中，使用一个指针，指向一个偏移量，根据偏移量找到的地址就是祖宗类的数据，并且这个数据只有一份

11. 什么是抽象类？抽象类的作用？

抽象类含有形如 virtual void fun() =0; 的基类/派生类
强制派生类重写父类的实现

从原理的角度理解，重写之后将fun虚函数进行覆盖，test是A*this调用经过重写的虚函数fun，符合多态的条件，并且继承的是接口不是实现，fun虚函数继承父类函数接口，并使用重写的虚函数实现，最终形成了这个样子

优秀多态文章
优秀多态文章
为什么要使用父类指针和引用实现多态，而不能使用对象？
虚析构函数
虚表位置
虚表位置