C++多态、重载、覆盖、隐藏
1. 多态
在基类中定义一个虚函数,然后在派生类中又定义一个同名,同参数表的函数,这就是多态。多态采用了动态绑定技术。也就是说,通过一个基类指针来操作对象,如果对象是基类对象,就会调用基类中的那个函数,如果对象实际是派生类对象,就会调用派声类中的那个函数,调用哪个函数并不由函数的参数表决定,而是由函数的实际类型决定。
一个操作随着所传递或捆绑的对象类型的不同能够做出不同的反应,其行为模式称为多态。
c++使用滞后捆绑技术支持多态,这种技术通过预先设定其成员函数的虚函数性质,使得任何捆绑该成员函数的未定类型的对象操作在编译时,都以一个不确定的指针特殊的“引命待发”来编码,到了运行时,遇到确定类型的对象,才突然指定其真正的行为。即滞后到运行时根据具体类型的对象来捆绑成员函数。这样一来,辨别对象类型的工作就可以不用用户做了。
例子:
#include <iostream>
using namespace std;
class A
{
public:
virtual void ShowMessage();
};
class B:public A
{
public:
void ShowMessage();
};
void A::ShowMessage()
{
cout<<"This is A./n";
return;
}
void B::ShowMessage()
{
cout<<"This is B./n";
return;
}
int main()
{
A* p;
p=new A();
p->ShowMessage();
p=new B();
p->ShowMessage();
return 0;
}
输出:
This is A.
This is B.
2. 重载
成员函数被重载的特征:
- 相同的范围(在同一个类中)
-
函数名字相同
-
参数不同
-
virtual关键字可有可无
3. 覆盖
覆盖是指派生类函数覆盖基类函数。
特征是:
-
不同的范围(分别位于派生类与基类);
-
函数名字相同;
-
参数相同;
-
基类函数必须有virtual关键字。
C++的多态行为,应该就是覆盖表现出来的。
例子:
函数Base::f(int)与Base::f(float)相互重载,而Base::g(void)被Derived::g(void)覆盖。
#include <iostream>
class Base
{
public:
void f(int x)
{
std::cout << "Base::f(int) " << x <<std::endl;
}
void f(float x)
{
std::cout << "Base::f(float) " << x <<std::endl;
}
virtual void g(void)
{
std::cout << "Base::g(void)" <<std::endl;
}
};
class Derived : public Base
{
public:
virtual void g(void)
{
std::cout << "Derived::g(void)" <<std::endl;
}
};
int main(void)
{
Derived d;
Base *pb = &d;
pb->f(42); // Base::f(int) 42
d.f(42);
pb->f(3.1415926f); // Base::f(float) 3.14
d.f(3.1415926f);
pb->g(); // Derived::g( )
d.g();
return 0;
}
4. 隐藏
本来仅仅区分重载和覆盖并不算困难,但C++的隐藏规则却使问题变得较为复杂,开始难以理解了。那什么时候发生隐藏呢?
以下两种情况下会发生隐藏:(二者分别对应不能满足上述重载和覆盖条件的两种情况)
- 如果派生类函数与基类函数同名,但参数不同(特征标不同),此时,无论是否有virtual关键字,基类的所有同名函数都将被隐藏。(注:此时不满足重载条件,因为不在同一个类中)
- 如果派生类函数与基类函数同名,且参数也相同(特征标相同),但基类函数没有用virtual关键字声明,则基类的所有同名函数都将被隐藏。(注:此时不满足覆盖条件,因为基类没有声明为虚函数。)
隐藏后,在子类中便会看不到父类的函数。
4.1 隐藏存在的理由
即然隐藏如此烦人,那它有什么存在的理由吗?
先看一段代码:
#include <iostream>
class Base
{
public:
void f(int x)
{
}
};
class Derived : public Base
{
public:
void f(char *str)
{
}
};
int main(void)
{
Derived *pd = new Derived;
pd->f(10); // error
pd->Base::f(10); // right
Derived d;
d.f(10); // error
d.Base.f(10); // right
}
看上面这段代码,我们可以发现隐藏规则至少有两点存在的理由:
-
写语句pd->f(10)的人可能真的想调用Derived::f(char *)函数,只是他误将参数写错了。有了隐藏规则,编译器就可以明确指出错误,这未必不是好事。否则,编译器会静悄悄地将错就错,程序员将很难发现这个错误,流下祸根。
-
假如类Derived有多个基类(多重继承),有时搞不清楚哪些基类定义了函数f。如果没有隐藏规则,那么pd->f(10)可能会调用一个出乎意料的基类函数f。尽管隐藏规则看起来不怎么有道理,但它的确能消灭这些意外。
当然,如果语句pd->f(10)
一定要调用函数Base::f(int)
,那么将类Derived
修改为如下即可。
#include <iostream>
class Base
{
public:
void f(int x)
{
}
};
class Derived : public Base
{
public:
void f(char *str)
{
}
void f(int x)
{
Base::f(x);
}
};
int main(void)
{
//Derived *pd = new Derived;
Derived d;
d.f(10);
}
4.2 名字空间中也可能发生隐藏
不一定非得是在类中才会发生隐藏,在类外讨论时,也可能发生隐藏,比如在名字空间中。看下面这段代码:
#include <iostream>
using namespace std;
void foo(void) { cout << "global foo()" << endl; }
int foo(int x) { cout << "global foo(int)" << endl; return x; }
namespace a
{
void foo(void) { cout << "a::foo()" << endl; }
void callFoo(void)
{
foo();
//foo(10); //Can't be compiled!
}
}
int main(int argc, char** argv)
{
foo();
a::callFoo();
return 0;
}
输出:
global foo()
a::foo()
注意,名字空间a中的foo隐藏了其它作用域(这里是全局作用域)中的所有foo名称,foo(10)不能通过编译,因为全局作用域中的int foo(int)版本也已经被a::foo()隐藏了,除非使用::foo(10)显式进行调用。
这其实也告诉我们,无论何时都使用完整名称修饰(作用域解析符调用函数,或指针、对象调用成员函数),真的是一种好的编程习惯。