当前位置：首页 > article >正文

C++多态讲解

article 2024/11/14 15:07:29

在这里插入图片描述

多态

多态的概念

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

运行时多态

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

多态的定义以及实现

多态的构成条件

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

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

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

在这里插入图片描述