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