[VC++]C++中類的多態與虛函數的使用

C++中類的多態與虛函數的使用

類的多態特性是支援物件導向的語言最主要的特性，有過非物件導向語言開發經曆的人，通常對這一章節的內容會覺得不習慣，因為很多人錯誤的認為，支援類的封裝的語言就是支援物件導向的，其實不然， Visual
BASIC 6.0是典型的非物件導向的開發語言，但是它的確是支援類，支援類並不能說明就是支援物件導向，能夠解決多態問題的語言，才是真正支援物件導向的開發的語言，所以務必提醒有過其它非物件導向語言基礎的讀者注意！

　　多態的這個概念稍微有點模糊，如果想在一開始就想用清晰用語言描述它，讓讀者能夠明白，似乎不太現實，所以我們先看如下代碼：//常式１
#include <iostream>    
usingnamespace std;  
  
class Vehicle
{  
public:  
    Vehicle(float speed,int total)
    {
        Vehicle::speed=speed;
        Vehicle::total=total;
    }
    void ShowMember()
    {
        cout<<speed<<"|"<<total<<endl;
    }
protected:  
    float speed;
    int total;
};  
class Car:public Vehicle  
{  
public:  
    Car(int aird,float speed,int total):Vehicle(speed,total)  
    {  
        Car::aird=aird;  
    }
    void ShowMember()
    {
        cout<<speed<<"|"<<total<<"|"<<aird<<endl;
    }
protected:  
    int aird;
};  

voidmain()  
{  
    Vehicle a(120,4);
    a.ShowMember();
    Car b(180,110,4);
    b.ShowMember();
    cin.get();
}
　　在c++中是允許衍生類別重載基類成員函數的，對於類的重載來說，明確的，不同類的對象，調用其類的成員函數的時候，系統是知道如何找到其類的同名成員，上面代碼中的a.ShowMember();，即調用的是Vehicle::ShowMember()，b.ShowMember();，即調用的是Car::ShowMemeber();。
　　但是在實際工作中，很可能會碰到對象所屬類不清的情況，下面我們來看一下衍生類別成員作為函數參數傳遞的例子，代碼如下：
//常式２
#include <iostream>    
usingnamespace std;  
  
class Vehicle
{  
public:  
    Vehicle(float speed,int total)
    {
        Vehicle::speed=speed;
        Vehicle::total=total;
    }
    void ShowMember()
    {
        cout<<speed<<"|"<<total<<endl;
    }
protected:  
    float speed;
    int total;
};  
class Car:public Vehicle  
{  
public:  
    Car(int aird,float speed,int total):Vehicle(speed,total)  
    {  
        Car::aird=aird;  
    }
    void ShowMember()
    {
        cout<<speed<<"|"<<total<<"|"<<aird<<endl;
    }
protected:  
    int aird;
};  

void test(Vehicle &temp)
{
    temp.ShowMember();
}

voidmain()  
{
    Vehicle a(120,4);
    Car b(180,110,4);
    test(a);
    test(b);
    cin.get();
}
　　例子中，對象a與b分辨是基類和衍生類別的對象，而函數test的形參卻只是Vehicle類的引用，按照類繼承的特點，系統把Car類對象看做是一個Vehicle類對象，因為Car類的覆蓋範圍包含Vehicle類，所以test函數的定義並沒有錯誤，我們想利用test函數達到的目的是，傳遞不同類對象的引用，分別調用不同類的,重載了的,ShowMember成員函數，但是程式的運行結果卻出乎人們的意料，系統分不清楚傳遞過來的基類對象還是衍生類別對象，無論是基類對象還是衍生類別對象調用的都是基類的ShowMember成員函數。
　　為了要解決上述不能正確分辨物件類型的問題，c++提供了一種叫做多態性（polymorphism）的技術來解決問題，對於常式序１，這種能夠在編譯時間就能夠確定哪個重載的成員函數被調用的情況被稱做先期聯編（early binding），而在系統能夠在運行時，能夠根據其類型確定調用哪個重載的成員函數的能力，稱為多態性，或叫滯後聯編(late
binding)，下面我們要看的常式３，就是滯後聯編，滯後聯編正是解決多態問題的方法。

　　代碼如下：
//常式３
#include <iostream>    
usingnamespace std;  
  
class Vehicle
{  
public:  
    Vehicle(float speed,int total)
    {
        Vehicle::speed = speed;
        Vehicle::total = total;
    }
    virtualvoid ShowMember()//虛函數
    {
        cout<<speed<<"|"<<total<<endl;
    }
protected:  
    float speed;
    int total;
};  
class Car:public Vehicle  
{  
public:  
    Car(int aird,float speed,int total):Vehicle(speed,total)  
    {  
        Car::aird = aird;  
    }
    virtualvoid ShowMember()//虛函數,在衍生類別中，由於繼承的關係，這裡的virtual也可以不加
    {
        cout<<speed<<"|"<<total<<"|"<<aird<<endl;
    }
public:  
    int aird;
};

void test(Vehicle &temp)
{
    temp.ShowMember();
}

intmain()  
{  
    Vehicle a(120,4);
    Car b(180,110,4);
    test(a);
    test(b);
    cin.get();
}
　　多態特性的工作依賴虛函數的定義，在需要解決多態問題的重載成員函數前，加上virtual關鍵字，那麼該成員函數就變成了虛函數，從上例代碼啟動並執行結果看，系統成功的分辨出了對象的真實類型，成功的調用了各自的重載成員函數。
　　多態特性讓程式員省去了細節的考慮，提高了開發效率，使代碼大大的簡化，當然虛函數的定義也是有缺陷的，因為多態特性增加了一些資料存放區和執行指令的開銷，所以能不用多態最好不用。
　　虛函數的定義要遵循以下重要規則：

　　1.如果虛函數在基類與衍生類別中出現，僅僅是名字相同，而形式參數不同，或者是傳回型別不同，那麼即使加上了virtual關鍵字，也是不會進行滯後聯編的。

　　2.只有類的成員函數才能說明為虛函數，因為虛函數僅適合用與有繼承關係的類對象，所以普通函數不能說明為虛函數。

　　3.靜態成員函數不能是虛函數,因為靜態成員函數的特點是不受限制於某個對象。

　　4.內聯(inline)函數不能是虛函數，因為內嵌函式不能在運行中動態確定位置。即使虛函數在類的內部定義定義，但是在編譯的時候系統仍然將它看做是非內聯的。

　　5.建構函式不能是虛函數，因為構造的時候，對象還是一片位定型的空間，只有構造完成後，對象才是具體類的執行個體。

　　6.解構函式可以是虛函數,而且通常聲名為虛函數。

　　說明一下，雖然我們說使用虛函數會降低效率，但是在處理器速度越來越快的今天，將一個類中的所有成員函數都定義成為virtual總是有好處的，它除了會增加一些額外的開銷是沒有其它壞處的，對於保證類的封裝特性是有好處的。
　　對於上面虛函數使用的重要規則6，我們有必要用執行個體說明一下，為什麼具備多態特性的類的解構函式，有必要聲明為virtual。

　　代碼如下：
#include <iostream>    
usingnamespace std;  
  
class Vehicle
{  
public:  
    Vehicle(float speed,int total)
    {
        Vehicle::speed=speed;
        Vehicle::total=total;
    }
    virtualvoid ShowMember()
    {
        cout<<speed<<"|"<<total<<endl;
    }
    virtual ~Vehicle()
    {
        cout<<"載入Vehicle基類解構函式"<<endl;
        cin.get();
    }
protected:  
    float speed;
    int total;
};  
class Car:public Vehicle  
{  
public:  
    Car(int aird,float speed,int total):Vehicle(speed,total)  
    {  
        Car::aird=aird;  
    }
    virtualvoid ShowMember()
    {
        cout<<speed<<"|"<<total<<"|"<<aird<<endl;
    }
    virtual ~Car()
    {
        cout<<"載入Car衍生類別解構函式"<<endl;
        cin.get();
    }
protected:  
    int aird;
};  

void test(Vehicle &temp)
{
    temp.ShowMember();
}
void DelPN(Vehicle *temp)
{
    delete temp;
}
voidmain()
{  
    Car *a=new Car(100,1,1);
    a->ShowMember();
    DelPN(a);
    cin.get();
}
　　從上例代碼的運行結果來看，當調用DelPN(a);後，在析構的時候，系統成功的確定了先調用Car類的解構函式，而如果將解構函式的virtual修飾去掉，再觀察結果，會發現析構的時候，始終只調用了基類的解構函式，由此我們發現，多態的特性的virtual修飾，不單單對基類和衍生類別的普通成員函數有必要，而且對於基類和衍生類別的解構函式同樣重要。