重寫必須滿足的條件：
1. 基類中的函式使用virtual修飾，即基類中的函式為虛擬函式；
2. 派生類中與基類中的這個virtual函式要有相同的函式原型（即：返回型別相同、函式名相同、形參列表相同）；
下面我們看個簡單的程式：

#include <iostream>
using std::cout;
using std::endl;

class Person
{
public:
  virtual void Study()
  {
      cout << "這是基類中的方法" << endl;
  }
};

class Man : public Person
{
public:
    virtual void Study()
    {
        cout << "這是派生類中的方法" << endl;
    }
};

int main(void)
{
    Person *p = new Man;
    p -> Study();	// 輸出結果：這是派生類中的方法


    return 0;
}
 

Man類中的Study()函式對Person類中的Study()函式進行了重寫。 也許有些人認為：返回型別可以不同，這個我們可以做個測試，就是將Man類中的Study()方法改為返回值為int型別：

virtual void Study()
{
	cout << "這是派生類中的方法" << endl;
	return 0;
}

再次編譯，我們會發現，程式編譯都不能通過，提示返回型別衝突，重寫錯誤。

所以，重寫(Override)或覆蓋只會發生在多型中。對於基類中的非virtual函式，在派生類中重新定義只會導致隱藏。

隱藏：指的是派生類中的函式遮蔽了基類中的函式。

隱藏的規則：
1. 對於基類中的非virtual函式，如果派生類中存在和基類中相同的函式名，而不管返回值和形參列表是否相等；都會導致基類中的所有同名函式被派生類隱藏；
2. 對於基類中的virtual函式，如果派生類中存在和基類中相同的函式名，而且形參列表不同，就會導致基類中的所有同名的virtual函式被派生類隱藏；

注意：如果派生類中的函式和基類中的同名的virtual函式具有相同的形參列表和不同的返回值，那麼將不會隱藏基類中的函式，直接導致編譯錯誤（原因：編譯器此時會認為你是在重寫方法，而不是隱藏，只是返回型別寫錯了）。

下面我們看一個簡單的程式：

#include <iostream>

using std::cout;
using std::endl;

class Person
{
public:
    void Eat()
    {
        cout << "這是基類中的Eat方法" << endl;
    }


    void Work()
    {
        cout << "這是基類中不帶引數、返回值為void的Work函式" << endl;
    }

    void Work(int a)
    {
         cout << "這是基類中帶一個引數、返回值為void的Work函式" << endl;
    }

    virtual void Study()
    {
        cout << "這是基類中不帶引數的虛方法" << endl;
    }

    virtual void Study(int a)
    {
         cout << "這是基類中有一個引數的虛方法" << endl;
    }
};

class Man : public Person
{
public:
    int Work()
    {
        cout << "這是派生類中不帶引數、返回值為int的Work函式" << endl;
        return 0;
    }

    virtual  void Study(int a, int b)
    {
        cout << "這是派生類中虛的方法" << endl;
    }
};

int main(void)
{
    Man m;
    m.Eat();
 // m.Study();      //該函式已被派生類中定義的Study(int a, int b)隱藏，呼叫會導致編譯錯誤
 // m.Study(1);     //該函式已被派生類中定義的Study(int a, int b)隱藏，呼叫會導致編譯錯誤
    m.Study(1, 2);
    m.Work();
 // m.Work(1);      //該函式已被派生類隱藏中定義的Work()隱藏，呼叫會導致編譯錯誤
    return 0;
}
 

分析：在派生類中，沒有定義Eat()方法，所以派生類可以正常的呼叫基類中的Eat()方法，但是後面的Study()方法，在派生類中對其進行了定義，雖然函式原型不同，但也隱藏了基類中的所有名為Study()的函式，需要注意的是：如果派生類中的函式和基類中的同名的virtual函式具有相同的形參列表和不同的返回值，那麼將不會隱藏基類中的函式，直接導致編譯錯誤（原因：編譯器此時會認為你是在重寫方法，而不是隱藏，只是返回型別寫錯了）。關於這一點，你可以在Man中新增一個int Study()函式試一下。對於Work()函式，同樣是由於在派生類中定義了一個同名的函式，導致基類中過載的一組Work()函式都被遮蔽。

對於隱藏，我們從字面意思也可以看出，只是將基類中的同名的函式遮蔽了，並沒有將其銷燬，所以我們還是可以對其進行呼叫的。

主要有以下三種方法：

1. 在派生類中的函式中呼叫基類中的同名函式，比如：

    virtual  void Study()
    {
        Person::Study();       
    }

2. 在派生類中定義函式的前面使用using關鍵字顯式地宣告；

    using Person::Study;
    virtual void Study()
    {
        cout << "這是基類中不帶引數的虛方法" << endl;
    }

3. 採用派生類物件.基類名::基類中的方法;直接呼叫；例如：對於上面的程式，如果我們要呼叫基類中的Study()方法，我們可以這樣才呼叫：m.Person::Study(); 通過這三種方式，我們就可以訪問被派生類遮蔽了的基類中定義的函式。

總結：所謂重寫（或叫覆蓋），指的是派生類對基類中的虛擬函式進行方法體的改寫（要求函式原型相同）；而隱藏指的是，派生類中的函式遮蔽了基類中同名的所有函式。（對virtual函式，要求函式名相同，形參列表不同；對非virtual函式，函式名相同即可）。注意：在繼承中不涉及過載的概念，因為過載最基本的要求是：在相同的作用域中，而繼承顯然屬於不同作用域。