C++ 多态和虚函数

电玩女神 2023-03-13 01:55 30阅读 0赞

虚函数实现多态

#include <iostream>
    using namespace std;
    
    //基类People
    class People{
    public:
        virtual void display();  //声明为虚函数
    };
    void People::display(){
        cout<<"无业游民。"<<endl;
    }
    
    //派生类Teacher
    class Teacher: public People{
    public:
        virtual void display();  //声明为虚函数
    };
    void Teacher::display(){
        cout<<"是一名教师"<<endl;
    }
    
    int main(){
        People *p = new People();
        p -> display();
    
        p = new Teacher();
        p -> display();
    
        return 0;
    }

结果：

无业游民。  
是一名教师

有了虚函数，基类指针指向基类对象时就使用基类的成员（包括成员函数和成员变量），指向派生类对象时就使用派生类的成员。换句话说，基类指针可以按照基类的方式来做事，也可以按照派生类的方式来做事，它有多种形态，或者说有多种表现方式，我们将这种现象称为**多态（Polymorphism）**。

上面的代码中，同样是`p->display();`这条语句，当 p 指向不同的对象时，它执行的操作是不一样的。同一条语句可以执行不同的操作，看起来有不同表现方式，这就是多态。  
  
多态是面向对象编程的主要特征之一，C++中虚函数的唯一用处就是构成多态。

int main(){
        People p();
        Teacher t();
       
        People &rp = p;
        People &rt = t;
       
        rp.display();
        rt.display();
    
        return 0;
    }

引用同样可以多态

# 注意事项 #

1) 只需要在虚函数的声明处加上 virtual 关键字，函数定义处可以加也可以不加。  
  
2) 为了方便，你可以只将基类中的函数声明为虚函数，这样所有派生类中具有遮蔽关系的同名函数都将自动成为虚函数。  
  
3) 当在基类中定义了虚函数时，如果派生类没有定义新的函数来遮蔽此函数，那么将使用基类的虚函数。  
  
4) 只有派生类的虚函数覆盖基类的虚函数（函数原型相同）才能构成多态（通过基类指针访问派生类函数）。例如基类虚函数的原型为`virtual void func();`，派生类虚函数的原型为`virtual void func(int);`，那么当基类指针 p 指向派生类对象时，语句`p -> func(100);`将会出错，而语句`p -> func();`将调用基类的函数。  
  
5) 构造函数不能是虚函数。对于基类的构造函数，它仅仅是在派生类构造函数中被调用，这种机制不同于继承。也就是说，派生类不继承基类的构造函数，将构造函数声明为虚函数没有什么意义。  
  
6) 析构函数可以声明为虚函数，而且有时候必须要声明为虚函数，这点我们将在下节中讲解。

# 纯虚函数 #

在[C++][C]中，可以将虚函数声明为纯虚函数，语法格式为：

virtual 返回值类型 函数名 (函数参数) = 0;

纯虚函数没有函数体，只有函数声明，在虚函数声明的结尾加上`=0`，表明此函数为纯虚函数。

> 最后的 `=0`并不表示函数返回值为0，它只起形式上的作用，告诉编译系统“这是纯虚函数”。

包含纯虚函数的类称为抽象类（Abstract Class）。之所以说它抽象，是因为它无法实例化，也就是无法创建对象。原因很明显，纯虚函数没有函数体，不是完整的函数，无法调用，也无法为其分配内存空间。  
  
抽象类通常是作为基类，让派生类去实现纯虚函数。派生类必须实现纯虚函数才能被实例化。

Line 是一个抽象类，也是最顶层的基类，在 Line 类中定义了两个纯虚函数 area() 和 volume()。

//线
    class Line{
    public:
        Line(float len);
        virtual float area() = 0;
        virtual float volume() = 0;
    protected:
        float m_len;
    };
    Line::Line(float len): m_len(len){ }

在 Rec 类中，实现了 area() 函数；所谓实现，就是定义了纯虚函数的函数体。但这时 Rec 仍不能被实例化，因为它没有实现继承来的 volume() 函数，volume() 仍然是纯虚函数，所以 Rec 也仍然是抽象类。

//矩形
    class Rec: public Line{
    public:
        Rec(float len, float width);
        float area();
    protected:
        float m_width;
    };
    Rec::Rec(float len, float width): Line(len), m_width(width){ }
    float Rec::area(){ return m_len * m_width; }

直到 Cuboid 类，才实现了 volume() 函数，才是一个完整的类，才可以被实例化。

//长方体
    class Cuboid: public Rec{
    public:
        Cuboid(float len, float width, float height);
        float area();
        float volume();
    protected:
        float m_height;
    };
    Cuboid::Cuboid(float len, float width, float height): Rec(len, width), m_height(height){ }
    float Cuboid::area(){ return 2 * ( m_len*m_width + m_len*m_height + m_width*m_height); }
    float Cuboid::volume(){ return m_len * m_width * m_height; }

它们的继承关系为：Line --> Rec --> Cuboid  
可以发现，Line 类表示“线”，没有面积和体积，但它仍然定义了 area() 和 volume() 两个纯虚函数。这样的用意很明显：Line 类不需要被实例化，但是它为派生类提供了“约束条件”，派生类必须要实现这两个函数，完成计算面积和体积的功能。  
在实际开发中，你可以定义一个抽象基类，只完成部分功能，未完成的功能交给派生类去实现（谁派生谁实现）。这部分未完成的功能，往往是基类不需要的，或者在基类中无法实现的。虽然抽象基类没有完成，但是却强制要求派生类完成，这就是抽象基类的“霸王条款”。

[C]: http://c.biancheng.net/cplus/