介紹虛擬函式之前，先舉一個繼承中的例項

class A
{
public:
    void show()const
    {cout<<"A";};
};
class B:public A //B繼承於A
{
public:
    void show()const
    {cout<<"B";};
};
void printfShow(A const& data)
{
    data.show();
}
int main()
{
    A a;
    B b;
    printfShow(a); //列印A
    printfShow(b); //列印A
}
 

• 通過上面的例項可以告訴我們，在有繼承的關係中，非虛擬函式的呼叫與物件無關，而是取決於類的型別，此處函式的引數型別為A，所有列印的永遠是A裡面的show()函式
• 下面舉出一個相同的例項

class A
{
    int data;
public:
    A() { data = 1; }
    void show() { cout << "A:" << data; }
};
class B:public A
{
    int data;
public:
    B() { data = 2; }
    void show() { cout << "B:" << data; }
};

int main()
{
    A a, *pa;
    B b, *pb;
    pa = &a; pa->show();//列印1
    pb = &b; pb->show();//列印2

    pa = &b; pa->show();//列印1，因為pa的型別為A
    return 0;
}

/*==================================================*/
class A
{
    int data;
public:
    A(int data) { this->data = data; }
    void show() { cout << "A:" << data; }
};
class B:public A
{
    int data;
public:
    B():A(10) { data = 2; }
    void show() { cout << "B:" << data; }
};

int main()
{
    A a(1), *pa;
    B b, *pb;
    pa = &a; pa->show();//列印1
    pb = &b; pb->show();//列印2

    pa = &b; pa->show();//列印10，還是A中的show，因為B中對A進行了構造
    return 0;
}
 

一、虛擬函式

1.概念：

在函式前面加virtual，就是虛擬函式

 2.覆蓋（重寫）：基類的虛擬函式，如果派生類有相同的函式，則子類的方法覆蓋了父類的方法(子類的函式前可省去virtual)

• 覆蓋的要求：
• 只有成員函式才可定義為虛擬函式，友元/全域性/static函式都不可以
• 函式名與引數列表相同
• 基類中函式前加virtual才可形成覆蓋，否則為隱藏
• 函式在子類和父類中的訪問許可權可以不同

3.關鍵字

• virtual：用於虛擬函式前，加在父類的函式前，子類函式前不可加
• override：用於子類虛擬函式的引數列表後，用來說明此函式為虛擬函式(父類的虛擬函式不可使用)

二、虛擬函式表

1.概念：是一塊連續的記憶體，所有虛擬函式的首地址都存放在虛擬函式表中，其大小為4位元組

2.注意

• 只有類中有虛擬函式時，才有虛擬函式表
• 父子類之間的虛擬函式表是不同的地址，且虛擬函式表中的虛擬函式的首地址也不同

class A
{
public:
    virtual void run1(){};
    virtual void run2(){};
};
class A:public B
{
public:
    virtual void run1(){};
    virtual void run2(){};
};
int main()
{
    cout<<sizeof(A); //4
    cout<<sizeof(B); //4
}

3.通過指標訪問虛擬函式表中的函式

原理：通過指標遍歷虛擬函式表然後列印虛擬函式，虛擬函式都是按照順序在記憶體中儲存的

class A
{
public:
    virtual void run1(){cout<<"A1";};
    virtual void run2(){cout<<"A2";};
};

typedef void(*pFun)();
int main()//列印一個
{
    pFun pf = NULL;
    A a;
    pf = (pFun)*((int*)*(int *)&a);
    pf();//列印run1()函式
}
int main()//列印兩個虛擬函式
{
    pFun pf = NULL;
    A a;
    for (int i = 0; i < 2; ++i)
    {
        pf = (pFun)*((int*)*(int *)&a+i);
        pf();
    }
}

三、多型

1.概念：在子類覆蓋了父類函式的情況下，用父類的指標(或引用)呼叫子類物件，或者通過父類指標呼叫覆蓋函式的時候(動態繫結)，實際上呼叫的是子類的覆蓋版本，這種現象叫做多型

2.多型的作用：多型是父類的指標呼叫完全由指向的型別決定，這樣就可以產生不同的效果

3.多型的條件

• 父子類之間有覆蓋關係
• 必須通過引用或者指標指向子類

4.程式碼演示

class A
{
    int data;
public:
    A(int data) { this->data = data; }
    virtual void show() { cout << "A:" << data; }
};
class B:public A
{
    int data;
public:
    B():A(10) { data = 2; }
    void show() { cout << "B:" << data; }
};

int main()
{
    A a(1), *pa;
    B b, *pb;
    pa = &a; pa->show();//列印A中的show
    pb = &b; pb->show();//列印B中的show

    pa = &b; pa->show();//列印B中的show(多型實現)
    return 0;
}

5.錯誤程式碼演示與更正

class A
{
    int data;
public:
    A() { data=1; }
    void show() { cout << "A:" << data; }
};
class B:public A
{
    int data;
public:
    B() { data = 2; }
    void show() { cout << "B:" << data; }
};

int main()
{
    A a;
    B pb；
    pb = (B*)&a;//將A物件轉換為B型別
    pb->show();//列印垃圾值
    return 0;
}

• 上面的程式碼，列印的是B的show()，因為沒有函式virtual關鍵字，所以函式的呼叫看的是物件型別，此處的B的型別，所以呼叫的是B的show()。但是此種做法會列印垃圾值。
• 列印垃圾值原因：B類為8位元組，A類為4位元組。B中show()函式訪問的是B類的後四節的data資料，現在pb指標指向的是4位元組的空間，後面4位元組不確定，因此為垃圾值。

• 上面的程式碼如果show函式加上virtual關鍵字，則不會產生錯誤，看如下程式碼

class A
{
    int data;
public:
    A() { data=1; }
    virtual void show() { cout << "A:" << data; }
};
class B:public A
{
    int data;
public:
    B() { data = 2; }
    void show() { cout << "B:" << data; }
};

int main()
{
    A a;
    B pb；
    pb = (B*)&a;//將A物件轉換為B型別
    pb->show();//列印1,呼叫A中的show();
    return 0;
}

• 原因：此處呼叫的是A中的show()，A中的show()訪問的是前4位元組的資料，A的data存在於前4位元組，所以列印A中的data

四、純虛擬函式(抽象類、介面)

1.基本概念：純虛擬函式一種特殊的虛擬函式，在許多情況下在基類中不對虛擬函式做出有意義的實現，而是把它定義為純虛擬函式，它的實現由派生類實現

• 格式：virtual 返回型別 函式名(引數列表)=0;

2.抽象類：包含純虛擬函式的類成為抽象類

• 特點：抽象類包含純虛擬函式，不能定義物件，只能被繼承。類中所有成員函式必須是公有的

3.介面：是抽象類的一部分，提供純虛擬函式介面

4.注意

• 純虛擬函式沒有函式體
• 純虛擬函式可以不在派生類中實現，則派生類接著作為抽象類存在

5.程式碼演示

class CNpc
{
public:
    virtual void PK()=0; //純虛擬函式
};
class CNpc_1:public CNpc
{
public:
    void PK(){
        cout<<"CNpc_1 PK";
    }
};
class CNpc_2:public CNpc
{
public:
    void PK(){
        cout<<"CNpc_2 PK";
    }
};
int main()
{
    CNpc* p1=&CNpc_1;
    p1->PK(); //呼叫CNpc_1中的函式

    CNpc* p2=&CNpc_2;
    p2->PK(); //呼叫CNpc_2中的函式
}