C++ Exceptional 类的重载、重写（覆盖）和隐藏

通过下面这个例子可以很好的理解重载、重写（覆盖）和隐藏的关系：

class Base{public:    virtual ~Base() {}    virtual void f(int);    virtual void f(double);    virtual void g(int i = 10);};void Base::f(int){    cout << "Base::f(int)" << endl;}void Base::f(double){    cout << "Base::f(double)" << endl;}void Base::g(int i){    cout << "Base::g(int)" << i << endl;}class Derived : public Base{public:    void f(complex<double>);    void g(int i = 20);};void Derived::f( complex<double> ){    cout << "Derived::f(complex)" << endl;}void Derived::g(int i){    cout << "Derived::g()" << i << endl;}int main(int argc, char * argv[]){    Base b;    Derived d;    Base* pb = new Derived;    b.f(1.0);    d.f(1.0);    pb->f(1.0);    b.g();    d.g();    pb->g();    delete pb;}

下面分别解释以上程序的输出：
1. b.f(1.0) Base::f(double)
2. d.f(1.0) Derivedf(complex)
3. pb->f(1.0) Base::f(double)
4. b.g() Base::g(int) 10
5. d.g() Derived::g(int) 20
6. pb->g() Derived::g(int) 10

重载： Base中的f(int)和f(double) 为重载关系，重载为在同一个类中，具有相同的函数名，但函数参数不同。

重写（覆盖）： Derived中的g(int i = 20) 重写了基类Base中 g(int i = 10)，但这里要注意的是，当用一个指向子类的基类指针调用g(int) 时，默认的参数是静态绑定的，也就是基类Base中的 i = 10 是静态绑定的，所以 6 才会输出 Derived::g(int) 10

隐藏： Derived中的f( complex<double> ) 隐藏了子类中的同名函数。注意这里并不是重写，因为他们的参数不同。但子类中的函数会隐藏父类中的同名函数。所以 2 3 的输出分别如上。pb->f(1.0)并不会调用Derived中的f(complex<double>) 函数，因为这两者这件的关系并不是重写，而是隐藏，所以调用的仍然是Base中的函数。