C++ 面向对象 - 类的多态性与虚函数

多态性

在面向对象的方法中，多态性是指向不同对象发送同一个消息，不同对象在接收时会产生不同的行为（方法）。

通俗点说就是可以不用像 C 语言中为了求多种图形的面积而针对不同的图形各设计一个独立名字的函数，在 C++ 中只要设计一个专门用于求面积的函数名即可。这个专门用于求面积的函数名可以作为各种求图形面积的函数名。

这么做的好处在于程序设计者可以省去设立多个函数名对应多个函数的麻烦，使用的时候统一用同一个函数名就可调用具有不同功能的函数。

多态在 C++ 中的实现可以是函数的重载、运算符的重载和虚函数，本实训我们介绍虚函数的使用。

虚函数

我们知道在同一个类中是不能定义两个名字相同、参数个数和类型完全相同的函数，否则就是重复定义。但是在类的继承层次结构中，在不同的层次中可以出现名字相同、参数个数和类型相同而功能不同的函数。这时系统会根据同名覆盖的原则决定调用的对象。

那么有没有一种方法，用同一种调用形式，既能调用派生类又能调用基类的同名函数？即不通过不同的对象名去调用不同派生层次中的同名函数，而是通过指针调用它们，虚函数就是用来解决这个问题的。

虚函数是一种动态的重载方式。虚函数的作用是允许在派生类中重新定义与基类同名的函数，并可以通过基类指针或引用来访问基类和派生类中同名函数。

C++ 中要声明一个成员函数为虚函数，只需要在函数的声明前加上一个关键字 virtual 即可，然后就像对待普通成员函数那样，给它加上定义。

例如：

class Base
{
public:
    virtual void VFunc();     // 声明一个虚函数
};
void Base::VFunc()
{
    cout << "虚函数" << endl;
}

重写父类虚函数

当一个类继承了一个含有虚函数的类，子类就可以选择是否要对父类的虚函数进行重写。所谓重写，就是覆盖父类中的定义，提供一个自己的定义。当然也可以选择不重写，那么就沿用父类的定义。

要重写一个虚函数，需要增加一条与要重写的函数相同（参数与返回值）的函数声明，然后在声明后面加上说明符 override。

例如：

/* Base类的声明同上 */
class D1 : public Base     // 继承 Base 类
{
public:
    void VFunc() override;     // 重写 VFunc 函数
};
void D1::VFunc()
{
    cout << "覆盖父类实现" <<endl;
}
int main()
{
    D1 b;
    b.VFunc();
}

输出结果为：覆盖父类实现

在子类中重写虚函数时是可以重新定义访问性的，即使父类中虚函数的访问性为 private，在子类中仍然可以重写为 public。如果子类想要访问被重写的父类的定义，同样使用作用域运算符（::）即可。

例如：

/* Base类的声明同上 */
class D1 : public Base     // 继承 Base 类
{
public:
    void VFunc() override;     // 重写 VFunc 函数
};
void D1::VFunc()
{
    Base::VFunc();     // 调用父类的定义
    cout << "覆盖父类实现" <<endl;
}
int main()
{
    D1 b;
    b.VFunc();
}

输出结果为：

1. 虚函数
2. 覆盖父类实现

多态性的体现

C++ 允许将一个对象的指针赋值给它的父类指针变量。而当通过父类指针调用一个虚函数时，则会调用子类中最后被重写的那个版本，这样对于同一段通过指针调用某个虚函数的代码，就会因为实际指向的对象不同，而调用不同函数，这就是所谓的多态性。

同理，通过引用调用一个虚函数，也会有这样的效果。

例如：

class Base
{
public:
    virtual void Cal(int a,int b);
};
void Base::Cal(int a, int b)
{
    cout << a * b << endl;     // 默认是乘法
}
class Add : public Base
{
public:
    void Cal(int a,int b) override;
};
void Add::Cal(int a,int b)
{
    cout << a + b << endl;     // 实现一个加法
}
class Sub : public Base
{
public:
    void Cal(int a,int b) override;
};
void Sub::Cal(int a,int b)
{
    cout << a - b << endl;     //实现一个减法
}
//普通函数
void call(Base *ptr)
{
    ptr->Cal(10,10);     // 通过指针调用虚函数
}
int main()
{
    Add ad;
    call(&ad);
    Sub sb;
    call(&sb);
}

输出结果为：

1. 20
2. 0

可以看到，连续两次调用 call 函数，调用的效果有所不同。第一次调用的是对象是 Add，因此实现的是加法，即10+10=20；而第二次的调用对象是 Sub，实现的则是减法，即10-10=0。

虽然 C++ 也允许将子类对象直接赋值给父类变量，但是这样做会导致子类被切割成父类对象，丢失了子类的成分，这时调用虚函数，也就不会调用到被子类的重写的版本了。

例如：

1. /* 类的定义同上 */
3. void call(Base b) // 这里不使用指针
4. {
5. b.Cal(10,10);
6. }
7. int main()
8. {
9. Add ad;
10. call(ad); // Add 子类赋值给 Base 父类变量
12. Sub sb;
13. call(sb); // Sub 子类赋值给 Base 父类变量
14. }

输出结果为：

1. 100
2. 100

如果子类对象赋值给父类变量，则使用该变量时只能访问子类的父类部分（因为子类含有父类的部分，所以不会有问题）。因此无论哪个对象在调用 Call 函数时都是调用的父类的成员函数，所以输出结果都为100，即10*10=100。

虚析构函数

如果一个父类的析构函数没有声明成虚函数，那么使用 delete 运算符销毁一个父类指针所指的子类对象时，就只会调用父类的析构函数，子类的析构函数则不会被调用，这样就可能导致子类动态分配的资源无法及时回收，造成资源泄露。

例如：

class Base
{
public:
    ~Base();     // 析构函数不是虚函数
};
Base::~Base()
{
    cout << "父类析构函数" << endl;
}
class D : public Base
{
public:
    int *Ptr;
    D();
    ~D();
};
D::D():Ptr(new int){}     // 动态分配一块 int 类型大小的空间
D::~D()
{
    delete Ptr;     // 回收 Ptr 所指空间
    cout << "子类析构函数" << endl;
}
int main()
{
    Base *ptr = new D();
    delete ptr;     // 由于只会调用 Base 类的析构函数，导致 D 类中 Ptr 所指的那块空间没有被释放，造成内存泄露。
}

输出结果为：父类析构函数

如果将析构函数声明为虚函数，调用它时除了调用子类重写的那个版本，还会沿着继承链向上（父类方向）依次调用父类的析构函数。

对于上面那个例子，如果将 Base 类的析构函数声明成虚函数，即virtual ~Base()，那么最后得到的输出结果就是：

1. 子类析构函数
2. 父类析构函数

即也就是依次调用了 D 类、Base 类的析构函数。所以，在一般情况下析构函数建议声明成虚函数。

纯虚函数

有时在类中将某一成员声明为虚函数，并不是因为基类本身的要求，而是因为派生类的需求，在基类中预留一个函数名，具体功能留给派生类区定义。这种情况下就可以将这个纯虚函数声明为纯虚函数。即纯虚函数的作用是在基类中为其派生类保留一个函数的名字，以便派生类对它进行定义。

纯虚函数就是在声明虚函数时被初始化为0的函数，但它只有名字，不具备函数功能，不能被调用，其一般形式是：

virtual 函数类型 函数名（参数列表） = 0

纯虚函数没有函数体。最后的“=0”只是一种形式，告诉编译系统，它是一个纯虚函数，留在派生类中定义，并没有实际意义。

纯虚函数只有在派生类中定义了之后才能被调用。如果在一个类中声明了纯虚函数，而在派生类中没有对该函数定义，则该虚函数在派生类中仍然为纯虚函数。

例如：

class Base
{
public:
    virtual void Func() = 0;     // 声明一个纯虚函数
};

抽象类

含有纯虚函数的类就成为抽象类。抽象类只是一种基本的数据类型，用户需要在这个基础上根据自己的需要定义处各种功能的派生类。

抽象类的作用就是为一个类族提供一个公共接口。抽象类不能定义对象，但是可以定义指向抽象类的指针变量，通过这个指针变量可以实现多态。

例如：

class Base
{
public:
    virtual void Func() = 0;     // 声明一个纯虚函数
};
class D1 : public Base {}     // 什么也不做
class D2 : public Base
{
public:
    void Func() override;     // 重写纯虚函数
};
void D2::Func() { /* …… */ }
int main()
{
    Base b = Base();     // 错误，Base 类是抽象类，不能定义对象。
    Base *ptr1 = new D1();     // 错误，D1 没有重写 Base 类的 Func 函数，所以也是抽象类。
    Base *ptr2 = new D2();     //正确
}

例题

第1关：人与复读机

任务描述

本关任务：设计人类、英语学生类和复读机类三个类。

相关知识

为了完成完成本关任务，你需要掌握虚函数的基本使用。

编程要求

在右侧编辑器中的Begin-End之间补充代码，设计人类、英语学生类和复读机类三个类，具体要求如下：

1. 人类（ Chinese ）

   • 它有一个虚函数 greet，函数输出中文问候，即你好。

2. 英语学生类（ EnglishLearner ）

   • 继承 Chinese 类，重写 greet 函数，访问性为 public，输出英文问候，即Hello。

3. 复读机类（ Repeater ）

   • 继承 Chinese 类，以 public 访问性重写 greet 函数，函数调用 Chinese 类的 greet 函数。

测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试。

代码解析

#include <iostream>
using namespace std;

/********* Begin *********/
class Chinese
{
//人类的声明
public:
    virtual void greet();
};
//人类的定义

void Chinese::greet(){
    cout << "你好" << endl;
}

class EnglishLearner : public Chinese
{
//英语学生类的声明
public:
    void greet() override;
};
//英语学生类的定义

void EnglishLearner::greet(){
    cout << "Hello" << endl;
}

class Repeater : public Chinese
{
//复读机类的声明
public:
    void greet() override;
};
//复读机类的定义

void Repeater::greet(){
    Chinese::greet();
}

/********* End *********/

第2关：复读机的毁灭

任务描述

本关任务：设计三个复读机类并实现一个普通函数。

相关知识

为了完成本关任务，你需要掌握虚析构函数的使用。

编程要求

在右侧编辑器中的Begin-End之间补充代码，设计三个复读机类和一个普通函数，具体要求如下：

1. 复读机类（ Repeater ）

   • 它有一个成员函数 Play，在这里它什么也不做。它还有一个析构函数，它被调用时会输出一行砰！。

2. 正向复读机类（ ForRepeater ）

   • 继承 Repeater 类并重写 Play 函数，输出没想到你也是一个复读机且在析构函数中输出正·复读机 炸了。

3. 反向复读机类（ RevRepeater ）

   • 继承 Repeater 类也重写 Play 函数，输出机读复个一是也你到想没且在析构函数中输出机读复·反 炸了。

4. 普通函数：Repeater* CreateRepeater(int type)，函数根据 type 的值，动态创建不同的复读机对象，并返回它的指针。其中当type = 0，创建 ForRepeater 对象；type = 1，创建 RevRepeater 对象；其他则返回 0。

测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：0

预期输出：

1. 没想到你也是一个复读机
2. 正·复读机 炸了
3. 砰！

代码解析

#include <iostream>
using namespace std;

/********* Begin *********/
class Repeater
{
//复读机基类的声明
public:
    virtual void Play();
    virtual ~Repeater();    
};
//复读机基类的定义

void Repeater::Play(){}

Repeater::~Repeater(){
    cout << "砰！" << endl;
}

class ForRepeater : public Repeater
{
//正向复读机的声明
public:
    void Play() override;
    virtual ~ForRepeater();
};
//正向复读机的定义

void ForRepeater::Play(){
    cout << "没想到你也是一个复读机" << endl;
}

ForRepeater::~ForRepeater(){
    cout << "正·复读机 炸了" << endl;
}

class RevRepeater : public Repeater
{
//反向复读机的声明
public:
    void Play() override;
    virtual ~RevRepeater();
};
//反向复读机的定义

void RevRepeater::Play(){
    cout << "机读复个一是也你到想没" << endl;
}

RevRepeater::~RevRepeater(){
    cout << "机读复·反 炸了" << endl;
}

//普通函数
Repeater* CreateRepeater(int type)
{
    //根据type创建指定的复读机
    if(type == 0){
        return new ForRepeater();
    }
    else if(type == 1){
        return new RevRepeater();
    }
    else{
        return 0;
    }
    
    
}

/********* End *********/

第3关：计算图像面积

任务描述

本关任务：设计一个矩形类、一个圆形类和一个图形基类，计算并输出相应图形面积。

相关知识

为了完成本关任务，你需要掌握纯虚函数和抽象类的使用。

编程要求

在右侧编辑器中的Begin-End之间补充代码，设计图像基类、矩形类和圆形类三个类，函数成员变量据情况自己拟定，其他要求如下：

1. 图形类（ shape ）

   • 纯虚函数：void PrintArea()，用于输出当前图形的面积。

2. 矩形类（ Rectangle ）

   • 继承 Shape 类，并且重写 PrintArea 函数，输出矩形的面积，输出格式为：矩形面积 = width*height。

   • 带参构造函数：Rectangle(float w,float h)，这两个参数分别赋值给成员变量的宽、高。

3. 圆形类（ Circle ）

   • 继承 Shape 类，并且重写 PrintArea 函数，输出圆形的面积，输出格式为：圆形面积 = radio * radio * 3.14。

   • 带参构造函数：Circle(float r)，参数 r 代表圆的半径。

测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：10 2.5

预期输出：

1. 矩形面积 = 20
2. 圆形面积 = 314

测试输入：2 2.5

预期输出：

1. 矩形面积 = 4
2. 圆形面积 = 12.56

代码解析

#include <iostream>
using namespace std;

/********* Begin *********/
class Shape
{
//基类的声明
public:
    virtual void PrintArea() = 0;
};

class Rectangle : public Shape
{
//矩形类的声明
private:
    float width, height;
public:
    void PrintArea() override;
    Rectangle(float w,float h);
};
//矩形类的定义

void Rectangle::PrintArea(){
    cout << "矩形面积 = " << width*height << endl;
}

Rectangle::Rectangle(float w,float h){
    width = w;
    height = h;
}

class Circle : public Shape
{
//圆形类的声明
public:
    float radio;
    void PrintArea() override;
    Circle(float r);
};
//圆形类的定义

void Circle::PrintArea(){
    cout << "圆形面积 = " << radio * radio * 3.14 << endl;
}

Circle::Circle(float r){
    radio = r;
}

/********* End *********/