多态

---

多态的概念

通俗来说，就是多种形态。多态分为编译时多态(静态多态)和运行时多态(动态多态)这里重点讲运行时多态。

运行时多态

运行时多态，具体点就是去完成某个行为(函数)，可以传不同的对象就会完成不同的行为，就达到多种形态。

多态的定义以及实现

多态的构成条件

多态是一个继承关系的下的类对象，去调用同一函数，产生了不同的行为。

• 实现多态的两个必须的重要条件

  • 必须指针或者引用调用虚函数。

  • 被调用的函数必须是虚函数。

  • 总结：要实现多态效果，第一必须是基类的指针或引用，因为只有基类的指针或引用才能既指向派生类对象；第二派生类必须对基类的虚函数重写/覆盖，重写或者覆盖了，派生类才能有不同的函数，多态的不同形态效果才能达到。

• 虚函数

  类成员函数前面加 virtual 修饰，那么这个成员函数被称为虚函数。注意非成员函数不能加 virtual 修饰。

    class Person
    {
    public:
        virtual void print()
        {
            cout << "Hello world" << endl;
        }
    };
  

• 虚函数的覆盖和重写

  派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称派生类的虚函数重写了基类的虚函数。

  • 注意：在重写基类虚函数时，派生类的虚函数在不加 virtual 关键字时，虽然也可以构成重写，但是该种写法不是很规范，不建议这样使用。

  • 代码示例:

  
    #include <iostream>
    using namespace std;
  
    // 多态
    class Person
    {
    public:
        virtual void print() // 2.必须使用虚函数,并且虚函数完成了重写或者覆盖。这里的virtual不可以去掉
        {
            cout << "Person" << endl;
        }
    };
  
    class Student : public Person
    {
    public:
        // 派生类的虚函数可以不加virtual
        virtual void print() // 2.使用虚函数,并且虚函数完成了重写或者覆盖。这里的virtual可以去掉
        {
            cout << "Student" << endl;
        }
    };
  
    void Func(Person *ptr) // 1.必须是基类的指针或者引用
    {
        ptr->print();
    }
  
    int main()
    {
        Person s1;
        Student s2;
        Func(&s1);
        Func(&s2);
    }
  

• 关于多态的选择题

  以下程序输出结果为：
  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
    
    
    这里发生了重写，就相当于将基类的 virtual void func(int val = 1) 替换到了派生类的 void func(int val = 0)。

• 虚构函数的其他问题

  • 协变

    派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

    #include <iostream>
    using namespace std;
    
    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();
    }
    int main()
    {
        Person ps;
        Student st;
        Func(&ps);
        Func(&st);
        return 0;
    }
    

  • 析构函数的重写

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

• 重载/重写/隐藏的对比
  

纯虚函数和抽象类

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

---