【C++】多态

星霜旅人

已于 2025-04-08 16:16:13 修改

阅读量1.4k

点赞数 30

分类专栏： C++ 文章标签： c++

于 2025-03-30 15:31:42 首次发布

本文链接：https://blog.youkuaiyun.com/hsy1603914691/article/details/146592632

版权

C++ 专栏收录该内容

15 篇文章

订阅专栏

只要努力就一定能成功，其实是一种傲慢。

前言

这是我自己学习C++的第十二篇博客总结。后期我会继续把C++学习笔记开源至博客上。

上一期笔记是关于C++的继承知识，没看的同学可以过去看看：

【C++】继承_class :是继承吗 c++-优快云博客https://blog.youkuaiyun.com/hsy1603914691/article/details/146056477

多态的定义

1. 多态即''多种形态''。

2. 多态分为编译时多态(静态多态)和运行时多态(动态多态)。

3. 编译时多态(静态多态)主要就是函数重载和函数模板。他们传不同类型的参数就可以调用不同的函数，通过参数类型的不同，从而达到多种形态。之所以叫编译时多态，是因为实参传给形参的过程是在编译时完成的。

4. 运行时多态(动态多态)主要就是针对某个行为(函数)，传不同的对象会完成不同的行为，从而达到多种形态。比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是优惠买票；军人买票时是优先买票。

5. 动态多态就是一个在继承关系下的类对象，去调用同一函数，生了不同的行为。比如Student继承了Person，调用同一个买票函数，Person对象买票全价，Student对象优惠买票。

多态的构成条件

1. 基类的指针或者引用调用虚函数。因为只有基类的指针或引用才能既指向基类对象又指向派生类对象。

2. 被调用的函数必须是虚函数，并且完成了虚函数的重写、覆盖。因为只有当虚函数重写、覆盖了，基类和派生类之间才能有不同的函数，多态的不同形态效果才能达到。

虚函数的定义

1. 类成员函数前面加virtual修饰 ，那么这个 成员函数 被称为 虚函数 。

2. 非成员函数不能加virtual修饰 。

class Person
{
public:
    virtual void BuyTicket() { cout << "买票-全价" << endl;}
};

虚函数重写、覆盖

1. 虚函数的重写、覆盖：派生类中有一个跟基类完全相同的虚函数(返回值类型、函数名字、参数列表完全相同)，称派生类的虚函数重写、覆盖了基类的虚函数。

析构函数重写、覆盖

1. 基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写。

2. 虽然基类与派生类析构函数名字不同看起来不符合重写的规则，实际上编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

3. 从下面的代码可以看出， 如果基类A的析构函数~A()没有声明为virtual， 那么在执行delete p2时， 只会调用基类A的析构函数， 而不会调用派生类B的析构函数。这会导致 派生类B中分配的资源无法释放， 从而引发内存泄漏问题。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
class A
{
public:
    virtual ~A()
    {
        cout << "~A()" << endl;
    }
};

class B : public A
{
public:
    ~B()
    {
        cout << "~B()" << endl;
        delete _p;
    }
protected:
    int* _p = new int[10];
};

int main()
{
    A* p1 = new A;
    A* p2 = new B;
    delete p1;
    delete p2;
    return 0;
}
//~A()
//~B()
//~A()

override关键字

1. C++对虚函数重写的要求比较严格，但是有些情况下由于疏忽，比如函数名写错、参数写错等导致无法构成重写，而这种错误在编译期间是不会报出的。而C++11提供了override关键字，可以帮助用户检测是否重写。

2. 注意 override关键字 加在 需要构成多态的派生类成员函数后面 。

class Car 
{
public:
    virtual void Dirve()
    {}
};

class Benz:public Car 
{
public:
    virtual void Drive() override 
    { 
        cout << "Benz-舒适" << endl;
    }
};

final关键字

1. 当一个类加上final关键字时，这个类就不能再被其他类继承。
2. 当一个虚函数加上final关键字时，这个函数就不能在任何派生类中被重写。

class Car 
{
public:
    virtual void Dirve() final
    {}
};

class Benz:public Car 
{
public:
    virtual void Drive() 
    { 
        cout << "Benz-舒适" << endl;
    }
};

重载-重写-覆盖

1. 考虑构成隐藏之前，需要考虑是否已经构成重写。

2. 重载函数必须在同一个作用域中。

纯虚函数和抽象类

1. 在 虚函数 的后面写上 =0 ，则这个函数为 纯虚函数 。

2. 纯虚函数不需要定义实现 ， 只要声明即可 ：在类中声明一个纯虚函数时， 只需指出该函数的签名(包括 返回类型、 函数名和 参数列表)，并在 声明末尾加上=0来表明它是一个纯虚函数，而 不需要为这个函数编写具体的实现代码。

3. 包含纯虚函数的类 叫做 抽象类 ，抽象类 不能实例化出对象 ，如果 派生类继承后不重写纯虚函数 ，那么 派生类也是抽象类 。

4. 纯虚函数 某种程度上 强制了派生类重写虚函数 ，因为 不重写实例化不出对象 。

class Car
{
public:
    virtual void Drive() = 0;
};

多态的原理

多态是如何实现的

1. 满足多态条件后，底层不再是编译时通过调用对象确定函数的地址，而是运行时到指向的对象的虚表中确定对应的虚函数的地址，这样就实现了指针或引用指向基类就调用基类的虚函数，指向派生类就调用派生对应的虚函数。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

class Person {
public:
	virtual void BuyTicket() 
	{ cout << "买票-全价" << endl; }
private:
	string _name;
};
class Student : public Person 
{
public:
	virtual void BuyTicket() 
	{ cout << "买票-打折" << endl; }
private:
	string _id;
};
class Soldier : public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-优先" << endl;
	}
private:
	string _codename;
};
void Func(Person* ptr)
{
	// 这里可以看到虽然都是Person指针Ptr在调用BuyTicket
	// 但是跟ptr没关系，而是由ptr指向的对象决定的。
	ptr->BuyTicket();
}

int main() 
{
	// 其次多态不仅仅发生在派生类对象之间，多个派生类继承基类，重写虚函数后，多态也会发生在多个派生类之间。
	Person ps;
	Student st;
	Soldier sr;
	Func(&ps);
	Func(&st);
	Func(&sr);
	return 0;
}

动态绑定与静态绑定

1. 对不满足多态条件 (基类指针或者引用+调用虚函数) 的函数调用是在编译时绑定 ，也就是编译时确定调用函数的地址，叫做 静态绑定 。

2. 满足多态条件的函数调用是在运行时绑定 ，也就是在运行时到指向对象的虚函数表中找到调用函数的地址，也就做 动态绑定 。

虚函数表

1. 基类对象的虚函数表中存放基类所有虚函数的地址。

2. 同类型的对象共用同一张虚表，不同类型的对象各自有独立的虚表。

3. 派生类对象中包含了一个完整的基类部分，这个基类部分有自己的虚函数表指针。这个虚函数表指针和单独创建的基类对象的虚函数表指针是独立的，尽管它们可能指向相同的虚函数表。

4. 虚函数表的内容会根据派生类是否重写了基类的虚函数而动态调整。如果派生类中重写的基类的虚函数，那么派生类的虚函数表中对应的虚函数就会被覆盖成派生类重写的虚函数地址。

+---------------------------+
| 派生类的虚函数表指针 (vptr) |
+---------------------------+
| 基类子对象                |
| - 基类的虚函数表指针 (vptr)|
| - 基类的成员变量          |
+---------------------------+
| 派生类的成员变量          |
+---------------------------+