三、多态

（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。
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 202,980评论 5赞 476
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,178评论 2赞 380
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 149,868评论 0赞 336
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,498评论 1赞 273
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,492评论 5赞 364
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,521评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,910评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,569评论 0赞 256
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,793评论 1赞 296
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,559评论 2赞 319
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,639评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,342评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,931评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,904评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,144评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,833评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,350评论 2赞 342