C++进阶(三)--多态

一、多态的基本概念

1.什么是多态

二、多态的定义及实现

1.虚函数

2.虚函数的重写

3.虚函数重写的⼀些其他问题

协变(了解)

析构函数的重写

C++11 override和final

4.重载、覆盖(重写)、隐藏(重定义)的对比

三、抽象类

1.纯虚函数

2.接口继承和实现继承

四、多态的原理

1.虚函数表

2.多态的原理

3.动态绑定和静态绑定

引言

在 C++ 编程的世界中，多态性（Polymorphism）是面向对象编程（OOP）的核心概念之一，它赋予了程序无与伦比的灵活性和可扩展性。多态性允许我们以统一的方式处理不同类型的对象，使代码更加简洁、易于维护，并且能够更好地适应未来的变化。通过多态，我们可以编写更具通用性和抽象性的代码，而无需关心具体的对象类型，这在构建大型软件系统时显得尤为重要。在本文中，我们将深入探讨 C++ 中的多态，包括其基本概念、实现方式、应用场景、优势、潜在的陷阱以及一些高级话题，帮助你深入理解并熟练运用多态性来提升代码的质量和可维护性。

一、多态的基本概念

1.什么是多态

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

静态多态代码示例：

#include <iostream>
class MathOperations {
public:
    int add(int a, int b) {
        return a + b;
    }


    double add(double a, double b) {
        return a + b;
    }

    int add(int a, int b, int c) {
        return a + b + c;
    }
};

int main() {
    MathOperations mo;
    std::cout << mo.add(1, 2) << std::endl;          // 调用 int add(int, int)
    std::cout << mo.add(1.1, 2.2) << std::endl;      // 调用 double add(double, double)
    std::cout << mo.add(1, 2, 3) << std::endl;      // 调用 int add(int, int, int)

    return 0;
}

运⾏时多态（动态多态），具体点就是去完成某个⾏为(函数)，可以传不同的对象就会完成不同的⾏为，就达到多种形态。

⽐如买票这个⾏为，当普通⼈买票时，是全价买票；学⽣买票时，是优惠买票(5折或75折)；军⼈买票时是优先买票。

再⽐如，同样是动物叫的⼀个⾏为(函数)，传猫对象过去，就是”(>^ω^<) 喵“，传狗对象过去，就是"汪汪"。

运行时多态是通过虚函数（Virtual Functions）和继承来实现的。基类中的虚函数可以在派生类中被重写（Override），当通过基类指针或引用调用虚函数时，会根据对象的实际类型调用相应的函数。这是 C++ 多态性的核心，也是本文的重点。

代码示例：

class Person {
public:
    // 虚函数，用于购买票，输出全价信息
    virtual void BuyTicket() {
        cout << "买票 全价" << endl;
    }
};

class Student : public Person 
{
public:
    // 重写基类的虚函数，用于购买票，输出打折信息
    virtual void BuyTicket() override 
    {
        cout << "买票 打折" << endl;
    }
};

// 定义一个函数，接受一个 Person 指针作为参数
void Func(Person* ptr) 
{
    // 这里调用 BuyTicket 函数，由于 BuyTicket 是虚函数，实际调用的函数将根据 ptr 指向的对象的类型来决定
    // 如果 ptr 指向 Person 对象，调用 Person 的 BuyTicket 函数；如果指向 Student 对象，调用 Student 的 BuyTicket 函数
    ptr->BuyTicket();
}

int main() 
{
    Person ps;
    Student st;
    // 调用 Func 函数，传入 Person 对象的地址
    Func(&ps);
    // 调用 Func 函数，传入 Student 对象的地址
    Func(&st);
    return 0;
}

二、多态的定义及实现

多态是指不同继承关系的类对象，去调用同一函数，产生了不同的行为。在继承中要想构成多态需要满足两个条件：

必须通过基类的指针或者引用调用虚函数。
被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。

1.虚函数

被virtual修饰的类成员函数被称为虚函数。

class Student : public Person 
{
public:
    // 重写基类的虚函数
    virtual void BuyTicket() override 
    {
        cout << "买票 打折" << endl;
    }
};

需要注意的是：

友元函数不属于成员函数，不能成为虚函数

静态成员函数就不能设置为虚函数，静态成员函数与具体对象无关，属于整个类，核心关键是没有隐藏的this指针，可以通过类名::成员函数名直接调用，此时没有this无法拿到虚表，就无法实现多态，因此不能设置为虚函数

只有类的非静态成员函数前可以加virtual，普通函数前不能加virtual。
虚函数这里的virtual和虚继承中的virtual是同一个关键字，但是它们之间没有任何关系。虚函数这里的virtual是为了实现多态，而虚继承的virtual是为了解决菱形继承的数据冗余和二义性。

2.虚函数的重写

虚函数的重写也叫做虚函数的覆盖，若派生类中有一个和基类完全相同的虚函数(返回值类型相同、函数名相同以及参数列表完全相同)，此时我们称该派生类的虚函数重写了基类的虚函数。

例如，我们以下Student和Soldier两个子类重写了父类Person的虚函数。

//父类
class Person
{
public:
	//父类的虚函数
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
};
//子类
class Student : public Person
{
public:
	//子类的虚函数重写了父类的虚函数
	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
};
//子类
class Soldier : public Person
{
public:
	//子类的虚函数重写了父类的虚函数
	virtual void BuyTicket()
	{
		cout << "优先-买票" << endl;
	}
};

现在我们就可以通过父类Person的指针或者引用调用虚函数BuyTicket，此时不同类型的对象，调用的就是不同的函数，产生的也是不同的结果，进而实现了函数调用的多种形态。

void Func(Person& p)
{
	//通过父类的引用调用虚函数
	p.BuyTicket();
}
void Func(Person* p)
{
	//通过父类的指针调用虚函数
	p->BuyTicket();
}
int main()
{
	Person p;   //普通人
	Student st; //学生
	Soldier sd; //军人

	Func(p);  //买票-全价
	Func(st); //买票-半价
	Func(sd); //优先买票

	Func(&p);  //买票-全价
	Func(&st); //买票-半价
	Func(&sd); //优先买票
	return 0;
}

注意： 在重写基类虚函数时，派生类的虚函数不加virtual关键字也可以构成重写，主要原因是因为继承后基类的虚函数被继承下来了，在派生类中依旧保持虚函数属性。但是这种写法不是很规范，因此建议在派生类的虚函数前也加上virtual关键字。

3.虚函数重写的⼀些其他问题

协变(了解)

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

class A {};
class B : public A {};

class Person {
public:
    // 虚函数 BuyTicket，返回 A* 类型的指针
    virtual A* BuyTicket() {
        std::cout << "买票 全价" << std::endl;
        return nullptr;
    }
};

class Student : public Person 
{
public:
    // 重写基类 Person 的虚函数 BuyTicket，返回 B* 类型的指针
    virtual B* BuyTicket() override 
    {
        std::cout << "买票 打折" << std::endl;
        return nullptr;
    }
};

// 函数 Func 接收一个 Person* 类型的指针，并调用其 BuyTicket 函数
void Func(Person* ptr) 
{
    ptr->BuyTicket();
}


int main() 
{
    Person ps;
    Student st;
    Func(&ps);
    Func(&st);
    return 0;
}

析构函数的重写

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

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

注意：这个问题⾯试中经常考察，⼤家⼀定要结合类似下⾯的样例才能讲清楚，为什么基类中的析构函数建议设计为虚函数。

class A {
public:
    // 虚析构函数
    virtual ~A() {
        std::cout << "~A()" << std::endl;
    }
};

class B : public A {
public:
    B() : _p(new int[10]) { }
    // 重写基类的析构函数
    virtual ~B()  {
        std::cout << "~B()->delete: " << _p << std::endl;
        delete[] _p;
    }

protected:
    int* _p = nullptr;
};

int main() {
    A* p1 = new A;
    A* p2 = new B;//指向子类仍然调用父类析构函数--需要构成多态

    delete p1;
    delete p2;

    return 0;
}

在这种场景下，若是父类和子类的析构函数没有构成重写就可能会导致内存泄漏，因为此时delete p1和delete p2都是调用的父类的析构函数，而我们所期望的是p1调用父类的析构函数，p2调用子类的析构函数，即我们期望的是一种多态行为。
此时只有父类和子类的析构函数构成了重写，才能使得delete按照我们的预期进行析构函数的调用，才能实现多态。因此，为了避免出现这种情况，比较建议将父类的析构函数定义为虚函数。

C++11 override和final

从上面可以看出，C++对函数重写的要求比较严格，有些情况下由于疏忽可能会导致函数名的字母次序写反而无法构成重写，而这种错误在编译期间是不会报错的，直到在程序运行时没有得到预期结果再来进行调试会得不偿失，因此，C++11提供了final和override两个关键字，可以帮助用户检测是否重写。

1. ﬁnal：修饰虚函数，表示该虚函数不能再被重写

例如，父类Person的虚函数BuyTicket被final修饰后就不能再被重写了，子类若是重写了父类的BuyTicket函数则编译报错。

//父类
class Person
{
public:
	//被final修饰，该虚函数不能再被重写
	virtual void BuyTicket() final
	{
		cout << "买票-全价" << endl;
	}
};
//子类
class Student : public Person
{
public:
	//重写，编译报错
	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
};
//子类
class Soldier : public Person
{
public:
	//重写，编译报错
	virtual void BuyTicket()
	{
		cout << "优先-买票" << endl;
	}
};

2.override：检查派生类虚函数是否重写了基类的某个虚函数，如果没有重写则编译报错。

//父类
class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
};
//子类
class Student : public Person
{
public:
	//子类完成了父类虚函数的重写，编译通过
	virtual void BuyTicket() override
	{
		cout << "买票-半价" << endl;
	}
};
//子类
class Soldier : public Person
{
public:
	//子类没有完成了父类虚函数的重写，编译报错
	virtual void BuyTicket(int i) override
	{
		cout << "优先-买票" << endl;
	}
};

4.重载、覆盖(重写)、隐藏(重定义)的对比

三、抽象类

1.纯虚函数

在虚函数的后⾯写上=0，则这个函数为纯虚函数，纯虚函数不需要定义实现(实现没啥意义因为要被派⽣类重写，但是语法上可以实现)，只要声明即可。

包含纯虚函数的类叫做抽象类，抽象类不能实例化出对象，如果派⽣类继承后不重写纯虚函数，那么派⽣类也是抽象类。纯虚函数某种程度上强制了派⽣类重写虚函数，因为不重写实例化不出对象。

#include <iostream>
using namespace std;
//抽象类（接口类）
class Car
{
public:
	//纯虚函数
	virtual void Drive() = 0;
};
int main()
{
	Car c; //抽象类不能实例化出对象，error
	return 0;
}

派生类继承抽象类后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。

#include <iostream>
using namespace std;
//抽象类（接口类）
class Car
{
public:
	//纯虚函数
	virtual void Drive() = 0;
};
//派生类
class Benz : public Car
{
public:
	//重写纯虚函数
	virtual void Drive()
	{
		cout << "Benz-舒适" << endl;
	}
};
//派生类
class BMV : public Car
{
public:
	//重写纯虚函数
	virtual void Drive()
	{
		cout << "BMV-操控" << endl;
	}
};
int main()
{
	//派生类重写了纯虚函数，可以实例化出对象
	Benz b1;
	BMV b2;
	//不同对象用基类指针调用Drive函数，完成不同的行为
	Car* p1 = &b1;
	Car* p2 = &b2;
	p1->Drive();  //Benz-舒适
	p2->Drive();  //BMV-操控
	return 0;
}

抽象类既然不能实例化出对象，那抽象类存在的意义是什么？

强制派生类实现接口：含有纯虚函数的类是抽象类，不能被实例化。这就强制要求任何继承自该抽象类的派生类，必须实现纯虚函数，否则派生类也会成为抽象类。

为运行时多态奠定基础：纯虚函数搭配虚函数机制，让通过基类指针或引用调用函数时，能够根据对象的实际类型，动态调用对应的函数。

分离接口与实现：抽象类将通用的接口提取出来，开发者可以先聚焦于顶层的抽象设计，后续逐步完善派生类的具体实现，让代码结构更加清晰。

2.接口继承和实现继承

实现继承： 普通函数的继承是一种实现继承，派生类继承了基类函数的实现，可以使用该函数。

接口继承： 虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态。

建议： 所以如果不实现多态，就不要把函数定义成虚函数。

四、多态的原理

1.虚函数表

下面是一道常考的笔试题：Base类实例化出对象的大小是多少？

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
};

通过观察测试，我们发现Base类实例化的对象b的大小是8个字节。

int main()
{
	Base b;
	cout << sizeof(b) << endl; //8
	return 0;
}

b对象当中除了_b成员外，实际上还有一个_vfptr放在对象的前面（有些平台可能会放到对象的最后面，这个跟平台有关）。

对象中的这个指针叫做虚函数表指针，简称虚表指针，虚表指针指向一个虚函数表，简称虚表，每一个含有虚函数的类中都至少有一个虚表指针。

虚函数表中到底放的是什么？

下面Base类当中有三个成员函数，其中Func1和Func2是虚函数，Func3是普通成员函数，子类Derive当中仅对父类的Func1函数进行了重写。

#include <iostream>
using namespace std;
//父类
class Base
{
public:
	//虚函数
	virtual void Func1()
	{
		cout << "Base::Func1()" << endl;
	}
	//虚函数
	virtual void Func2()
	{
		cout << "Base::Func2()" << endl;
	}
	//普通成员函数
	void Func3()
	{
		cout << "Base::Func3()" << endl;
	}
private:
	int _b = 1;
};
//子类
class Derive : public Base
{
public:
	//重写虚函数Func1
	virtual void Func1()
	{
		cout << "Derive::Func1()" << endl;
	}
private:
	int _d = 2;
};
int main()
{
	Base b;
	Derive d;
	return 0;
}

通过调试可以发现，父类对象b和子类对象d当中除了自己的成员变量之外，父类和子类对象都有一个虚表指针，分别指向属于自己的虚表。

实际上虚表当中存储的就是虚函数的地址，因为父类当中的Func1和Func2都是虚函数，所以父类对象b的虚表当中存储的就是虚函数Func1和Func2的地址。

而子类虽然继承了父类的虚函数Func1和Func2，但是子类对父类的虚函数Func1进行了重写，因此，子类对象d的虚表当中存储的是父类的虚函数Func2的地址和重写的Func1的地址。这就是为什么虚函数的重写也叫做覆盖，覆盖就是指虚表中虚函数地址的覆盖，重写是语法的叫法，覆盖是原理层的叫法。

其次需要注意的是：Func2是虚函数，所以继承下来后放进了子类的虚表，而Func3是普通成员函数，继承下来后不会放进子类的虚表。此外，虚函数表本质是一个存虚函数指针的指针数组，一般情况下会在这个数组最后放一个nullptr，我们可以在内存中观察到。

总结一下，派生类的虚表生成步骤如下：

先将基类中的虚表内容拷贝一份到派生类的虚表。
如果派生类重写了基类中的某个虚函数，则用派生类自己的虚函数地址覆盖虚表中基类的虚函数地址。
派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

虚表是什么阶段初始化的？虚函数存在哪里？虚表存在哪里？

虚表实际上是在构造函数初始化列表阶段进行初始化的，注意虚表当中存的是虚函数的地址不是虚函数，虚函数和普通函数一样，都是存在代码段的，只是他的地址又存到了虚表当中。另外，对象中存的不是虚表而是指向虚表的指针。
至于虚表是存在哪里的，我们可以通过以下这段代码进行判断。

int j = 0;
int main()
{
	Base b;
	Base* p = &b;
	printf("vfptr:%p\n", *((int*)p)); //002AAB5C
	int i = 0;
	printf("栈上地址:%p\n", &i);       //:0133FCB8
	printf("数据段地址:%p\n", &j);     //002AD45C

	int* k = new int;
	printf("堆上地址:%p\n", k);       //0178D280
	const char* cp = "hello world";
	printf("代码段地址:%p\n", cp);    //002AAB4C
	return 0;
}

代码当中打印了对象b当中的虚表指针，也就是虚表的地址，可以发现虚表地址与代码段的地址非常接近，由此我们可以得出虚表实际上是存在代码段的。

2.多态的原理

面代码中，为什么当父类Person指针指向的是父类对象Mike时，调用的就是父类的BuyTicket，当父类Person指针指向的是子类对象Johnson时，调用的就是子类的BuyTicket?

#include <iostream>
using namespace std;
//父类
class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
	int _p = 1;
};
//子类
class Student : public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
	int _s = 2;
};
int main()
{
	Person Mike;
	Student Johnson;
	Johnson._p = 3; //以便观察是否完成切片
	Person* p1 = &Mike;
	Person* p2 = &Johnson;
	p1->BuyTicket(); //买票-全价
	p2->BuyTicket(); //买票-半价
	return 0;
}

通过调试可以发现，对象Mike中包含一个成员变量_p和一个虚表指针，对象Johnson中包含两个成员变量_p和_s以及一个虚表指针，这两个对象当中的虚表指针分别指向自己的虚表。

围绕此图分析便可得到多态的原理：

1.父类指针p1指向Mike对象，p1->BuyTicket在Mike的虚表中找到的虚函数就是Person::BuyTicket。
2.父类指针p2指向Johnson对象，p2>BuyTicket在Johnson的虚表中找到的虚函数就是Student::BuyTicket。
这样就实现出了不同对象去完成同一行为时，展现出不同的形态

虚函数表总结：

基类对象的虚函数表中存放基类所有虚函数的地址。同类型的对象共⽤同⼀张虚表，不同类型的对象各⾃有独⽴的虚表，所以基类和派⽣类有各⾃独⽴的虚表。

派⽣类由两部分构成，继承下来的基类和⾃⼰的成员，⼀般情况下，继承下来的基类中有虚函数表指针，⾃⼰就不会再⽣成虚函数表指针。但是要注意的这⾥继承下来的基类部分虚函数表指针和基类对象的虚函数表指针不是同⼀个，就像基类对象的成员和派⽣类对象中的基类对象成员也独⽴的。