【C++入门】C++多态

C++多态

一、虚函数和多态

1.虚函数

• 在类的定义中，前面有 virtual 关键字的成员函数就是虚函数。

  class base
  {
      virtual int get();
  };
  

• virtual 关键字只用在类定义里的函数声明中，写函数体时不用。

  int base::get()
  {
  }
  

2.多态的表现形式

• 表现形式一：

  • 派生类的指针可以赋给基类指针。
  • 通过基类指针调用基类和派生类中的同名虚函数时:
    • （1）若该指针指向一个基类的对象，那么被调用是基类的虚函数；
    • （2）若该指针指向一个派生类的对象，那么被调用的是派生类的虚函数。

  class CBase
  {
  public:
      virtual void SomeVirtualFunction() {}
  };
  class CDerived : public CBase
  {
  public:
      virtual void SomeVirtualFunction() {}
  };
  int main()
  {
      CDerived ODerived;
      CBase *p = &ODerived;
      p->SomeVirtualFunction(); //调用哪个虚函数取决于p指向哪种类型的对象
      return 0;
  }
  

• 表现形式二：

• 派生类的对象可以赋给基类引用。

  • （1）若该引用引用的是一个基类的对象，那么被调用是基类的虚函数；
  • （2）若该引用引用的是一个派生类的对象，那么被调用的是派生类的虚函数。

  class CBase
  {
  public:
      virtual void SomeVirtualFunction() {}
  };
  class CDerived : public CBase
  {
  public:
      virtual void SomeVirtualFunction() {}
  };
  int main()
  {
      CDerived ODerived;
      CBase &r = ODerived;
      r.SomeVirtualFunction(); //调用哪个虚函数取决于r引用哪种类型的对象
      return 0;
  }
  

3.多态的简单示例

class A
{
public:
    virtual void Print()
    {
        cout << "A::Print" << endl;
    }
};
class B : public A
{
public:
    virtual void Print() { cout << "B::Print" << endl; }
};
class D : public A
{
public:
    virtual void Print() { cout << "D::Print" << endl; }
};
class E : public B
{
    virtual void Print() { cout << "E::Print" << endl; }
};
int main()
{
    A a;
    B b;
    E e;
    D d;
    A *pa = &a;
    B *pb = &b;
    D *pd = &d;
    E *pe = &e;
    pa->Print(); // a.Print()被调用，输出：A::Print
    pa = pb;
    pa->Print(); //b.Print()被调用，输出：B::Print
    pa = pd;
    pa->Print(); //d. Print ()被调用,输出：D::Print
    pa = pe;
    pa->Print(); //e.Print () 被调用,输出：E::Print
    return 0;
}

4.多态的作用

在面向对象的程序设计中使用多态，能够增强程序的可扩充性，即程序需要修改或增加功能的时候，需要改动和增加的代码较少。

二、多态的调用及访问

1.多态的调用

• 用基类指针数组存放指向各种派生类对象的指针，然后遍历该数组，就能对各个派生类对象做各种操作，是很常用的做法。

• 在非构造函数，非析构函数的成员函数中调用虚函数，是多态：

  class Base
  {
  public:
      void fun1() { this->fun2(); } //this是基类指针，fun2是虚函数，所以是多态
      virtual void fun2() { cout << "Base::fun2()" << endl; }
  };
  class Derived : public Base
  {
  public:
      virtual void fun2() { cout << "Derived:fun2()" << endl; }
  };
  int main()
  {
      Derived d;
      Base *pBase = &d;
      pBase->fun1();
      return 0;
  }
  

  输出： Derived:fun2()

• 在构造函数和析构函数中调用虚函数，不是多态。编译时即可确定，调用的函数是自己的类或基类中定义的函数，不会等到运行时才决定调用自己的还是派生类的函数。

• 派生类中和基类中虚函数同名同参数表的函数，不加virtual也自动成为虚函数

2.虚函数的访问权限

class Base
{
private:
    virtual void fun2() { cout << "Base::fun2()" << endl; }
};
class Derived : public Base
{
public:
    virtual void fun2() { cout << "Derived:fun2()" << endl; }
};
Derived d;
Base *pBase = &d;
pBase->fun2(); // 编译出错

• 编译出错是因为 fun2() 是Base的私有成员。即使运行到此时实际上调用的应该是Derived的公有成员 fun2()也不行，因为语法检查是不考虑运行结果的。
• 如果 将Base中的 private换成public,即使Derived中的fun2() 是private的，编译依然能通过，也能正确调Derived::fun2()。

三、多态的实现原理

1.多态实现的关键：虚函数表

class Base
{
public:
    int i;
    virtual void Print() { cout << "Base:Print"; }
};
class Derived : public Base
{
public:
    int n;
    virtual void Print() { cout << "Drived:Print" << endl; }
};
int main()
{
    Derived d;
    cout << sizeof(Base) << "," << sizeof(Derived);
    return 0;
}

程序运行输出结果： 8, 12（多了4个字节）

• 每一个有虚函数的类（或有虚函数的类的派生类）都有一个虚函数表，该类的任何对象中都放着虚函数表的指针。虚函数表中列出了该类的虚函数地址。多出来的4个字节就是用来放虚函数表的地址的。
• 多态调用的代价：
  • 空间开销——虚函数表的存储
  • 时间开销——在虚函数表中查找
• 多态的函数调用语句被编译成一系列根据基类指针所指向的（或基类引用所引用的）对象中存放的虚函数表的地址，在虚函数表中查找虚函数地址，并调用虚函数的指令。

四、虚析构函数

1.虚析构函数作用

• 通过基类的指针删除派生类对象时，通常情况下只调用基类的析构函数
  • 但是，删除一个派生类的对象时，应该先调用派生类的析构函数，然后调用基类的析构函数。
• 解决办法：把基类的析构函数声明为virtual
  • 派生类的析构函数可以virtual不进行声明
  • 通过基类的指针删除派生类对象时，首先调用派生类的析构函数，然后调用基类的析构函数
• 一般来说，一个类如果定义了虚函数，则应该将析构函数也定义成虚函数。或者，一个类打算作为基类使用，也应该将析构函数定义成虚函数。
• 注意：不允许以虚函数作为构造函数

五、纯虚函数和抽象类

1.纯虚函数

纯虚函数： 没有函数体的虚函数

class A
{
private:
    int a;

public:
    virtual void Print() = 0; //纯虚函数
    void fun() { cout << "fun"; }
};

2.抽象类

• 包含纯虚函数的类叫抽象类

  • 抽象类只能作为基类来派生新类使用，不能创建独立的抽象类的对象
  • 抽象类的指针和引用可以指向由抽象类派生出来的类的对象

  A a ; // 错，A 是抽象类，不能创建对象
  A * pa ; // ok,可以定义抽象类的指针和引用
  pa = new A ; //错误, A 是抽象类，不能创建对象
  

• 在抽象类的成员函数内可以调用纯虚函数，但是在构造函数或析构函数内部不能调用纯虚函数。

• 如果一个类从抽象类派生而来，那么当且仅当它实现了基类中的所有纯虚函数，它才能成为非抽象类。

【知识索引】【C++入门】