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

【C++】从静态到动态：多态的诗意旅程

news 来源：原创 2025/6/20 2:52:25

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

前言

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

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

【C++】继承探幽：构建代码复用与扩展的新境界-CSDN博客https://blog.csdn.net/hsy1603914691/article/details/146056477

多态的定义

1. 多态的概念：多种形态。

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

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

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

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

多态的构成条件

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

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

虚函数

1. 类成员函数 前面加 virtual修饰 ，那么这个成员函数被称为 虚函数 。注意： 非成员函数不能加virtual修饰 。

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

虚函数重写

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

析构函数重写

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

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

3. 下面的代码可以看到，如果 ~A()不加virtual ，那么 delete p2 时只调用 A 的析构函数，没有调用 B 的析构函数，就会导致 内存泄漏问题 ，因为 ~B() 中在释放资源。

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 B;
    delete p1;
    delete p2;
    return 0;
}

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关键字加在不需要构成多态的基类成员函数中。

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. 这个虚函数表指针和单独创建的基类对象的虚函数表指针是独立的，尽管它们可能指向相同的虚函数表（或经过派生类调整后的虚函数表）。

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