C++繼承中重載、重寫、重定義的區別：

重載overload：是函數名相同，參數列表不同 重載只是在類的內部存在。但是不能靠返回類型來判斷。

重寫override：也叫做覆蓋。 子類重新定義父類中有相同名稱和參數的虛函數。函數特征相同。但是具體實現不同，主要是在繼承關系中出現的 。

重寫需要注意：

1 被重寫的函數不能是static的。 必須是virtual的

2 重寫函數必須有相同的類型，名稱和參數列表

3 重寫函數的訪問修飾符可以不同。盡管virtual是private的，派生類中重寫改寫為public,protected也是可以的

 

重定義 (redefining)也叫做隱藏:

子類重新定義父類中有相同名稱的非虛函數 ( 參數列表可以不同 ) 。

如果一個類，存在和父類相同的函數，那么，這個類將會覆蓋其父類的方法，除非你在調用的時候，強制轉換為父類類型，否則試圖對子類和父類做類似重載的調用是不能成功的。 

class Base {
private:
virtual void display() { cout<<"Base display()"<<endl; }
void say(){ cout<<"Base say()"<<endl; }
public:
void exec(){ display(); say(); }
void f1(string a) { cout<<"Base f1(string)"<<endl; }
void f1(int a) { cout<<"Base f1(int)"<<endl; } //overload，兩個f1函數在Base類的內部被重載
};

class DeriveA:public Base{
public:
void display() { cout<<"DeriveA display()"<<endl; } //override，基類中display為虛函數，故此處為重寫
void f1(int a,int b) { cout<<"DeriveA f1(int,int)"<<endl; } //redefining，f1函數在Base類中不為虛函數，故此處為重定義
void say() { cout<<"DeriveA say()"<<endl; } //redefining，同上
};

class DeriveB:public Base
{
public:
void f1(int a) { cout<<"DeriveB f1(int)"<<endl; } //redefining，重定義
};

int main(){
DeriveA a;
Base *b=&a;
b->exec(); //display():version of DeriveA call(polymorphism) //say():version of Base called(allways )

b里邊的函數display被A類覆蓋，但是say還是自己的。

a.exec(); //same result as last statement   
a.say();
DeriveB c;
c.f1(1); //version of DeriveB called
}

執行結果：

 

 

 綜上所述，總結如下：

1 成員函數重載特征：
   a 相同的范圍（在同一個類中）

   b 函數名字相同

   c 參數不同

   d virtual關鍵字可有可無

2 重寫（覆蓋)是指派生類函數覆蓋基類函數，特征是：

   a 不同的范圍，分別位於基類和派生類中

   b 函數的名字相同

   c 參數相同

   d 基類函數必須有virtual關鍵字

3 重定義(隱藏)是指派生類的函數屏蔽了與其同名的基類函數，規則如下：

   a 如果派生類的函數和基類的函數同名，但是參數不同，此時，不管有無virtual，基類的函數被隱藏。

   b 如果派生類的函數與基類的函數同名，並且參數也相同，但是基類函數沒有vitual關鍵字，此時，基類的函數被隱藏。

 

注意區分虛函數中的重載和重寫：

class A{
public:
      virtual int fun(){}
};

class B:public A{
       int fun(int a){}  //這是重載而不是重寫：

}

int mian()
{

}

class B:public A{
       int fun() // 從A繼承來的 fun, 編譯器會自己偷偷幫你加上
       int fun(int a){} // 新的fun, 和前面的只是名字一樣的重載函數, 不是虛函數
}