C++中重载、覆盖以及隐藏的区别
C++中重载、覆盖以及隐藏是经常让人混淆的三个概念。
1、重载
有两个或多个函数名相同的函数,但是函数的形参列表不同。在调用相同函数名的函数时,根据形参列表确定到底该调用哪一个函数。
重载是C++提供的一种灵活运用的操作,它不止可以用到函数,还可以运用到运算符中进行重载。
重载的函数必须位于同一个命名空间中,在类的层次上来看,每个类就相当于是一个命名空间,所以重载只能发生在同一个类中。
成员函数被重载的特征:
(1)相同的范围(在同一个类中);
(2)函数名字相同;
(3)参数不同;
(4)virtual 关键字可有可无。
举例:
class Base
{
public:
void f(int x){ cout << "Base::f(int) " << x << endl; }
void f(float x){ cout << "Base::f(float) " << x << endl; }
virtual void g(void){ cout << "Base::g(void)" << endl;}
};
int main()
{
Derived d;
d.f(42);
d.f(3.14f);
return 0;
}
运行结果:
2、覆盖
在基类中定义了一个虚拟函数,然后在派生类中又定义了一个同名同参数同返回类型的函数,这就是覆盖了。
在派生类对象上直接调用这个函数名,只会调用派生类中的那个。
覆盖是发生在不同类之间(基类和派生类)。
覆盖是指派生类函数覆盖基类函数,特征是:
(1)不同的范围(分别位于派生类与基类);
(2)函数名字相同;
(3)参数相同;
(4)基类函数必须有virtual 关键字。
举例:
class Base
{
public:
void f(int x){ cout << "Base::f(int) " << x << endl; }
void f(float x){ cout << "Base::f(float) " << x << endl; }
virtual void g(void){ cout << "Base::g(void)" << endl;}
};
class Derived : public Base
{
public:
void g(void){ cout << "Derived::g(void)" << endl;}
};
int main()
{
Derived d;
Base *pb = &d;
pb->f(42); // Base::f(int) 42
pb->f(3.14f); // Base::f(float) 3.14
pb->g(); // Derived::g(void)
return 0;
}
运行结果:
注意:此时如果将基类中函数g()前的virtual去掉,会是什么结果?答案是,这种情况不会构成覆盖。
2、覆盖
既然是和虚拟函数挂钩,说明了这个是一个多态支持的特性,所谓的覆盖指的是用基类对象的指针 或者引用时访问虚拟函数的时候会根据实际
的类型决定所调用的函数,因此此时派生类的成员函数可以"覆盖"掉基类的成员函数. 注意唯有同名且参数相同还有带有virtual关键字并且分别
在派生类和基类的函数才能构成虚拟函数,这个也是派生类的重要特征. 而且,由于是和多态挂钩的,所以只有在使用类对象指针或者引用的时候
才能使用上. 总之一句话:覆盖函数都是虚函数,反之不然~~ (如果基类和继承类的函数名称,产生返回值都是一样的[如果返回值不同应该无法
编译],如果基类用到了virtual,那么无论继承类的实现中是否加入virtual 这个keyword ,还是会构成覆盖的关系)。
多态:
在基类中定义了一个虚拟函数,然后在派生类中又定义一个同名,同参数表的函数,这就是多态。多态是这3种
情况中唯一采用动态绑定技术的一种情况。也就是说,通过一个基类指针来操作对象,如果对象是基类对象,
就会调用基类中的那个函数,如果对象实际是派生类对象,就会调用派声类中的那个函数,调用哪个函数并不
由函数的参数表决定,而是由函数的实际类型决定。
举例:
class A { public: virtual void ShowMessage(){cout<<"Hello,This is A.\n";} // 分析加不加virtual的区别 }; class B:public A { public: void ShowMessage(){cout<<"Hello,This is B.\n";} }; int main() { A* p; p=new A(); p->ShowMessage(); p=new B(); p->ShowMessage(); return 0; }
运行结果:
3、隐藏
指的是派生类的成员函数隐藏了基类函数的成员函数.隐藏一词可以这么理解:在调用一个类的成员函数的时候,编译器会沿着类的继承链逐级
的向上查找函数的定 义,如果找到了那么就停止查找了,所以如果一个派生类和一个基类都有同一个同名(暂且不论参数是否相同)的函数,而编
译器最终选择了在派生类中的函数,那么我们就说这个派生类的成员函数"隐藏"了基类的成员函数,也就是说它阻止了编译器继续向上查找函数
的定义。回到隐藏的定义中,前面已经说了有virtual关键字并且分别位于派生类和基类的同名,同参数函数构成覆盖的关系,因此隐藏的关系只有
如下的可能:
1)必须分别位于派生类和基类中 ;
2)必须同名;
3)参数不同的时候本身已经不构成覆盖关系了,所以此时是否是virtual函数已经不重要了。
当参数相同的时候就要看时候有virtual关键字了,有的话就是覆盖关系,没有的时候就是隐藏关系了很多人分辨不清隐藏和覆盖的区别,因为他们
都是发生在基类和派生类之中的.但是它们之间最为重要的区别就是: 覆盖的函数是多态的,是存在于vtbl之中的函数才能构成"覆盖"的关系,而
隐藏的函数都是一般的函数,不支持多态,在编译阶段就已经确定下来了。
直接使用类对象才会出现隐藏。
举例:
struct foo
{
void func(int x)
{
cout <<"foo::func(int)"<<endl;
}
void func(float x)
{
cout <<"foo::func(float)"<<endl;
}
void func(double x)
{
cout <<"foo::func(double)"<<endl;
}
};
struct a
{
void func(int x)
{
cout <<"struct a :: fun(int x)"<<endl;
}
};
struct b : public a
{
void func(float x)
{
cout <<"struct b::fun(float x)"<<endl;
}
};
struct c : public b
{
//using a::func;
//using b::func;
void func(double x)
{
cout <<"struct c::func(double x)"<<endl;
}
};
int main()
{
foo fo;
fo.func(1);
fo.func((float)1);
c oc; // 直接根据类对象来调用
oc.func(1);
oc.func((float)1);
}
注意:怎么样取消隐藏?可以申明出基类命名空间(每个类都相当于是一个独立的命名空间),这样隐藏就变成了重载,因为不同的函数成
为了一个命名空间(注意,此时基类和派生类中的同名函数的参数一定要不同)。
struct foo
{
void func(int x)
{
cout <<"foo::func(int)"<<endl;
}
void func(float x)
{
cout <<"foo::func(float)"<<endl;
}
void func(double x)
{
cout <<"foo::func(double)"<<endl;
}
};
struct a
{
void func(int x)
{
cout <<"struct a::fun(int x)"<<endl;
}
};
struct b : public a
{
void func(float x)
{
cout <<"struct b::fun(float x)"<<endl;
}
};
struct c : public b
{
using a::func;
using b::func;
void func(double x)
{
cout <<"struct c::func(double x)"<<endl;
}
};
int main()
{
foo fo;
fo.func(1);
fo.func((float)1);
c oc;
oc.func(1);
oc.func((float)1);
}
运行结果:
总结:在基类和派生类中,如果直接使用类对象进行操作,容易引起隐藏。当使用指针调用类的操作时,如果该成员函数已用virtual进行
了声明,那么会发生覆盖,这时候具体的操作应该依据指针所指的对象类型;反之,当没有virtual时,不会发生覆盖,这时候具体的操作
要依据指针的类型来进行判断。
举例:
class Base
{
public:
virtual void f(float x){ cout << "Base::f(float) " << x << endl; }
void g(float x){ cout << "Base::g(float) " << x << endl; } // 加不加virtual没有关系,派生类与基类该函数的参数不同
void h(float x){ cout << "Base::h(float) " << x << endl; }
};
class Derived : public Base
{
public:
virtual void f(float x){ cout << "Derived::f(float) " << x << endl; }
void g(int x){ cout << "Derived::g(int) " << x << endl; }
void h(float x){ cout << "Derived::h(float) " << x << endl; }
};
int main()
{
Derived d;
Base *pb = &d;
Derived *pd = &d;
// Good : behavior depends solely on type of the object(定义为虚函数virtual)
pb->f(3.14f); // Derived::f(float) 3.14
pd->f(3.14f); // Derived::f(float) 3.14
// Bad : behavior depends on type of the pointer(未定义为虚函数virtual)
pb->g(3.14f); // Base::g(float) 3.14
pd->g(3.14f); // Derived::g(int) 3 (surprise!)
// Bad : behavior depends on type of the pointer
pb->h(3.14f); // Base::h(float) 3.14 (surprise!)(未定义为虚函数virtual)
pd->h(3.14f); // Derived::h(float) 3.14
// 隐藏基类的操作
d.f(3.14f);
d.g(3.14f);
d.h(3.14f);
return 0;
}
运行结果:
最后,再提醒一个值得注意的地方,经常遇到的虚析构函数,实质上就是覆盖操作。虚析构函数(基类的析构函数前+virtual)的使用主要
是为了防止内存的泄露,详情见我上篇博文《深度解析构造函数和析构函数》(http://blog.csdn.net/shenbo2030/article/details/44
588203)。
举例:
class ClxBase
{
public:
ClxBase() {};
virtual ~ClxBase() {cout << "Output from the destructor of class ClxBase!" << endl;} // 加不加virtual的区别
virtual void DoSomething() { cout << "Do something in class ClxBase!" << endl; } // 加不加virtual的区别
};
class ClxDerived : public ClxBase
{
public:
ClxDerived() {};
~ClxDerived() { cout << "Output from the destructor of class ClxDerived!" << endl; }
void DoSomething() { cout << "Do something in class ClxDerived!" << endl; }
};
int main()
{
//ClxBase Test;
ClxBase *pTest = new ClxDerived;
pTest->DoSomething();
delete pTest;
return 0;
}