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

C++--多态

news 2025/8/2 6:42:34

一，引言

多态(polymorphism)的概念：通俗来说，就是多种形态。多态分为编译时多态(静态多态)和运⾏时多态(动态多态)，这⾥我们重点讲运⾏时多态，编译时多态(静态多态)和运⾏时多态(动态多态)。编译时多态(静态多态)主要就是我们前⾯讲的函数重载和函数模板，他们传不同类型的参数就可以调⽤不同的函数，通过参数不同达到多种形态，之所以叫编译时多态，是因为他们实参传给形参的参数匹配是在编译时完成的，我们把编译时⼀般归为静态，运⾏时归为动态。

运⾏时多态，具体点就是去完成某个⾏为(函数)，可以传不同的对象就会完成不同的⾏为，就达到多种形态。⽐如买票这个⾏为，当普通⼈买票时，是全价买票；学⽣买票时，是优惠买票(5折或75折)；军⼈买票时是优先买票。再⽐如，同样是动物叫的⼀个⾏为(函数)，传猫对象过去，就是”(>^ω^<) 喵“，传狗对象过去，就是"汪汪"。

二，多态的定义以及实现

多态是⼀个继承关系的下的类对象，去调⽤同⼀函数，产⽣了不同的⾏为。⽐如Student继承了 Person。Person对象买票全价，Student对象优惠买票。

实现多态有两个重要条件（非常重要）

1，必须是基类的指针或者引⽤调⽤虚函数。

2，被调用的函数必须是虚函数，并且完成覆盖或者从写。

注意：要实现多态效果，第⼀必须是基类的指针或引⽤，因为只有基类的指针或引⽤才能既指向基类对象⼜指向派⽣类对象；第⼆派⽣类必须对基类的虚函数完成重写/覆盖，重写或者覆盖了，基类和派⽣类之间才能有不同的函数，多态的不同形态效果才能达到。举个例子：

class Person
{
public:virtual void BuyTicket(){cout << "成人买全票" << endl;}
};
class Student :public Person
{
public:virtual void BuyTicket(){cout << "学生学学生票" << endl;}
};
int main()
{Person s;Student n;Person* p = &s;Person* q = &n;p->BuyTicket();q->BuyTicket();return 0;
}

上述函数实现了，指向谁调用谁。p指向person对象，调用person的虚函数；q指向student对象，调用student的虚函数。

理解这个原理，要先讲一下什么是虚函数。

1，虚函数

1，1虚函数的重写

类成员函数前⾯加virtual修饰，那么这个成员函数被称为虚函数。注意⾮成员函数不能加virtual修饰。如上述person的buytecket和student中的buytecket这两个成员函数都叫做虚函数。虚函数有一个重要的概念重写：即在子类中有一个和父类完全相同的虚函数（返回值，函数名，参数类别）完成相同。叫做虚函数的重写或者覆盖。称子类的虚函数重写了父类的基函数。

注意：在派生类中重写的虚函数前是可以不加virtual。可以理解是被继承下来的(但是这种写法不规范)如下：

class Person
{
public:virtual void BuyTicket(){cout << "成人买全票" << endl;}
};
class Student :public Person
{
public:void BuyTicket(){cout << "学生学学生票" << endl;}
};

上述也构成了派生类对基类虚函数的重写。

1，2虚函数的练习题

来看一道编程题，判断该呈现的运行结果是什么？

答案讲解在本文最后。

1，3虚函数的协变

派⽣类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引⽤，派⽣类虚函数返回派⽣类对象的指针或者引⽤时，称为协变。协变的实际意义并不⼤，所以我们了解⼀下即可。如下代码：

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;}
};

上述代码也可以实现多态功能。

2，析构函数的重写

基类的析构函数为虚函数，此时派⽣类析构函数只要定义，⽆论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派⽣类析构函数名字不同看起来不符合重写的规则，实际上编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统⼀处理成destructor，所以基类的析构函数加了 vialtual修饰，派⽣类的析构函数就构成重写。即在编译器内部两个成员函数是同名的。为什么要实现虚函数的重写呢？来看如下例子：

class A
{
public:virtual ~A(){cout << "~A()" << endl;}
};class B : public A {
public:~B(){cout << "~B()->delete:" << _p << endl;delete _p;}
protected:int* _p = new int[10];
};
int main()
{A* p1= new A;A* p2= new A;delete p1;delete p2;return 0;
}

下⾯的代码我们可以看到，如果~A()，不加virtual，那么deletep2时只调⽤的A的析构函数，没有调⽤ B的析构函数，就会导致内存泄漏问题，因为~B()中在释放资源。若实现为多态的形式就可以做到指向谁调用谁，就可以保证B类的资源得到释放。

3，override 和final关键字

从上⾯可以看出，C++对虚函数重写的要求⽐较严格，但是有些情况下由于疏忽，⽐如函数名写错参数写错等导致⽆法构成重写，⽽这种错误在编译期间是不会报出的，只有在程序运⾏时没有得到预期结果才来debug会得不偿失，因此C++11提供了override，可以帮助⽤⼾检测是否重写。如果我们不想让派⽣类重写这个虚函数，那么可以⽤final去修饰。来看如下例子：

当加上override编译器就会检查报错，如果不加则没有。

4，纯虚函数与抽象类

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

class Car
{
public:virtual void Drive() = 0;
};
class Benz :public Car
{
public:virtual void Drive(){cout << "Benz舒适" << endl;}
};
class BMW :public Car
{
public:virtual void Drive(){cout << "BMW操控" << endl;}
};

Car无法实例出对象。Benz和BMW通过重写之后就可以重新实例化对象。