微信下单小程序怎么弄_建设公司怎么做网站运营_申请域名_百度网站优化培训

多态的概念

多态的概念：通俗来讲，就是多种形态
多态分类：
- 编译时多态（静态多态）：如函数重载，函数模板
- 运行是多态（动态多态）：完成某个行为（函数），可以传不同的对象完成不同的行为，所达到的结果是不一样的

编译时多态：指在编译时编译器会根据参数个数、参数类型、参数顺序和函数是否const来决定调用哪一个同名函数，或者根据模板参数来生成相应的模板类。如：c++输入输出会自动识别类型，实际上是调用了两个重载函数，匹配整数i，就用int的类型打印，匹配浮点数d，就调用double的类型去打印

int i=0;
double d=1.0;
cout<<i;
cout<<d;

运行时多态： 指的是在程序运行时根据对象的实际类型来确定调用哪个方法
如：成年人买票，买的是全价票，学生买票，买的是学生优惠票，军人买票，则可以优先买票。不同的人去买票，所呈现的形态是不一样的

多态的定义与实现

多态的构成条件

实现多态的两个必要条件：

• 必须指针或者引用调用虚函数
• 被调用的函数必须是虚函数

传基类的对象，调用基类的函数，调用派生类的对象，调用派生类的函数

#include<iostream>
using namespace std;
class Person
{
public:virtual void BuyTicket()//虚函数{cout << "买票-全价" << endl;}
};class Student :public Person
{
public:virtual void BuyTicket()//虚函数{cout << "买票-打折" << endl;}
};void func(Person*ptr)
{
//这里虽然都是Perosn指ptr在调用BuyTicket
//但是根ptr没关系，与ptr指向对象有关ptr->BuyTicket();//必须时指针或者引用调用虚函数
}/*void func(Person&ptr)
{ptr.BuyTicket();
}*/int main()
{Person p;Student s;func(&p);func(&s);/*func(p);func(s);*/return 0;
}

要实现多态效果，第⼀必须是基类的指针或引⽤，因为只有基类的指针或引⽤才能既能指向基类，也能派⽣类对象；第⼆派⽣类必须对基类的虚函数重写/覆盖，重写或者覆盖了，派⽣类才能有不同的函数，多态的不同形态效果才能达到。

虚函数

类成员前+virtual修饰，那么这个成员就是虚函数。（非成员函数不能加）

class Person
{
public:virtual void BuyTicket()//虚函数{cout << "买票-全价" << endl;}
};class Student :public Person
{
public://成员函数virtual void BuyTicket()//虚函数{cout << "买票-打折" << endl;}
};

基类虚函数的重写/覆盖

派生类中必须有一个与基类完全相同的虚函数（函数返回值类型，函数名，参数列表完全相同）。若派生类中的虚函数不写virtual也构成多态，因为基类的虚函数被继承下来后依然保持虚函数的属性，但不建议这么写。

只有虚函数才能完成重写

class Person
{
public:virtual void BuyTicket()//虚函数{cout << "买票-全价" << endl;}
};class Student :public Person
{
public://函数名相同，返回值相同，参数列表相同virtual void BuyTicket()//虚函数{cout << "买票-打折" << endl;}
};

• 下面是没写派生类virtual的情况。
• 基类不能不写virtual，如果基类没写，那么派生类继承下来的函数就不具备虚函数的属性，那么就不是对基类虚函数的重写
  

多态场景选择题

• 以下程序输出结果是什么（）
  A：A->0 、 B：B->1、C：A->1、D:B->0、E:编译出错、F:以上都不对

 class A{public:virtual void func(int val = 1){ std::cout<<"A->"<< val <<std::endl;}virtual void test(){ func();}};class B : public A{public:void func(int val = 0){ std::cout<<"B->"<< val <<std::endl; }};int main(int argc ,char* argv[]){B*p = new B;p->test();return 0;}

答案是：B
为什么：先看test()函数，test()函数的this指针调用func()函数，this指针是基类的类型。同时func函数又构成重写，所以此时构成多态的两个条件都已满足：

1. 调用的函数必须是虚函数
2. 必须是基类的指针或者引用调用虚函数。

看到主函数，是p调用的test()，p是B类型，那么调用的func()函数就是B的func()函数。但是因为构成重写，所以这里有些特殊，虚函数的重写可以理解为是将基类虚函数virtual void func(int val=1)部分拿下来与派生类重写函数的函数体部分进行结合，也就是virtual void func(int val=1){ std::cout<<"B->"<< val <<std::endl; }，所以输出的值为：“B->1”

虚函数重写存在的问题

协变了解即可
派⽣类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类类型的指针或者引 ⽤，派⽣类虚函数返回派⽣类类型的指针或者引⽤时，称为协变。协变的实际意义并不⼤，了解⼀下即可。

class A {};
class B :public A{};class Person {
public:virtual A* BuyTicket(){cout << "买票全价" << endl;return nullptr;}
};
class Student : public Person {
public:virtual B* BuyTicket(){cout << "买票打折" << endl;return nullptr;}
};
void Func(Person* ptr)
{ptr->BuyTicket();
}

析构函数的重写

基类的析构函数为虚函数，此时派⽣类析构函数只要定义，⽆论是否加virtual关键字，都与基类的析 构函数构成重写，虽然基类与派⽣类析构函数名字不同看起来不符合重写的规则，实际上编译器对析 构函数的名称做了特殊处理，编译后析构函数的名称统⼀处理成destructor，所以基类的析构函数加了 vialtual修饰，派⽣类的析构函数就构成重写

class A
{
public:virtual ~A(){cout << "~A()" << endl;}
};
class B : public A {
public:~B(){cout << "~B()->delete:" << _p << endl;delete _p;}
protected:int* _p = new int[10];
};
int main()
{A* p1 = new A;A* p2 = new B;delete p1;delete p2;return 0;
}

如果A的虚构函数前不加virtual，不构成重写，那么就会存在内存泄漏。p1是基类的指针，指向基类对象，p2是基类指针，指向派生类对象，若要完全析构p2就需要先析构指向的派生类对象，再析构本身，但若不构成重写，那么就无法析构派生类对象，直接析构本身。这样就会造成内存泄漏。

• override和final关键字
• override：帮助用户检测是否重写
• final：如果我们不想让派⽣类重写这个虚函数，那么可以⽤final去修饰。
  

重载/重写/隐藏的对比

重载：

1. 两个函数再用一个作用域
2. 函数相同，参数不同，参数的类型或者个数不同，返回值可同可不同

重写：

1. 两个函数分别在基类和派生类两个不同的作用域
2. 函数名，参数，返回值相同，协变例外
3. 两个函数必须是虚函数

隐藏：

1. 两个函数分别在基类和派生类两个不同的作用域
2. 函数名相同
3. 两个函数不构成重写就是隐藏
4. 基类派生类的成员变量名相同也构成隐藏

纯虚函数和抽象类

纯虚函数就是在虚函数后面写上=0。纯虚函数不需要定义实现(实现没啥意义因为要被 派⽣类重写，但是语法上可以实现)，只要声明即可。包含纯虚函数的类叫做抽象类，如果派⽣类继承后不重写纯虚函数，那么派⽣类也是抽象类。纯虚函数某种程度上强制了 派⽣类重写虚函数，因为不重写实例化不出对象。

• 派生类重写纯虚函数
  
• 派生类不重写纯虚函数

多态原理

虚函数表指针

• 下面编译为32为程序的运行结果是什么：
  A：编译报错、B：运行报错、C：8、D：12

class Base{public:virtual void Func1(){cout << "Func1()" << endl;}protected:int _b = 1;char _ch = 'x';};int main(){Base b;cout << sizeof(b) << endl;return 0;}

• 答案是“D”
• 在Base类中，除去两个成员变量，还存在一个虚函数表指针（_vfptr）占4字节，内存对齐后，得出答案"D"
  
• 虚函数表是什么？
  ⼀个含有虚函数的类中都⾄少都有⼀个虚函数表指针，因为⼀个类所有虚函数的地址要被放到这个类对象的虚函数表中，虚函数表也简称虚表。虚函数表就是一个指针数组，里面存放着虚函数的指针
  Base类中的虚函数的地址都存放在虚函数表中
  
• 将代码调整成下面这样

class Base{public:virtual void Func1(){cout << "Func1()" << endl;}virtual void FuncB(){cout << "FuncB()" << endl;}virtual void FuncB2(){cout << "FuncB2()" << endl;}protected:int _b = 1;char _ch = 'x';};class A:public Base{public:virtual void Func1(){cout << "Func1()" << endl;}protected:int a;};

A继承了Base类，同时它的虚函数也被继承下来，但由于对虚函数Func1进行了重写，所以虚表中原本的Func1函数被覆盖。前面所说的重写说从语法层面讲的，这里的覆盖是从原理层来讲的。重写也叫覆盖，只是所阐述的角度不同罢了。

多态如何实现的

运⾏时到指向的对象的虚表中确定对应的虚函数的 地址，这样就实现了指针或引⽤指向基类就调⽤基类的虚函数，指向派⽣类就调⽤派⽣类对应的虚函数

动态绑定与静态绑定

不满足多态条件的函数调用，是在编译时确定调用的函数的地址的叫静态绑定

满足多态条件的函数调用，是在运行时确定调用的函数的地址，叫做动态调用

虚函数表

一. 基类对象的虚函数表中存放基类所有虚函数的地址。

二. 派生类：

① 继承下来的基类

1. 若继承下来的基类有虚函数表了，自己不会再生成

2. 继承下来的基类部分虚函数表指针和基类对象的虚函数表指针不是同⼀个，就像基类对象的成员和派⽣类对象中的基类对象成员也独⽴ 的

② 自己的虚函数成员

③派⽣类中重写了基类的虚函数，派⽣类的虚函数表中对应的虚函数就会被覆盖成派⽣类重写的虚函 数地址

总结：派⽣类的虚函数表包含

1. 基类的虚函数地址2. 派⽣类重写的虚函数地址3. 派⽣类⾃⼰的虚函数地址三个部分

• 虚函数存在哪的？虚函数和普通函数⼀样的，编译好后是⼀段指令，都是存在代码段的，只是虚函 数的地址⼜存到了虚表中。

• 虚函数表本质是⼀个存虚函数指针的指针数组，⼀般情况这个数组最后⾯放了⼀个0x0000标 记。(这个C++并没有进⾏规定，各个编译器⾃⾏定义的，vs系列编译器会再后⾯放个0x0000 标记，g++系列编译不会放）

• 虚表存储在哪？虚表存储在每个类的对象实例中。

虚表对于每个类只有一个实例，并且所有该类的对象共享同一个虚表。这是因为虚表包含的是对于特定类的虚函数的地址，而不是具体对象的成员函数。