【C++】多态功能细节问题分析

        多态是在不同继承关系的类对象去调用同一函数，产生了不同的行为。值得注意的是，虽然多态在功能上与隐藏是类似的，但是还是有较大区别的，本文也会进行多态和隐藏的差异分析。

1. 在继承中要构成多态的条件

                 1.1必须通过基类的指针或引用调用虚函数。

                1.2被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。

以上两个条件就是判断多态的充分必要条件，在笔试中该类问题考察比较多，需要值得注意。

什么是虚函数？——可以简单的理解在成员函数前加一个virtual就变成虚函数了，至于虚函数与普通函数有什么区别就是动态绑定和静态绑定的区别，下面会仔细介绍。

而虚函数的重写也具备条件：虚函数+三同（同名、同返回值、同形参）。

下面是一个多态与非多态的比较：

#include<iostream>using namespace std;class Person
{
public:Person(size_t val ):TicketPrice(val){}//Person(size_t val = 100) :TicketPrice(val) {}virtual void GetPrice(){cout << "Person's TicketPrice : " << TicketPrice << endl;}protected:size_t TicketPrice;
};class Man:public Person
{
public:Man(size_t val) :Person(val){}virtual void GetPrice() override{cout << "Man's TicketPrice : " << TicketPrice << endl;}};class Child :public Person
{
public:Child(size_t val) :Person(val) { TicketPrice /= 2; }virtual void GetPrice() override{cout << "Child's TicketPrice : " << TicketPrice << endl;}};int main()
{Child cd(800);cd.GetPrice();//非多态//cd.Person::GetPrice();Person* pp;pp = new Child(800);//多态pp->GetPrice();return 0;
}

为什么pp->GetPrice()会输出Child’s TicketPrice : 400 呢？这就是多态的动态绑定的效果。

动态绑定 vs 静态绑定

普通函数：采用静态绑定（编译时绑定），即函数调用是在编译时确定的。这意味着函数调用的目标地址在编译阶段就已经固定下来了。

虚函数：采用动态绑定（运行时绑定），即函数调用是在运行时根据对象的实际类型来决定的。这使得程序可以根据对象的实际类型调用相应的函数版本。

根据动态绑定的特性，即运行时调用，结合重写的特性，其实就不难理解多态的原理了。

2、特殊的多态

在多态中有一个特殊的多态，即析构函数的多态。

首先，我们先测试一下非虚析构函数和虚析构函数的差别：

非虚析构函数：

class Base
{
public:~Base() { cout << "Base Destruct!" << endl; }};class Derived:public Base
{
public:~Derived() { cout << "Dericed Destruct!" << endl; }};int main()
{Base* bp;bp = new Derived();delete bp;return 0;
}

如果基类的析构函数不是虚函数，在通过基类指针删除派生类对象时，只会调用基类的析构函数，而不会调用派生类的析构函数。这可能会导致派生类中的资源没有被正确释放，从而造成内存或其他资源泄漏。

虚析构函数：

class Base
{
public:virtual ~Base() { cout << "Base Destruct!" << endl; }};class Derived:public Base
{
public:virtual ~Derived() override { cout << "Dericed Destruct!" << endl; }};int main()
{Base* bp;bp = new Derived();delete bp;return 0;
}

如果基类的析构函数被声明为虚函数，那么通过基类指针删除派生类对象时，首先会调用派生类的析构函数，然后是基类的析构函数。这样可以确保所有层级的对象都被正确销毁。

***提示：虚构函数编译器会自动识别为~Destructor（），所以即使基类和派生类的虚构函数名不同也会构成重写（不信你可以使用override测试一下）。

3、虚表

虚表（简称vtable）是C++实现动态绑定和多态的一种机制。当一个类包含至少一个虚函数时，编译器通常会为该类生成一个虚表，并在每一个对象中添加一个指向这个虚表的指针。

在C++中，当派生类对象赋值给基类对象时，不会拷贝虚表指针或虚表本身，这个赋值操作只会复制基类部分的数据成员，而不会涉及派生类特有的数据成员。上述现象的一个重要原因是对象切片（Object Slicing）。当一个派生类对象赋值给基类对象时，只有基类部分的数据会被复制，而派生类特有的部分会被“切掉”。

class Base
{
public:Base(int val=1) :_b(val) {}virtual void func1() {cout << "This is Base func1" << endl;}virtual void func2() {cout << "This is Base func2" << endl;}
protected:int _b;
};class Derived:public Base
{
public:Derived():_d(2){}virtual void func1() {cout << "This is Derived func1" << endl;}virtual void func2() {cout << "This is Derived func2" << endl;}virtual void func3() {cout << "This is Derived func3" << endl;}
protected:int _d;
};int main()
{Base b(2);Derived d;b = d;b.func1();d.func1();return 0;
}

当然，如果你需要保留派生类的特性，可以使用指针或引用来避免对象切片。

class Base
{
public:Base(int val=1) :_b(val) {}virtual void func1() {cout << "This is Base func1" << endl;}virtual void func2() {cout << "This is Base func2" << endl;}
protected:int _b;
};class Derived:public Base
{
public:Derived():_d(2){}virtual void func1() {cout << "This is Derived func1" << endl;}virtual void func2() {cout << "This is Derived func2" << endl;}virtual void func3() {cout << "This is Derived func3" << endl;}
protected:int _d;
};int main()
{Base* b = new Derived();b->func1();return 0;
}

---

值得注意的是，虚表的存贮位置是值得讨论的，很多人博客的表述及通义千问都是认为虚表是存储在静态区，但是从实际操作来看似乎有些问题。

那我们开始测试看虚表是否存储在静态区中吧！

class Base
{
public:Base(int val=1) :_b(val) {}virtual void func1() {cout << "This is Base func1" << endl;}virtual void func2() {cout << "This is Base func2" << endl;}
protected:int _b;const static int x = 1;
};class Derived:public Base
{
public:Derived():_d(2){}virtual void func1() {cout << "This is Derived func1" << endl;}virtual void func2() {cout << "This is Derived func2" << endl;}virtual void func3() {cout << "This is Derived func3" << endl;}
protected:int _d;
};typedef void(*FUNC_PTR)();int main()
{int a = 0;printf("栈区：%11p\n", &a);int* ap = new int();printf("堆区：%11p\n", ap);static int as = 1;printf("静态区： %p\n", &as);const char* s = "hello";printf("常量区： %p\n", s);Base b;printf("虚表：%11p\n", *((int*)&b));//int tmp = ;FUNC_PTR f = *((FUNC_PTR*)(*((int*)&b)));//测试是不是虚表项地址f();return 0;
}

每一个区都是以块的组织方式进行存贮，所以我们只需要比较虚表的地址与a\ap\as\s哪个变量的地址更加靠经就基本能判定b的虚表存储在哪个区。由上图可知，虚表地址更加靠近常量区，所以得出结论——虚表存储在常量区。