工作了好多年，才想起來寫一點筆記，我也是醉了。。。
馬上面臨面試，所以複習一下知識點，好多要點，畢竟這是個看面試不看工作能力給工資的時代=。=

面嚮物件語言的基本特性：

1. 封裝：將客觀事物抽象成類，每個類對自身的資料和方法實行protection(private, protected,public)
2. 繼承：廣義的繼承有三種實現形式：實現繼承（指使用基類的屬性和方法而無需額外編碼的能力）、可視繼承（子窗體使用父窗體的外觀和實現程式碼）、介面繼承（僅使用屬性和方法，實現滯後到子類實現）。
3. 多型：系統能夠在執行時，能夠根據其型別確定呼叫哪個過載的成員函式的能力，稱為多型性。

//例程１  
 

#include <iostream>      
using namespace 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 main()    
{    
    Vehicle a(120,4);  
    a.ShowMember();  
    Car b(180,110,4);  
    b.ShowMember();  
    cin.get();  
}

C++中允許派生類過載基類成員函式，對於過載來說，不同的類物件呼叫相應的成員函式，即系統知道a.ShowMember()呼叫的是Vehicle的成員方法，b.ShowMember()呼叫的是Car的成員方法。

但是實際使用中，會遇到這樣的情況：

//例程２  
#include <iostream>      
using namespace 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();  
}  

void main()    
{  
    Vehicle a(120,4);  
    Car b(180,110,4);  
    test(a);  
    test(b);  
    cin.get();  
}

在這種情況下，因為Vehicle是基類，所以Car類包含了Vehicle的所有屬性和方法，所以test()呼叫是沒有問題的，但是我們想要實現的效果是傳入不同的物件呼叫對應物件類的方法，但是實際上這個例子中，系統分不清你傳給test()的是哪個類的物件，所以他們都會呼叫基類的ShowMember()函式。

為了解決這個問題，就要用到多型來解決這個問題了：對於例程式１，這種能夠在編譯時就能夠確定哪個過載的成員函式被呼叫的情況被稱做先期聯編（early binding），而在系統能夠在執行時，能夠根據其型別確定呼叫哪個過載的成員函式的能力，稱為多型性，或叫滯後聯編(late binding)

//例程３  
#include <iostream>      
using namespace std;    

class Vehicle  
{    
public:    
    Vehicle(float speed,int total)  
    {  
        Vehicle::speed = speed;  
        Vehicle::total = total;  
    }  
    virtual 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;    
    }  
    virtual void ShowMember()//虛擬函式,在派生類中，由於繼承的關係，這裡的virtual也可以不加  
    {  
        cout<<speed<<"|"<<total<<"|"<<aird<<endl;  
    }  
public:    
    int aird;  
};  

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

int main()    
{    
    Vehicle a(120,4);  
    Car b(180,110,4);  
    test(a);  
    test(b);  
    cin.get();  
}

C++中的多型依賴於虛擬函式，關鍵字virtual；而java中用到的是abstract；
只要基類宣告是virtual，那麼子類就無需再聲明瞭，系統會自動新增該關鍵字，但是為了可讀性最好還是寫上吧。

虛擬函式定義需要遵循一下幾個規則：

1. 如果虛擬函式在基類與派生類中出現，僅僅是名字相同，而形式引數不同，或者是返回型別不同，那麼即使加上了virtual關鍵字，也是不會進行滯後聯編的。
2. 只有類的成員函式才能說明為虛擬函式，因為虛擬函式僅適合用與有繼承關係的類物件，所以普通函式不能說明為虛擬函式。
3. 靜態成員函式不能是虛擬函式,因為靜態成員函式的特點是不受限制於某個物件。
4. 內聯(inline)函式不能是虛擬函式，因為行內函數不能在執行中動態確定位置。即使虛擬函式在類的內部定義，但是在編譯的時候系統仍然將它看做是非內聯的。
5. 建構函式不能是虛擬函式，因為構造的時候，物件還是一片未定型的空間，只有構造完成後，物件才是具體類的例項。
6. 解構函式可以是虛擬函式,而且通常聲名為虛擬函式。

解構函式為什麼也要宣告為虛擬函式：

#include "stdafx.h"

#include <iostream>    

using namespace std;   



class Vehicle 

{   

public:  

    Vehicle(float speed,int total) 

    { 

        Vehicle::speed=speed; 

        Vehicle::total=total; 

    } 

    virtual void 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;   

    } 

    virtual void 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; 

} 

void main() 

{   

    Car *a=new Car(100,1,1); 

    a->ShowMember(); 

    DelPN(a); 

    cin.get(); 

}

從上例程式碼的執行結果來看，當呼叫DelPN(a);後，在析構的時候，系統成功的確定了先呼叫Car類的解構函式，而如果將解構函式的virtual修飾去掉，再觀察結果，會發現析構的時候，始終只調用了基類的解構函式，由此我們發現，多型的特性的virtual修飾，不單單對基類和派生類的普通成員函式有必要，而且對於基類和派生類的解構函式同樣重要。