三、多态

（1）多态

<1>定义

多态：不同类型对象调用相同接口完成不同的行为。

根据对象的实际类型不同，可以自动完成不同的行为，而仅仅通过一致的调用形式。

<2>多态的形成条件（重点）

• 1 继承
• 2 子类覆盖（重写）父类的虚函数：有函数同名和参数完全相同的函数，并且父类函数前有关键字virtual
• 3 父类指针或引用指向子类

<3>虚函数

• 用virtual 修饰成员函数，使其成为虚函数。
• 父类必须加virtual，子类可加可不加。
• 动态多态又叫覆盖（重写override）

<4>面向对象特征之间的关系

没有封装就不能继承，没有继承就没有运行时的多态。

（2）绑定

<1>定义

绑定：将函数体和函数调用关联起来。

<2>分类

• 早绑定（又叫静态多态）：
  （1）定义：在程序运行之前，也就是在编译和链接时。（函数和运算符重载）
  （2）优点：编译效率、代码提示(代码智能感知)、编译时类型检查
• 晚绑定（动态多态）：
  （1）定义：晚绑定发生在运行时，基于不同类型的对象。必须有某种机制确定对象的具体类型然后调用合适的成员函数。（继承与虚函数）
  （2）优点：不用申明类型、对象类型可以随时更改
• 多态分为静态多态和动态多态。

<3>代码

class Animal{
public:
多态原则：函数名和参数、返回值必须一样，在函数前面加上virtual才有效。
    virtual string GetName() {return "动物";}
};
class Cat:public Animal{
public:
    string GetName() {return "猫";}
};
class Dog:public Animal{
public:
    string GetName() {return "狗";}
};
2.在不加virtual时，由于赋值兼容不能访问到子类对象里面的同名函数
void Func(Animal& a) {cout << a.GetName() << endl;} 
void Func(Animal* a) {cout << a->GetName() << endl;}
int main(){
    Cat c1,Cat c2；
    Dog d1,Dog d2;
1.这种调用形式会由于同名隐藏，不会调用父类的同名的成员函数
    cout << c1.GetName() << endl;cout << c2.GetName() << endl;
    cout << d1.GetName() << endl;cout << d2.GetName() << endl;
2.在加上virtual时，会产生函数重写,调用实际对象的成员函数。
***********************形式一：函数***********************************
     Func(c1);Func(c2);Func(&d1);Func(&d2);
**********************形式二：父类的指针数组***********************
没有数组的引用：Animal& arr[]={c1,c2,d1,d2};（错误的，无该用法）  
值传不能形成多态：Animal arr[]={c1,c2,d1,d2};赋值兼容的第一种情况,调用拷贝构造
    Animal* arr[]={&c1,&c2,&d1,&d2};
    for(int i=0;i<4;++i){
        cout << arr[i]->GetName()<<endl;
    }
**********************形式三：父类的指针vector**********************
没有vector的引用：vector<Animal&> vec={c1,c2,d1,d2};
      vector<Animal*> vec={&c1,&c2,&d1,&d2};

这就是引用代替不了指针的一个体现：多态。

（3）虚函数详解

<1>虚函数定义规则

• 1.如果虚函数在基类与派生类中出现，仅仅是名字相同，而形式参数不同，或者是返回类型不同，有无const.那么即使加上了virtual关键字，也是不会覆盖。
• 2.只有类的成员函数才能说明为虚函数，因为虚函数仅适合用与有继承关系的类对象，所以普通函数不能说明为虚函数。
• 3.静态成员函数不能是虚函数,因为静态成员函数的特点是不受限制于某个对象。
• 4.内联(inline)函数不能是虚函数，因为内联函数不能在运行中动态确定位置。即使虚函数在类的内部定义，但是在编译的时候系统仍然将它看做是非内联的。
• 5.构造函数不能是虚函数，因为构造的时候，对象还是一片未定型的空间，只有构造完成后，对象才是具体类的实例。
• 6.析构函数可以是虚函数,而且通常将父类的析构函数声明为虚函数。

注意：子类以new方式实例化，指针赋值给父类指针，delete父类指针时，只调用父类的析构函数，不调用子类的析构函数。（如果子类中在堆上申请了动态内存，不调用子类的析构函数会导致内存泄漏）要想解决这种方法需要定义父类的虚构函数为虚析构函数。

class Father{
public:
    virtual void Func()const{cout << "Father::Func()" << endl;}
    Father(){cout << __func__ <<endl;}
    virtual ~Father(){cout << __func__ <<endl;}//父类的析构函数声明为虚函数
};
class Son:public Father{
public:
    void Func()const{cout << "Son::Func()" << endl;}
    Son(){cout << __func__<< endl;}
    ~Son(){cout << __func__ << endl;}
};
int main(){
    Son s;
    Father* pf=&s;
    pf->Func();//多态/覆盖/重写 
执行：Father---->Son---->Son::Func()---->~Son---->~Father
    Father* pp=new Son;
    pp->Func();
    delete pp;
执行：在父类析构函数前不加virtual，就不会析构子类对象。
Father--->Son---->Son::Func()----->~Father
}

<2>多态的实现原理分析

• 当类中声明虚函数时,编译器会在类中生成一个虚函数表(基类和派生类中各自都会生成一个)，并且虚函数会被编译器放到虚函数表中。在执行时，当编译器检测到虚函数时，并不会直接编译父类的虚函数，而是在运行的时候会动态的根据Base指向的对象，找到vptr指针，然后找到虚函数表，最后调用虚函数表里的函数。
• 虚函数表
  虚函数表是一个存储类成员函数指针的数据结构
  虚函数表是由编译器自动生成和维护的
  virtual函数会被编译器放入虚函数表中
  存在虚函数时,每个对象当中都有一个指向虚函数表的指针（通常称之为 vptr 指针），
  sizeof对象会增大一个指针的大小。

（4）纯虚函数

<1>定义

纯虚函数是在基类中声明的虚函数，它在基类中没有实现，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加=0。

<2>格式

class 类名{
    virtual 返回值类型 函数(形参列表) = 0;
}

<3>适用情况

定义一个基类时，会遇到无法定义基类中虚函数的具体实现，其实现依赖于不同的派生类。

<4>注意：

（1）定义纯虚函数时，不能定义纯虚函数的实现部分。即使是函数体为空也不可以.
函数体为空就可以执行，只是什么也不做就返回。而纯虚函数不能调用。
（2）在派生类中必须有重新定义的纯虚函数的函数体，这样的派生类才能用来定义对象。（如果不重写进行覆盖，程序会报错）
（3）父类有的纯虚函数，子类必须继承，并且子类必须重写，否则会报错。

<5>抽象类

• 包含纯虚函数的类称为抽象类。由于抽象类包含了没有定义的纯虚函数，所以抽象类不能定义对象。
• 继承抽象类仍然可能是抽象类。比如子类继承了父类（抽象类），但是没有重写父类的纯虚函数，因此该子类也叫抽象类。

<6>实例

class Shape{
public://要写成公有的 
    virtual float GetLength()=0;
    //virtual float GetArea()=0;//后面子类中不重写该纯虚函数的话也叫抽象类。
    virtual ~Shape(){cout << __func__ <<endl;}//必须定成虚的析构函数，否则不会析构子类对象
};
class Triangle:public Shape{
    float a,b,c;
public:
    Triangle(float a,float b,float c):a(a),b(b),c(c){cout << __func__ <<endl;}
    float GetLength(){return a+b+c;}
    ~Triangle(){cout << __func__ <<endl;}
};
class Circle:public Shape{
    float r;
public:
    Circle(float r):r(r){cout << __func__ <<endl;}
    float GetLength(){return 2*M_PI*r;}
    ~Circle(){cout << __func__ <<endl;}
};
class Rect:public Shape{
    float length,width;
public:
    Rect(float length,float width):length(length),width(width){cout << __func__ <<endl;}
    float GetLength(){return (length+width)*2;}
    ~Rect(){cout << __func__ <<endl;}
};
int main(){
    Shape* arr[]={
        new Triangle(3,4,5),
        new Circle(3),
        new Rect(4,6)};
    float sumlength=0;
    for(int i=0;i<3;++i){
        float length_tmp =arr[i]->GetLength();
        cout << length_tmp << endl;
        sumlength +=length_tmp;
    }
    cout << sumlength <<endl;
    for(int i=0;i<3;++i){
        delete arr[i];
    }
}
执行：Triangle---Circle---Rect---12---18.8496---20---50.8496
 ~Triangle--->~Shape--->~Circle--->~Shape--->~Rect--->~Shape

（5）连续继承

class A{
public:
    void Func(){ cout << "A::Func" << endl;}
};
class B:public A{
public:
    // 虚函数从继承关系中，第一个定义虚函数的类的继承类开始覆盖。
    virtual void Func(){ cout << "B:Func" << endl;}
};
class C:public B{
public:
    // C的基类B已经覆盖了A的虚函数，那么C继承的虚函数是覆盖过的。
    void Func(){ cout << "C:Func" << endl;}
};
int main(){
   A* a = new C;
   a->Func();//A::Func
   B* b=new C;
   b->Func();//C::Func
}

（6）重载、同名隐藏、多态实例

<1>重载覆盖的区别

重载	覆盖
重载要求函数名相同，但是参数列表必须不同，返回值可以相同也可以不同。	覆盖要求函数名、参数列表、返回值必须相同。（有一个特例返回值可以不同）
在类中重载是同一个类中不同成员函数之间的关系。	在类中覆盖则是子类和基类之间不同成员函数之间的关系。
重载函数的调用是根据参数列表决定。	覆盖函数的调用是根据对象类型决定。
重载函数是在编译时确定调用一个函数。（早绑定）	覆盖函数是在执行时确定调用个函数。（晚绑定）

<2>函数重载关于返回值

重载：返回值不同不能作为函数重载的依据

重载：返回值不同不能作为函数重载的依据
        char Func(){}
        int Func(){}
int main(){
         a=Func();//报错，函数出现冲突
}

<3>覆盖的实例（与解引用无关）

class Base{
public:
  virtual void Func()const{ cout << "Base" << endl; }
};
class Derive : public Base {
public:
  void Func() const { cout << "Derive" << endl; }
};
int main() {
  Base* pB = new Derive;
  pB->Func();
  (*pB).Func();//只是访问方式不一样，是上面的简写。
}

<4>覆盖的特例

返回值可以不同，也可以形成多态。只要是返回的是对象指针，并且父类和子类的返回类型构成继承关系。

如果覆盖函数返回值类型是有继承关系的类的指针/引用类型，虽然返回值类型不同，但仍然是覆盖。
class Base{};
class Derive:public Base{};
class A{
public:
    virtual Base* Func()const{//返回类型为A
        cout << "A:Func" << endl;
        return NULL;
    }
};
class B:public A{
public:
    Derive* Func() const{//返回类型为B时，也能形成多态。
        cout << "B:Func" << endl;
        return NULL;
    }
};
int main(){
    B b;
    A* p=&b;
    p->Func();
}

<5>实例

class A{
public:
    virtual void Func(){cout << "A:func()" << endl;}
    void Func(int i){cout << "A:Func(" << i << ")" <<endl;}
};
class B:public A{
public:
    //using A::Func;//解决同名隐藏方法二
    void Func() {cout << "B:Func()" << endl;}
};
int main(){
    B b;
    b.Func();//同名隐藏
    b.A::Func(1);//解决同名隐藏方法一
    
    A a(b);
    a.Func();
    a.Func(2);//重载Func
    
    A c;
    c=b;
    c.Func();
    c.Func(3);//重载
    
    A* pa=&b;
    pa->Func();//覆盖/多态/重写
    pa->Func(4);//重载
    
    A& fa=b;
    fa.Func();//多态
    fa.Func(5);//重载
}

（7）双重转发

• case 1:
  由于友元函数不是成员函数，构成不了覆盖，父类指针还是会调用父类的函数。

class Base{
public:
  friend ostream& operator<<(ostream& os,const Base& b){ return os << "Base"; }
};

class Derive : public Base {
public:
  friend ostream &operator<<(ostream &os, const Derive &b) { return os << "Derive"; }
};

int main() {
  Base* pB = new Derive;
  cout << (*pB) << endl;
}
结果：Base

• case 2:双重转发
  要想上面的两个函数形成多态，则需要用到双重转发。改写为：

class Base{
public:
virtual ostream& Output(ostream& os)const{//因为下面的对象是const
         os << "Base" << endl;
         return os;
  }
  friend ostream& operator<<(ostream& os,const Base& b){ 
         return b.Output(os);
 }
};
class Derive : public Base {
public:
virtual ostream& Output(ostream& os)const{//virtual可写可不写
         os << "Derive" << endl;
         return os;
  }
friend ostream &operator<<(ostream &os, const Derive &b) { 
      return b.Output(os); 
}
};
int main() {
  Base* pB = new Derive;
  cout << (*pB) << endl;
}
执行：Derive
调用的原理：父类对象pB，解引用还是属于父类，因此会调用父类的输出运算符，
b=*pB,当b调用函数Output时，在父类中该函数前有virtual关键字，然后
子类也重写了Output函数，并且pB指向子类对象，则b也就指向子类对象，构成了多态的三个条件，因此则会调用子类的函数Output。