多態與虛函數的使用

多態性
1.編譯時的多態性：通過函數的重載和運算符的重載實現
2.運行時的多態性：在程序執行前，無法根據函數名和參數來確定該調用哪個函數，必須在程序執行過程中，根據執行的具體情況來動態的確定。它是通過類繼承關系和虛函數來實現的。目的也是建立一種通用的程序。通用性是程序追求的主要目標之一。

虛函數是類的成員函數，定義格式如下
virtual 返回類型 函數名（參數表）

關鍵字virtual指明該函數為虛函數，virtual只用於在類內部聲明，若函數在類外部實現則不需要再加virtual關鍵字。
如果某一個類的一個類成員方法被定義為虛函數，則由該類派生出來的所有派生類中，該函數始終保持虛函數的特征。

//Test1.h
#include<iostream>
using namespace std;
class Fish
{
public:
    Fish(){cout<<"This is Fish built. "<<endl;}
    virtual ~Fish(){cout<<"This is Fish free. "<<endl;}//析構函數可定義為虛函數，構造函數不可以定義為虛函數，因為在調用構造函數時對象還沒有完成實例化。在基類中及其派生類中都動態分配內存空間時，必須把析構函數定義為虛函數，實現撤銷對象時的多態性。
    virtual void water();//派生類中定義虛函數必須與基類中的虛函數同名外，還必須同參數列表，
    virtual void eat();//同返回類型。否則會被認為是重載，而不是虛函數。
    virtual Fish* fish();//如基類中返回基類指針，派生類中返回派生類指針是允許的，這是一個例外
};
class Shark : public Fish
{
public:
    Shark(){cout<<"This is Shark built. "<<endl;}
    ~Shark(){cout<<"This is Shark free. "<<endl;}
    Shark* fish();
    void water();
    void eat();
};
class Whale : public Fish
{
public:
    Whale(){cout<<"This is Whale built. "<<endl;}
    ~Whale(){cout<<"This is Whale free. "<<endl;}
    Whale* fish();
    void water();
    void eat();
};
void Fish::eat(){cout<<"Fish eat. "<<endl;}//如果定義放在類外部，virtual只能加在函數聲明前面，不能加在函數定義前面。正確的定義必須不包括virtual。
void Fish::water(){cout<<"Fish water. "<<endl;}
Fish* Fish::fish(){cout<<"This is fish*. "<<endl;return this;}

void Shark::eat(){cout<<"Shark eat. "<<endl;}
void Shark::water(){cout<<"Shark water. "<<endl;}
Shark* Shark::fish(){cout<<"This is shark*. "<<endl;return this;}

void Whale::eat(){cout<<"Whale eat. "<<endl;}
void Whale::water(){cout<<"Whale water. "<<endl;}
Whale* Whale::fish(){cout<<"This is whale*. "<<endl;return this;}

void Fun(Fish *f)
{
    f->eat();
    f->water();
    f->fish();
}

 虛函數需要注意的幾點
1.派生類中定義虛函數必須與基類中的虛函數同名外，還必須同參數列表，同返回類型。否則會被認為是重載，而不是虛函數。如基類中返回基類指針，派生類中返回派生類指針是允許的，這是一個例外。

(該例外是指，只存在一個僅返回類型不同的虛函數，且該虛函數返回值必須分別為基類指針和派生類指針)

2.只有類的成員函數才能說明為虛函數。這是因為虛函數僅適用於有繼承關系的類對象。

3.靜態成員函數，是所有同一類對象共有，不受限於某個對象，不可作為虛函數。

4.一個類對象的靜態和動態類型是相同的，實現動態特性時，必須使用基類類型的指針變量或引用，使該指針指向該基類的不同派生類的對象，並通過該指針指向虛函數，才能實現動態的多態性。

5.內聯函數每個對象一個拷貝，無映射關系，不能作為虛函數。

6.析構函數可定義為虛函數，構造函數不可以定義為虛函數，因為在調用構造函數時對象還沒有完成實例化。在基類中及其派生類中都動態分配內存空間時，必須把析構函數定義為虛函數，實現撤銷對象時的多態性。

7.函數執行速度要稍慢一些，為了實習多態性，每一個派生類中均要保存相應的虛函數的入口地址表，函數的調用機制也是間接實現。所以多態性總是要付出一些代價，但是通用性是一個更高的目標。

8.如果定義放在類外部，virtual只能加在函數聲明前面，不能加在函數定義前面。正確的定義必須不包括virtual。

 

//Test.cpp
#include"Test1.h"
void main()
{
    Fish *f = new Shark;//一個類對象的靜態和動態類型時相同的，實現動態特性時，必須使用基類類型的指針變量或引用，
    Whale w;
    Fish &f1 = w;//使該指針指向該基類的不同派生類的對象，並通過該指針指向虛函數，才能實現動態的多態性。
    Fun(f);
    Fun(&f1);
    delete f;//在基類中及其派生類中都動態分配內存空間時，必須把析構函數定義為虛函數，實現撤銷對象時的多態性。 }

 運行結果為

 

 

2019/12/19補充

例題，嘗試寫出下列程序的運行結果

class A
{
public:
 void FuncA()
 {
     printf( "FuncA called\n" );
 }
 virtual void FuncB()
 {
     printf( "FuncB called\n" );
 }
};
class B : public A
{
public:
 void FuncA()
 {
     A::FuncA();
     printf( "FuncAB called\n" );
 }
 virtual void FuncB()
 {
     printf( "FuncBB called\n" );
 }
};
void main( void )
{
 B  b;
 A  *pa;
 pa = &b;
 A *pa2 = new A;
 pa->FuncA(); （ 3）
 pa->FuncB(); （ 4）
 pa2->FuncA(); （ 5）
 pa2->FuncB();
 delete pa2;
}

 

 

解析：

父類指針指向子類實例對象，調用普通重寫方法時，會調用父類中的方法。而調用被子類重寫虛函數時，會調用子類中的方法。

再次說明了，子類中被重寫的虛函數的運行方式是動態綁定的，與當前指向類實例的父類指針類型無關，僅和類實例對象本身有關。

 

 

父類指針指向子類實例對象，調用普通重寫方法時，會調用父類中的方法， 所以pa->FuncA()會調用父類中的FuncA， 而調用被子類重寫虛函數時，會調用子類中的方法， 所以pa->FuncB()則調用的是子類整的FuncB

 

正確調用順序為

 

FuncA called

FuncBB called

FuncA called

FuncB called