C++ 继承与多态(四):重载(overload)、覆盖(override)、隐藏(overhide)之间的关系
文章目录
一. 重载(overload):
限定范围:同一个类中
函数名相同,但是参数个数,或者参数类型不同则为重载。
注意:返回值类型不同并不属于重载!
class A{
public:
virtual void func();
//int func();//ERROR!overload can't be distinguished by return type;
int func(int);
int func(double);
};
二.隐藏(oversee)
限定范围:派生类
派生类的函数与基类的函数名相同,那么派生类的函数将会吧基类的函数隐藏起来,如果想使用基类中的函数,则需要使用域限定符::
class Base{
public:
void func(){
cout << "Base::func()" << endl;
}
virtual void func2(){
cout << "Base::func2()" << endl;
}
};
class Derived:public Base{
public:
//oversee 隐藏
void func(){
cout << "Derived::func()" << endl;
}
//overload 重载 ,注意,如果没有上面的func,这个func应该属于隐藏,因为两个函数不在一个类中
void func(int a){
cout << "Derived:func(int)" << endl;
}
//隐藏
void func2(int a){
cout << "Derived::func2(int)" << endl;
}
};
void test2(){
Derived b;
b.func();
b.Base::func();//oversee, 被隐藏了
b.func(1);
}
三.覆盖(override):
限定范围:有虚函数的派生类中
派生类中的函数与基类中的虚函数完全相同
注:完全相同的意思是函数名,形参,返回值完全相同
为什么要叫覆盖?
因为C继承了虚函数表之后,在虚函数表中func将原来的B中的func地址进行了覆盖,也就是更新了虚函数表
class B{
public:
virtual void func(){
cout << "B::func()" << endl;
}
};
class C:public B{
public:
//虚函数
void func(){
cout << "C::func()" << endl;
}
//这完全是一个新的函数,也不是虚函数,由于不是虚函数,不能实现动态联编
void func(int a){
cout << "C::func(int a)" << endl;
}
};
void test3(){
B* b = new C();
b->B::func();//这个操作并没有查虚函数表,而是直接调用该函数
b->func();
}
int main(){
test3();
return 0;
}
四.一个复杂继承的类判断这三种关系
区分在使用多态的过程中,什么时候是动态联编,什么时候是动态联编
在使用多态的过程中,C继承了A,B的虚函数表并进行覆盖,
多态的过程可以这样理解:new出C的对象,然后再按照A的规格,进行转换(这个时候虚函数表已经完成了覆盖,然后再向A类适配转换)
A* pa = new C(); 可以理解成 在类A中操作已经覆盖了的虚函数表,同时也有可能进行静态联编
B* pb = new C(); 可以理解成 在类B中操作已经覆盖了的虚函数表,同时也有可能进行静态联编
class A
{
public:
virtual void a() //虚函数
{
cout << "a() in A" << endl;
}
virtual void b() //虚函数
{
cout << "b() in A" << endl;
}
virtual void c() //虚函数
{
cout << "c() in A" << endl;
}
};
class B
{
public:
virtual void a() //虚函数
{
cout << "a() in B" << endl;
}
virtual void b() //虚函数
{
cout << "b() in B" << endl;
}
void c() //非虚函数
{
cout << "c() in B" << endl;
}
void d() //非虚函数
{
cout << "d() in B" << endl;
}
};
class C : public A, public B
{
public:
virtual void a() //虚函数,覆盖
{
cout << "a() in C" << endl;
}
void c()
{
cout << "c() in C" << endl;
}
void d() //非虚函数,隐藏
{
cout << "d() in C" << endl;
}
};
void test1()
{
C c;
A *pa = &c;
pa->a();
pa->b();
pa->c();
//pa->d();//ERROR! 从A继承下来的虚函数表中没有覆盖d
}
void test2(){
C c;
B *pb = &c;
pb->a();
pb->b();
pb->c();//这里实现的是静态联编,也就是直接在类B中寻找,与多态无关
pb->d();//同上
}
void test3(){
C c;
C* pc = &c;
pc->a();
//pc->b();//ERROR!编译器并不知道是哪一张虚函数表中的b()
pc->A::b();
pc->B::b();
pc->c();
pc->A::c();
pc->B::c();
pc->d();
pc->B::d();
}
int main()
{
test3();
return 0;
}