那麼，什麼是虛函數呢，我們先來看看微軟的解釋：
虛函數是指一個類中你希望重載的成員函數，當你用一個基類指針或引用指向一個繼承類對象的時候，你調用一個虛函數，實際調用的是繼承類的版本。 這個定義說得不是很明白。MSDN中還給出了一個例子，但是它的例子也並不能很好的說明問題。我們自己編寫這樣一個例子：
複製代碼代碼如下:
#include "stdio.h"
#include "conio.h"
class Parent
{
public:
char data[20];
void Function1();
virtual void Function2(); // 這裏聲明Function2是虛函數
}parent;
void Parent::Function1()
{
printf("This is parent,function1\n");
}
void Parent::Function2()
{
printf("This is parent,function2\n");
}
class Child: public Parent
{
void Function1();
void Function2();
} child;
void Child::Function1()
{
printf("This is child,function1\n");
}
void Child::Function2()
{
printf("This is child,function2\n");
}
int main(int argc, char* argv[])
{
Parent *p; // 定義一個基類指針
if ( _getch()=='c' ) // 如果輸入一個小寫字母c
p=&child; // 指向繼承類對象
else
p=&parent; // 否則指向基類對象
p->Function1(); // 這裏在編譯時會直接給出Parent::Function1()的 入口地址。
p->Function2(); // 注意這裏，執行的是哪一個Function2？
return 0;
}
用任意版本的Visual C++或Borland C++編譯並運行，輸入一個小寫字母c，得到下面的結果：
This is parent,function1
This is child,function2
爲什麼會有第一行的結果呢？因爲我們是用一個Parent類的指針調用函數Fuction1()，雖然實際上這個指針指向的是Child類的對象，但編譯器 無法知道這一事實（直到運行的時候，程序纔可以根據用戶的輸入判斷出指針指向的對象），它只能按照調用Parent類的函數來理解並編譯，所以我們看到了 第一行的結果。
那麼第二行的結果又是怎麼回事呢？我們注意到，Function2()函數在基類中被virtual關鍵字修飾，也就是 說，它是一個虛函數。虛函數最關鍵的特點是“動態聯編”，它可以在運行時判斷指針指向的對象，並自動調用相應的函數。如果我們在運行上面的程序時任意輸入 一個非c的字符，結果如下：
This is parent,function1
This is parent,function2
請注意看第二行，它的結果出現了變化。程序中僅僅調用了一個Function2()函數，卻可以根據用戶的輸入自動決定到底調用基類中的Function2 還是繼承類中的Function2，這就是虛函數的作用。我們知道，在MFC中，很多類都是需要你繼承的，它們的成員函數很多都要重載，比如編寫MFC應 用程序最常用的CView::OnDraw(CDC*)函數，就必須重載使用。把它定義爲虛函數（實際上，在MFC中OnDraw不僅是虛函數，還是純虛 函數），可以保證時刻調用的是用戶自己編寫的OnDraw。虛函數的重要用途在這裏可見一斑。
-----------------------------------------------------------
再看下面的
派生類的大小問題C++中虛函數和純虛函數的概念，差別和分別存在的原因
首先：強調一個概念
定義一個函數爲虛函數，不代表函數爲不被實現的函數，定義它爲虛函數是爲了允許用基類的指針來調用子類的這個函數
定義一個函數爲純虛函數，才代表函數沒有被實現，定義他是爲了實現一個接口，起到一個規範的作用，規範繼承這個類的程序員必須實現這個函數。
對繼承的影響：
普通的類（沒有虛函數，純虛函數）就可以被繼承，而且工作的相當好
關於這個問題有以下疑問：
純虛函數難道就是爲了實現接口？接口存在的意義？
我實在弄不懂，我幹嘛要預先定義好？未來的事情本難料，就等有一天我的類中需要使用某個函數，在添加一個函數不就可以？
關於實例化一個類：
有純虛函數的類是不可能生成類對象的，如果沒有純虛函數則可以。比如：
複製代碼代碼如下:
class CA
{
public:
virtual void fun() = 0; // 說明fun函數爲純虛函數
virtual void fun1();
};
class CB
{
public:
virtual void fun();
virtual void fun1();
};
// CA，CB類的實現
...
void main()
{
CA a; // 不允許，因爲類CA中有純虛函數
CB b; // 可以，因爲類CB中沒有純虛函數
...
}
---------------------------------------------------------------
虛函數在多態中間的使用：
多態一般就是通過指向基類的指針來實現的。
dog mydogwangwang;
mydogwangwang.born();
一定是返回“dog”
那麼
horse myhorsepipi;
myhorsepipi.born();
一定是返回“horse”
也是多態呀？
/////////////////////////////////////////////////
有一點你必須明白，就是用父類的指針在運行時刻來調用子類:
例如，有個函數是這樣的：
複製代碼代碼如下:
void animal::fun1(animal *maybedog_maybehorse)
{
maybedog_maybehorse->born();
}
參數maybedog_maybehorse在編譯時刻並不知道傳進來的是dog類還是horse類，所以就把它設定爲animal類，具體到運行時決定了才決定用那個函數。
也就是說用父類指針通過虛函數來決定運行時刻到底是誰而指向誰的函數。
複製代碼代碼如下:
//用虛函數
#include <iostream.h>
class animal
{
public:
animal();
~animal();
void fun1(animal *maybedog_maybehorse);
virtual void born();
};
void animal::fun1(animal *maybedog_maybehorse)
{
maybedog_maybehorse->born();
}
animal::animal()
{
}
animal::~animal()
{
}
void animal::born()
{
cout<< "animal";
}
class dog: public animal
{
public:
dog();
~dog();
virtual void born();
};
dog::dog()
{
}
dog::~dog()
{
}
void dog::born()
{
cout<<"dog";
}
class horse:public animal
{
public:
horse();
~horse();
virtual void born();
};
horse::horse()
{
}
horse::~horse()
{
}
void horse::born()
{
cout<<"horse";
}
void main()
{
animal a;
dog b;
horse c;
a.fun1(&c);
}
//output: horse
//不用虛函數
#include <iostream.h>
class animal
{
public:
animal();
~animal();
void fun1(animal *maybedog_maybehorse);
void born();
};
void animal::fun1(animal *maybedog_maybehorse)
{
maybedog_maybehorse->born();
}
animal::animal()
{
}
animal::~animal()
{
}
void animal::born()
{
cout<< "animal";
}
class dog: public animal
{
public:
dog();
~dog();
void born();
};
dog::dog()
{
}
dog::~dog()
{
}
void dog::born()
{
cout<<"dog";
}
class horse:public animal
{
public:
horse();
~horse();
void born();
};
horse::horse()
{
}
horse::~horse()
{
}
void horse::born()
{
cout<<"horse";
}
void main()
{
animal a;
dog b;
horse c;
a.fun1(&c);
}
//output: animal
---------------------------------------------------------------
有純虛函數的類是抽象類，不能生成對象，只能派生。他派生的類的純虛函數沒有被改寫，那麼，它的派生類還是個抽象類。
---------------------------------------------------------------
定義純虛函數就是爲了讓基類不可實例化化,
因爲實例化這樣的抽象數據結構本身並沒有意義.
或者給出實現也沒有意義
實際上我個人認爲純虛函數的引入,是出於兩個目的：
1.爲了安全.因爲避免任何需要明確但是因爲不小心而導致的未知的結果. 提醒子類去做應做的實現.
2.爲了效率,不是程序執行的效率,而是爲了編碼的效率.
·························································································································································································
C++虛函數與純虛函數用法與區別（轉）
1. 虛函數和純虛函數可以定義在同一個類(class)中，含有純虛函數的類被稱爲抽象類(abstract class)，而只含有虛函數的類(class)不能被稱爲抽象類(abstract class)。
2. 虛函數可以被直接使用，也可以被子類(sub class)重載以後以多態的形式調用，而純虛函數必須在子類(sub class)中實現該函數纔可以使用，因爲純虛函數在基類(base class)只有聲明而沒有定義。
3. 虛函數和純虛函數都可以在子類(sub class)中被重載，以多態的形式被調用。
4. 虛函數和純虛函數通常存在於抽象基類(abstract base class -ABC)之中，被繼承的子類重載，目的是提供一個統一的接口。
5. 虛函數的定義形式：virtual {method body}
純虛函數的定義形式：virtual { } = 0;
在虛函數和純虛函數的定義中不能有static標識符，原因很簡單，被static修飾的函數在編譯時候要求前期bind,然而虛函數卻是動態綁定(run-time bind)，而且被兩者修飾的函數生命週期(life recycle)也不一樣。
6. 虛函數必須實現，如果不實現，編譯器將報錯，錯誤提示爲：
error LNK****: unresolved external symbol "public: virtual void __thiscall
ClassName::virtualFunctionName(void)"
7. 對於虛函數來說，父類和子類都有各自的版本。由多態方式調用的時候動態綁定。
8. 實現了純虛函數的子類，該純虛函數在子類中就編程了虛函數，子類的子類即孫子類可以覆蓋
該虛函數，由多態方式調用的時候動態綁定。
9. 虛函數是C++中用於實現多態(polymorphism)的機制。核心理念就是通過基類訪問派生類定義的
函數
10. 多態性指相同對象收到不同消息或不同對象收到相同消息時產生不同的實現動作。C++支持兩種多態性：編譯時多態性，運行時多態性。
a.編譯時多態性：通過重載函數實現
b 運行時多態性：通過虛函數實現。
11. 如果一個類中含有純虛函數，那麼任何試圖對該類進行實例化的語句都將導致錯誤的產生，因爲抽象基類(ABC)是不能被直接調用的。必須被子類繼承重載以後，根據要求調用其子類的方法。
1 //father class 2 3 class Virtualbase 4 5 { 6 7 public: 8 9 virtual void Demon()= 0; //prue virtual function 10 11 virtual void Base() {cout<<"this is farther class"<}; 12 13 } 14 15 //sub class 16 17 class SubVirtual :public Virtualbase 18 19 { 20 21 public: 22 23 void Demon() { cout<<" this is SubVirtual!"< 24 25 void Base() { cout<<"this is subclass Base"< 26 27 } 28 29 /* 30 31 instance class and sample 32 33 */ 34 35 void main() 36 37 { 38 39 Virtualbase* inst = new SubVirtual(); //multstate pointer 40 41 inst->Demon(); 42 43 inst->Base(); 44 45 // inst = new Virtualbase(); 46 47 // inst->Base() 48 49 return ; 50 51 }