【C++】多态功能细节问题分析
多态是在不同继承关系的类对象去调用同一函数，产生了不同的行为。值得注意的是，虽然多态在功能上与隐藏是类似的，但是还是有较大区别的，本文也会进行多态和隐藏的差异分析。
- 在继承中要构成多态的条件
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的虚表存储在哪个区。由上图可知，虚表地址更加靠近常量区，所以得出结论——虚表存储在常量区。